Groovy闭包

Groovy闭包

闭包是一种表示可执行代码块的方法。闭包也是对象，可以像方法一样传递参数。由于闭包是代码块，因此也可以在需要时执行。像方法一样，在定义的过程中，闭包也可以使用一个或者多个参数。
一、inject方法
inject方法可用于遍历集合，首先将需要传递的值和集合项目传给闭包，此时其传递的值将作为处理结果，然后再和下一个集合项目一起传给闭包，依此类推。方法原型为：
Object inject(Object value, Closure closure)
例：求5的阶乘值
－－－－－－－－－－－

deffactorial=[2,3,4,5].inject(1){previous,element->previous*element}
println"Factorial(5):${factorial}"

－－－－－－－－－－－
结果：
Factorial(5): 120
－－－－－－－－－－－

deffact=1
[2,3,4,5].each{number->fact*=number}
println"fact:${fact}"

－－－－－－－－－－－
结果：
fact: 120
－－－－－－－－－－－

deflist=[2,3,4,5]
factorial=list.inject(1){previous,element->previous*element}
println"Factorial(5):${factorial}"

－－－－－－－－－－－
结果：
Factorial(5): 120
－－－－－－－－－－－

list=[2,3,4,5]
defclosure={previous,element->previous*element}
factorial=list.inject(1,closure)
println"Factorial(5):${factorial}"

－－－－－－－－－－－
结果：
Factorial(5): 120

由于闭包也是一个对象，因此它可以作为方法的参数。
例：闭包作为方法的参数
－－－－－－－－－－－

//Findthoseitemsthatqualify
deffilter(list,predicate){
returnlist.findAll(predicate)
}
//Twopredicateclosure
defisEven={x->return(x%2==0)}
defisOdd={x->return!isEven(x)}

deftable=[11,12,13,14]

//Applyfilter
defevens=filter(table,isEven)
println"evens:${evens}"
defodds=filter(table,isOdd)
println"odds:${odds}"

－－－－－－－－－－－
结果：
evens: [12, 14]
odds: [11, 13]

例：闭包作为另一个闭包的参数
－－－－－－－－－－－

//Findinitiallistthatconformstopredicate
deftakeWhile={predicate,list->
defresult=[]
for(elementinlist){
if(predicate(element)){
result<<element
}else{
returnresult
}
}
returnresult
}
//Twopredicateclosures
defisEven={x->returnx%2==0}
defisOdd={x->return!isEven(x)}
deftable1=[12,14,15,18]
deftable2=[11,13,15,16,18]
//ApplytakeWhile
defevens=takeWhile.call(isEven,table1)
println"evens:${evens}"
defodds=takeWhile.call(isOdd,table2)
println"odds:${odds}"

－－－－－－－－－－－－
结果：
evens: [12, 14]
odds: [11, 13, 15]

例：闭包作为返回值
－－－－－－－－－－－－

defmultiply(x){
return{y->returnx*y}
}
deftwice=multiply(2)
println"twice(4):${twice(4)}"
//Closurereturningaclosure
defmultiplication={x->return{y->returnx*y}}
defquadruple=multiplication(4)
println"quadruple(3):${quadruple(3)}"

－－－－－－－－－－－－
结果：
twice(4): 8
quadruple(3): 12

例：选择性排序
－－－－－－－－－－－－

defselectionSort={list->
defswap={sList,p,q->
deftemp=sList[p]
sList[p]=sList[q]
sList[q]=temp
}
defminimumPosition={pList,from->
defmPos=from
defnextFrom=1+from
for(jinnextFrom..<pList.size()){
if(pList[j]<pList[mPos])
mPos=j
}
returnmPos
}
defsize=list.size()-1
for(kin0..size){
defminPos=minimumPosition(list,k)
swap(list,minPos,k)
}
returnlist
}
deftable=[13,14,12,11,14]
defsorted=selectionSort(table)
println"sorted:${sorted}"

－－－－－－－－－－－－
结果：
sorted: [11, 12, 13, 14, 14]