groovy闭包

Groovy是增强Java平台的唯一的脚本语言。它提供类似于Java的语法，内置映射（Map）、列表（List）、方法、类、闭包（closure）以及生成器。
Groovy是动态弱类型语言，即Groovy不要求声明变量的类型、方法的参数或者方法的返回值。这意味着在不同环境下，变量可以以多种方式使用。
Groovy类和Java是二进制兼容的。这意味着Groovy编译器产生的字节码与Java编译器产生的字节码是完全一样的。因此，对JVM而言，Groovy和Java是完全一样的。
Groovy是一门面向对象的语言。


数值和表达式
两个整数的除法运算通常会产生一个浮点数，即使其结果可能是一个整数。
如表达式6/3的结果是浮点数2.0，而不是整数2.

为了获得两个整型值相除的整数部分，必须调用intdiv方法：
13.intdiv(5)
该表达式的结果是整数2.

使用取模运算符（%）可以得到两个整数操作数相除的余数。但是对一个浮点数求模，或者对一个含有浮点数参数的整数求模都是非法的。

在Groovy中，第一次使用某个变量时，需要使用def关键字来声明变量。
变量的命名规则：可以由字母、数字和下划线组成，对大小写敏感，首字符必须是字母。


字符串和正则表达式
在Groovy中，可以使用单引号('abc')、双引号("abc")、或者三引号('''abc''')来封装字符串。使用三引号表示的字符串可以包含多行文本。
使用单引号封装的字符串的值就是所列出的字符序列本身。而在双引号和三引号中，任何包含在解释型字符串中的${expression}都将被求值，
其结果是字符串的一部分。如：
def age = 25
'My age is ${age}'      //My age is ${age}
"My age is ${age}"      //My age is 25
'''My age is ${age}'''  //My age is 25
"My age is \${age}"     //My age is ${age}

通用的原则是，只在字符串需要被解释的时候使用双引号，在其他情况下字符串使用单引号。

闭包常用方法demo，直接贴代码demo.groovy，运行时直接输入groovy demo.groovy：

[java] view plain copy

1. // groovy中的闭包及常用方法  
2. // 闭包的两种写法：  
3. // 1. 有参数的闭包：def clos = {参数名 -> 代码块}  
4. // 2. 无参数的闭包：def clos = {代码块}  
5. /****************************************************/  
6.   
7. def hello = 'Hello'  
8. def clos = {  
9.     param -> println "${hello}, ${param}"  
10. }  
11. def clos2 = {  
12.     p1, p2 -> println "the parameters are ${p1} and ${p2}"  
13. }  
14.   
15. def demo(clo) {  
16.     clo('zyf')  
17. }  
18.   
19. // 闭包的调用方式  
20. clos.call("zyf")  
21. clos('zyf')  
22. clos'zyf'  
23. clos2(1,2) // 也可以写成：clos2 1,2  
24. // 参数有闭包的方法的调用方式  
25. demo(clos)  
26. demo clos  
27. demo{  
28.     param -> println "hello , ${param}"  
29. }  
30. /********输出结果********/  
31. //Hello, zyf  
32. //Hello, zyf  
33. //Hello, zyf  
34. //the parameters are 1 and 2  
35. //Hello, zyf  
36. //Hello, zyf  
37. //hello , zyf  
38. /********输出结果********/  
39.   
40. /****************************************************/  
41.   
42. // upto方法无参数时表示循环几次(如：从1循环到3)，有参数时，参数从几递增到几(如：从3递增到4)  
43. 1.upto(3) {  
44.     println "abc"  
45. }  
46.   
47. def count = 0  
48. 3.upto(4) {  
49.     p -> count += p  
50. }  
51. println "count: ${count}"  
52. /********输出结果********/  
53. //abc  
54. //abc  
55. //abc  
56. //count: 7  
57. /********输出结果********/  
58.   
59. /****************************************************/  
60.   
61. // each方法常常用于列表、映射和字符串，以遍历每个元素，并将闭包应用于每个元素  
62. [1, 2].each {  
63.     println it  
64. }  
65.   
66. ['zhangsan' : 21, 'lisi' : 22].each {  
67.     println it  
68. }  
69.   
70. ['zhangsan' : 21, 'lisi' : 22].each {  
71.     println "${it.key} maps to : ${it.value}"  
72. }  
73.   
74. ['zhangsan' : 21, 'lisi' : 23].each {  
75.     p -> if (p.value > 22) {  
76.         println "${p.key} value over 22"  
77.     } else {  
78.         println "${p.key} value low 23"  
79.     }  
80. }  
81. /********输出结果********/  
82. //1  
83. //2  
84. //zhangsan=21  
85. //lisi=22  
86. //zhangsan maps to 21  
87. //lisi maps to 22  
88. //zhangsan value low 23  
89. //lisi value over 22  
90. /********输出结果********/  
91.   
92. /****************************************************/  
93.   
94. // find方法返回集合中符合某个判断标准的第一个值，若不存在则符合null。在闭包中，集合元素使用的判断条件必须是布尔表达式。  
95. def f = [1, 2].find {  
96.     it -> it > 1  
97. }  
98. println "find : ${f}"  
99. /********输出结果********/  
100. //find 2  
101. /********输出结果********/  
102.   
103. /****************************************************/  
104.   
105. // findAll方法将遍历所有元素，并返回一个符合条件的列表。  
106. def fa = ['zhangsan' : 21, 'lisi' : 23, wangwu : 24].findAll {// map的key默认都是字符串，故可以不用单引号或双引号  
107.     it -> it.value > 22  
108. }  
109. println "find all : ${fa}"  
110. fa.each {  
111.     println it  
112. }  
113.   
114. [1, 2, 3].findAll {  
115.     it -> it > 1  
116. }.each {  
117.     println it  
118. }  
119. /********输出结果********/  
120. //find all [lisi:23,wangwu:24]  
121. //lisi=23  
122. //wangwu=24  
123. //2  
124. //3  
125. /********输出结果********/  
126.   
127. /****************************************************/  
128.   
129. // any方法将遍历检查集合的每个元素，以确认：对至少一个元素来说，由闭包提供的布尔断言是否合法。  
130. def a = [1, 2].any {  
131.  it -> it > 1  
132. }  
133. println "any one over 1? ${a}"  
134. /********输出结果********/  
135. //any one over 1? true  
136. /********输出结果********/  
137.   
138. /****************************************************/  
139.   
140. // every方法则用来检查：对集合的所有元素来首，闭包提供的布尔断言是否合法。  
141. def e = [1, 2].every {  
142.     it -> it >1  
143. }  
144. println "every one over 1? ${e}"  
145. /********输出结果********/  
146. //every one over 1? false  
147. /********输出结果********/  
148.   
149. /****************************************************/  
150.   
151. // collect方法将遍历某个集合，并使用闭包中的变换方法将集合中的每个元素转换为一个新值。返回一个由转换后的值所组成的列表。  
152. def list = [1, 2, 3, 4].collect {  
153.     it -> return it * it  
154. }  
155. println "list: ${list}"  
156.   
157. list = (0..2).collect {// ..表示范围，从start到end的值，这里表示(0, 1, 2)  
158.     it -> 2 * it  
159. }  
160. println "list:${list}"  
161.   
162. list = (0..<2).collect {// ..<也表示范围，但是不包含右边界值，这里表示(0, 1)  
163.     it -> 3 * it  
164. }  
165. println "list:${list}"  
166.   
167. def s = ['zhangsan' : 21, 'lisi' : 22]  
168. list = s.collect {  
169.     it -> ++it.value  
170. }  
171. def olderS = s.collect {  
172.     it -> ++it.value  
173.     return it  
174. }  
175. println "s : ${s}"  
176. println "list : ${list}"  
177. println "olderS : ${olderS}"  
178. /********输出结果********/  
179. //list: [1, 4, 9, 16]  
180. //list:[0, 2, 4]  
181. //list:[0, 3]  
182. //s : [zhangsan:23, lisi:24]  
183. //list : [22, 23]  
184. //olderS : [zhangsan=23, lisi=24]  
185. /********输出结果********/  
186.   
187. /****************************************************/  
188.   
189. // inject方法可用于遍历集合，首先将需要传递的初始值和集合项目传递给闭包，此时其传递的初始值将作为初始结果，  
190. // 然后再和下一个集合元素一起传给闭包，以此类推。  
191. def factorial = [2, 3, 4].inject(1) {  
192.     previous, element ->   
193.         println "pre: ${previous}, ele: ${element}"  
194.         previous * element // 这里的previous分别是上次计算的结果值1,2,6;element分别是集合元素2,3,4  
195. }  
196. println "Factorial(4) : ${factorial}"  
197. /********输出结果********/  
198. //pre: 1, ele: 2  
199. //pre: 2, ele: 3  
200. //pre: 6, ele: 4  
201. //Factorial(4) : 24  
202. /********输出结果********/  
203.   
204. /****************************************************/  
205.   
206. // 闭包作为返回值  
207. def multiply(x) {  
208.     return {  
209.         y -> return x * y  
210.     }  
211. }  
212. def twice = multiply(2)  
213. println "twice(3) = ${twice(3)}" // 这里的twice(3)相当于multiply(2)(3)，后面的3是传递给作为返回值的闭包的参数  
214. /********输出结果********/  
215. //twice(3) = 6  
216. /********输出结果********/  
217.   
218. /****************************************************/  
219.   
220. // 冒泡排序  
221. def swap = {  
222.     sList, p, q ->  
223.         def temp = sList[p]  
224.         sList[p] = sList[q]  
225.         sList[q] = temp  
226.     }  
227. def minPosition = {  
228.     pList, from ->  
229.         def mPos = from  
230.         def nextFrom = from + 1  
231.             for (i in nextFrom..<pList.size()) {  
232.                 if (pList[i] < pList[mPos]) {  
233.                     mPos = i  
234.                 }  
235.             }  
236.         return mPos  
237.     }  
238. def selectionSort = {  
239.     l ->  
240.         def size = l.size() - 1  
241.         for (j in 0..<size) {  
242.             def minPos = minPosition(l, j)  
243.             swap(l, minPos, j)  
244.         }  
245.         return l  
246. }  
247.   
248. def table = [2, 4, 1, 3]  
249. def sorted = selectionSort(table)  
250. println "sorted : ${sorted}"  
251. /********输出结果********/  
252. //sorted : [1, 2, 3, 4]  
253. /********输出结果********/  
254.   
255. /****************************************************/  
256. /****************************************************/  
257.   
258. // 文件操作  
259. println "str's length:" + "a c d d".tokenize().size() // tokenize切分词返回列表，如[a, c, d, d]  
260. /********输出结果********/  
261. //str's length:4  
262. /********输出结果********/  
263.   
264. /****************************************************/  
265.   
266. // File类提供了eachFile方法，用来表示某个目录的文件对象，它接收闭包作为其参数，且对该目录中每个文件调用此闭包  
267. def listDir(dirFile, indent) {  
268.     dirFile.eachFile {  
269.         file ->  
270.             (0..<indent).each {  
271.                 print " "  
272.             }  
273.             println "${file.getName()}"  
274.             if (file.isDirectory()) {  
275.                 listDir(file, indent + 2)  
276.             }  
277.     }  
278. }  
279.   
280. def printDir(dirName) {  
281.     listDir(new File(dirName), 0)  
282. }  
283.   
284. // 命令行调用时，参数跟在文件名后，如：groovy demo.groovy c:\Users\...\Desktop  
285. /* 
286. if (args.size() != 1 || new File(args[0]).isDirectory() == false) { 
287.     println "please enter a directory" 
288. } else { 
289.     printDir(args[0]) 
290. } 
291. */  
292.   
293. /****************************************************/  
294.   
295. // File类提供了eachFileRecurse方法，它可以遍历某个目录中的所有文件，并且递归遍历子目录  
296. def printDir2(dirName, size) {  
297.     new File(dirName).eachFileRecurse {  
298.         file ->  
299.             if (file.getName().size() > size) // 遍历查找文件名大于给定长度的文件  
300.                 println "the file ${file.getName()} name's size over ${size}"  
301.     }  
302. }  
303.   
304. /* 
305. if (args.size() != 2 || new File(args[0]).isDirectory() == false) 
306.     println "please enter 2 right args!" 
307. else 
308.     printDir2(args[0], args[1].toInteger()) 
309. */  
310.   
311. /****************************************************/  
312.   
313. // xml解析  
314. // 文件library.xml的内容：  
315. //<library>  
316. //  <book>  
317. //      <title id='111'>java</title>  
318. //  </book>  
319. //  <book>  
320. //      <title id='222'>c</title>  
321. //  </book>  
322. //</library>  
323. def doc = new XmlParser().parse('library.xml')  
324. println "${doc.book[0].title.text()}"  
325. doc.book.each { // 遍历每一个book节点  
326.     it -> println "${it.title.text()}"  
327. }  
328. doc.book.title.each { // 遍历每一个book节点的每一个title节点  
329.     it -> println "${it.text()}"  
330. }  
331. println doc.book.title[0]['@id']  
332. println doc.book.title['@id']  
333. /********输出结果********/  
334. //java  
335. //java  
336. //c  
337. //java  
338. //c  
339. //111  
340. //[111, 222]  
341. /********输出结果********/