Groovy闭包

Groovy闭包

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

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

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

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

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

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

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

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

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

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

// Find those items that qualify
def  filter(list, predicate){
     return  list.findAll(predicate)
}
// Two predicate closure
def  isEven  =  {x  ->   return  (x % 2   ==  0)}
def  isOdd  =  {x  ->   return  !isEven(x)}

def  table  =  [ 11 , 12 , 13 , 14 ]

// Apply filter
def  evens  =  filter(table, isEven)
println  " evens: ${evens} "
def  odds  =  filter(table, isOdd)
println  " odds: ${odds} "

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

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

// Find initial list that conforms to predicate
def  takeWhile  =  {predicate,list  ->
     def  result  =  []
     for (element  in  list){
         if (predicate(element)){
            result element
        } else{
            return result
        }
    }
    return result
}
//Two predicate closures
def isEven = {x -> return x%2 == 0}
def isOdd = {x -> return !isEven(x)}
def table1 = [12,14,15,18]
def table2 = [11,13,15,16,18]
//Apply takeWhile
def evens = takeWhile.call(isEven, table1)
println "evens: ${evens}"
def odds = takeWhile.call(isOdd, table2)
println "odds: ${odds}"

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

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

def  multiply(x){
     return  {y  ->   return  x * y}
}
def  twice  =  multiply( 2 )
println  " twice(4): ${twice(4)} "
// Closure returning a closure
def  multiplication  =  {x  ->   return  {y  ->   return  x * y}}
def  quadruple  =  multiplication( 4 )
println  " quadruple(3): ${quadruple(3)} "

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

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

def  selectionSort  =  {list  ->
     def  swap  =  {sList,p,q  ->  
         def  temp  =  sList[p]
        sList[p]  =  sList[q]
        sList[q]  =  temp
    }
     def  minimumPosition  =  {pList, from   ->
         def  mPos  =   from
         def  nextFrom  =   1   +   from
         for (j  in  nextFrom.. pList.size()){
            if(pList[j]  pList[mPos])
                mPos = j
        }
        return mPos
    }
    def size = list.size() - 1
    for(k in 0..size){
        def minPos = minimumPosition(list, k)
        swap(list, minPos, k)
    }
    return list
}
def table = [13,14,12,11,14]
def sorted = selectionSort(table)
println "sorted: ${sorted}"

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