Groovy闭包详解

Groovy闭包是一种可执行代码块的方法，闭包也是对象，可以向方法一样传递参数，因为闭包也是对象，因此可以在需要的时候执行，像方法一样闭包可以传递一个或多个参数。闭包最常见的用途就是处理集合，可以遍历某个集合，并将对元素的操作作用于遍历出来的集合元素上。

闭包的语法是{comma-separated-form-parameter-list ->statement-list},如果不需要形参则可以省略->间隔符

下面是最简单的闭包形式

1 def cols={
2             println "Hello Word！"
3         }
4cols.call()

带参闭包

1 def cols2={param->
2             println "${param}"
3         }
4cols2("哈哈")

单个隐参数

def cols3={
            println "Hello ${it}"
        }
 cols3("二狗")

闭包在定义的时候就能访问外部的属性值

1 def greeting="Hello"
2 def cols4={param->
3 println "${greeting},${param}"
4  }
5  cols4("二狗")

闭包也常用在集合中，使用闭包可以更加的高效的遍历集合的元素，并将闭包应用到每个元素中去。

1 [1,2,3,4,5].each { println it}
2 ['张三':100,'李四':200,'王五':300].each { println it}
3 ['张三':100,'李四':200,'王五':300].each { println it.key+":"+it.value}

也可以根据条件对集合进行筛选

1  [1,2,3,4].each {num-> if(num%2==0) println num}
2 ['张三':100,'李四':200,'王五':300].each {if(it.value==200) {println it}}

find方法返回集合中符合某个判断标准的第一个值，在闭包中，集合元素使用的判断条件必须是bool表达式

1 def num = [1,2,3,4].find{p->p>2}
2 println num
3 def map=['张三':100,'李四':200,'王五':300].find {it.value>100}
4 println map

findAll方法是遍历所有的元素并返回一个符合条件的列表

1 num = [1,2,3,4].findAll {p->p>2}
2 println num
3 map = ['张三':100,'李四':200,'王五':300].findAll {it.value>100}
4 println map

collect用法：collect将遍历某个集合，并使用闭包中的变换方法将集合中的元素转换成一个新值，collect方法返回的是由转换后的值所组成的列表

1 def  staff= ["李铭":10,"李浩":20,"二狗":50]
2 list=staff.collect {e->++e.value}
3 println "staff:${list}"
4 staff = staff.collect {e->++e.value;return e}
5 println staff

inject用法：inject可用于遍历集合，首先将需要传递的值和集合中遍历出来的元素传给闭包，此时其传递的值将作为一个处理结果然后在和下一个集合元素一起传给闭包，依次类推

1 def factories = [2,3,4,5].inject(1){p,e->p*e}
2 println "factories1:${factorials}"
3 list = [2,3,4,5]
4 def clos6 = {p,e->p*e}
5 factories = list.inject (1,clos6)
6 println "factories2:${factories}"

闭包可以作为方法的参数使用

 1 def filter(list ,predicate){
 2  return list.findAll(predicate)
 3 }
 4 def isEven={x-> return (x%2==0)}
 5 def isOdd={x-> return !isEven(x)}
 6 def table =[11,12,13,14]
 7 def evens = filter(table,isEven)
 8 def odds = filter(table,isOdd)
 9 println "even:${evens}"
10 println "odds:${odds}"

闭包也可以作为另一个闭包的参数使用

 1 def takewhile = { predicate, list ->
 2 def reslut = []
 3 for (element in list) {
 4 if (predicate(element)) {
 5 reslut << element
 6  }
 7 }
 8 return reslut
 9  }
10 def isEven = { x -> return (x % 2 == 0)}
11 def isOdds = { x -> return !isEven(x) }
12 def table = [45, 65, 81, 15, 22, 16]
13 def evens = takewhile(isEven, table)
14 println evens
15 def odds = takewhile(isOdds, table)
16 println odds

闭包作为返回值

1 //定义一个函数，函数的返回值是个闭包
2 def twice(x)
3 { return {y-> return x*y}}
4 //定义一个闭包接收函数的返回值,闭包里面的返回值是两个参数的乘积
5 def multiply =twice(2)
6 //闭包所带的参数就是twice()函数里面的返回值里面的参数
7 println "multiply(4):${multiply(4)}"

使用Groovy闭包进行选择排序

 1 //选择排序
 2         //定义一个闭包select
 3         def select={list->
 4             //定义swap闭包实现集合元素的交换
 5             def swap={
 6                 x,y,slist->
 7                     def temp=slist[x]
 8                     slist[x]=slist[y]
 9                     slist[y]=temp
10 
11             }
12             //定义minmos闭包选取集合中最小元素的坐标
13             def minmos={
14                 //From作为起始坐标,将以From为坐标的元素与集合中的其他元素进行大小比较
15                 mlist,From ->
16                     def mopos=From
17                     def next=From+1
18                 for (j in next..<mlist.size()){
19                     //如果有元素比起始坐标的元素小则将坐标进行调换，最终筛选出来的mopos坐标是元素最小的坐标
20                      if (mlist[j]<mlist[mopos])
21                          mopos=j
22 
23                 }
24                     return mopos
25             }
26             //从第一个坐标下的元素开始与其他元素进行比较，依次循环
27             for (i in 0..list.size()-1){
28                 def pos=minmos(list,i)
29                 swap(i,pos,list)
30             }
31             return list
32         }
33         table=[10,5,7,6,8,4,5]
34 
35         println select(table)