Groovy閉包

[align=center]Groovy閉包[/align]

閉包是一種表示可執行代碼塊的方法。閉包也是對象，可以像方法一樣傳遞參數。由于閉包是代碼塊，是以也可以在需要時執行。像方法一樣，在定義的過程中，閉包也可以使用一個或者多個參數。

一、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}"
－－－－－－－－－－－           

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

由于閉包也是一個對象，是以它可以作為方法的參數。

例：閉包作為方法的參數

－－－－－－－－－－－
//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}"
－－－－－－－－－－－－           

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]