Groovy閉包詳解

Groovy閉包是一種可執行代碼塊的方法，閉包也是對象，可以向方法一樣傳遞參數，因為閉包也是對象，因此可以在需要的時候執行，像方法一樣閉包可以傳遞一個或多個參數。閉包最常見的用途就是處理集合，可以遍歷某個集合，並將對元素的操作作用於遍歷出來的集合元素上。

閉包的語法是{comma-separated-form-parameter-list ->statement-list},如果不需要形參則可以省略->間隔符

下面是最簡單的閉包形式

def cols={
            println "Hello Word！"
        }
cols.call()

帶參閉包

def cols2={param->
            println "${param}"
        }
cols2("哈哈")

單個隱參數

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

閉包在定義的時候就能訪問外部的屬性值

def greeting="Hello"
def cols4={param->
println "${greeting},${param}"
 }
 cols4("二狗")

閉包也常用在集合中，使用閉包可以更加的高效的遍歷集合的元素，並將閉包應用到每個元素中去。

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

也可以根據條件對集合進行篩選

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

find方法返回集合中符合某個判斷標准的第一個值，在閉包中，集合元素使用的判斷條件必須是bool表達式

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

findAll方法是遍歷所有的元素並返回一個符合條件的列表

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

collect用法：collect將遍歷某個集合，並使用閉包中的變換方法將集合中的元素轉換成一個新值，collect方法返回的是由轉換后的值所組成的列表

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

inject用法：inject可用於遍歷集合，首先將需要傳遞的值和集合中遍歷出來的元素傳給閉包，此時其傳遞的值將作為一個處理結果然后在和下一個集合元素一起傳給閉包，依次類推

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

閉包可以作為方法的參數使用

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

閉包也可以作為另一個閉包的參數使用

def takewhile = { predicate, list ->
def reslut = []
for (element in list) {
if (predicate(element)) {
reslut << element
 }
}
return reslut
 }
def isEven = { x -> return (x % 2 == 0)}
def isOdds = { x -> return !isEven(x) }
def table = [45, 65, 81, 15, 22, 16]
def evens = takewhile(isEven, table)
println evens
def odds = takewhile(isOdds, table)
println odds

閉包作為返回值

//定義一個函數，函數的返回值是個閉包
def twice(x)
{ return {y-> return x*y}}
//定義一個閉包接收函數的返回值,閉包里面的返回值是兩個參數的乘積
def multiply =twice(2)
//閉包所帶的參數就是twice()函數里面的返回值里面的參數
println "multiply(4):${multiply(4)}"

使用Groovy閉包進行選擇排序

//選擇排序
        //定義一個閉包select
        def select={list->
            //定義swap閉包實現集合元素的交換
            def swap={
                x,y,slist->
                    def temp=slist[x]
                    slist[x]=slist[y]
                    slist[y]=temp

            }
            //定義minmos閉包選取集合中最小元素的坐標
            def minmos={
                //From作為起始坐標,將以From為坐標的元素與集合中的其他元素進行大小比較
                mlist,From ->
                    def mopos=From
                    def next=From+1
                for (j in next..<mlist.size()){
                    //如果有元素比起始坐標的元素小則將坐標進行調換，最終篩選出來的mopos坐標是元素最小的坐標
                     if (mlist[j]<mlist[mopos])
                         mopos=j

                }
                    return mopos
            }
            //從第一個坐標下的元素開始與其他元素進行比較，依次循環
            for (i in 0..list.size()-1){
                def pos=minmos(list,i)
                swap(i,pos,list)
            }
            return list
        }
        table=[10,5,7,6,8,4,5]

        println select(table)