閉包與字串

String str = '2 + 3 = 5,abc'
println str.each { // 2 + 3 = 5,abc2 + 3 = 5,abc ， 字串的遍歷，返回值為變數 str 本身
    String tmp -> print tmp
}

println str.find { // 2 ， find的閉包是 由一個String形參，返回值為boolean 的閉包，true條件成立就返回
    String s -> s.isNumber()
}

def list = str.findAll { // 找到字串中所有符合條件的字元，組成list，返回
    String s -> s.isNumber()
}
println list.toListString() // [2, 3, 5]

println str.any { String s -> s.isNumber() } // true ， any 只要符合條件就返回true，否則返回false
println str.every { String s -> s.isNumber() } // false ， every 表示str中每個字元都要滿足條件返回true，否則返回false
// [2,  , +,  , 3,  , =,  , 5, ,, A, B, C] ， collect 對字串中每個字元進行閉包中的處理，返回處理後字元組成的集合list
println str.collect { it.toUpperCase() }.toListString()
 

閉包more

// 閉包關鍵變數 this 、 owner 、 delegate    都是指向其最近的類
def closure = {
    println "1this : "+this          // 1this : [email protected] ， this與java中的一樣，代表閉包定義處的類
    println "1owner : "+owner        // 1owner : [email protected] ， owner 代表閉包定義處的類或者物件
    println "1delegate : "+delegate  // 1delegate : 
 
[email protected] ， delegate 代表任意物件，預設值是 owner
}
closure.call()

class Person { // class Person 表示定義了一個內部類
    def static classClosure = { // static 表示靜態型別的閉包
        println "2this : "+this         // 2this : class part4.Person
        println "2owner : "+owner       // 2owner : class part4.Person
        println "2delegate : "+delegate // 2delegate : class part4.Person
    }
    def static say() {
        def classClosure = {
            println "3this : "+this         // 3this : class part4.Person
            println "3owner : "+owner       // 3owner : class part4.Person
            println "3delegate : "+delegate // 3delegate : class part4.Person
        }
        classClosure.call()
    }

    def cc = {
        println "4this : "+this         // 4this : 
 
[email protected]
        println "4owner : "+owner       // 4owner : [email protected]
        println "4delegate : "+delegate // 4delegate : [email protected]
    }
    def nostatic() {
        def classClosure = {
            println "5this : "+this         // 5this : [email protected]
            println "5owner : "+owner       // 5owner : [email protected]
            println "5delegate : "+delegate // 5delegate : [email protected]
        }
        classClosure.call()
    }
}
Person.classClosure.call() // 呼叫內部類中的靜態成員閉包
Person.say() // 呼叫內部類中的靜態函式
Person per = new Person()
per.cc.call() // 非靜態成員 呼叫
per.nostatic()

def outClosure = {
    def innerClosure = { // 閉包中定義閉包
        println "6this : "+this         // 6this : [email protected] ， this指向的是closureup.groovy的例項，與不巢狀的closure閉包的this是一樣的
        println "6owner : "+owner       // 6owner : [email protected] ， owner指向的是outClosure閉包的例項
        println "6delegate : "+delegate // 6delegate : [email protected] ， delegate沒有修改的話，預設指向 [email protected]
    }
    innerClosure.delegate = per // 修改innerClosure閉包的delegate物件，指向person例項物件
    innerClosure.call()
}
outClosure.call()
// 在一般情況下，閉包的 this owner delegate 值都一樣
// 在閉包的閉包中， this 與 owner 值不一樣，owner 與 delegate 的值一樣 ， 如果修改了delegate值， owner 就與 delegate 值不一樣了
// 閉包的 this 、 owner 的值是不能被修改的

// 閉包委託策略
class Student {
    String name
    def pretty = { "My name is $name" }
}
class Teacher {
    String name
}
def stu = new Student(name: 'hj') // new一個物件，並給name成員賦值
def tea = new Teacher(name: 'some')
println stu.pretty.call() // My name is hj
stu.pretty.delegate = tea
println stu.pretty.call() // My name is hj
stu.pretty.resolveStrategy = Closure.DELEGATE_ONLY // 修改閉包的委託策略(需要這兩行程式碼一起作用才行)，預設值為 Closure.OWNER_FIRST
// 當修改的閉包的委託策略為 DELEGATE_FIRST，如果在teacher物件中沒有與student物件的pretty閉包中的name變數一致的變數，那麼pretty.call()時還是會取student物件中的name的值
// 當修改的閉包的委託策略為 DELEGATE_ONLY，如果teacher物件中沒有name成員，那麼程式會報錯
println stu.pretty.call() // My name is some