Groovy笔记(6)_闭包

最新推荐文章于 2024-07-26 12:28:02 发布

iteye_887

最新推荐文章于 2024-07-26 12:28:02 发布

阅读量76

点赞数

文章标签： java

闭包介绍

1、由{}包围起来的代码块就是闭包
 println{} //执行该行，结果如下：
 <a href="mailto:com.clat.GroovyTest%24_run_closure1@10a2d43">com.clat.GroovyTest$_run_closure1@10a2d43</a>
符合格式：类$匿名内部类@hash code
 结论： 闭包是一个匿名内部类的对象。

2、也可以给闭包取名字：
 def aClosure = {
println "Hello Closure!"
 }
 println aClosuer //结果如下：
 <a href="mailto:com.clat.GroovyTest%24_run_closure2@89cf1e">com.clat.GroovyTest$_run_closure2@89cf1e</a>


调用闭包

1、aClosure.call() //使用call()调用闭包
2、aClosure()//调用闭包的简写方式，类似于方法调用。
结论：闭包是一个可执行的代码块。
3、闭包在调用的时候才会执行
4、参数化闭包
 def bClosure = {
 println "Hello ${it}"
 }
 bClosure.call("clat")
 bClosure("clat")
 bClosure "clat" //结果输出三个： Hello clat
it 是闭包的单个隐含参数。


闭包参数

1、闭包使用显示参数
 def cClosure = {name,address -> 
 println "${name},${address}!"
 }
 cClosure("hello","clat") // 输出: hello, clat!
2、闭包支持默认参数
 def dClosure = {name,address="clat"->
 println "${name},${address}!"
 }
 dClosure("hello") //输出hello, clat!


闭包作用域


1、def name= "clat"
 def eClosure = {println name}
eClosure() //输出: clat

 //闭包可以作为方法的参数
def aMethod(Closure closure){
name="escaflone"; closure() //这里的name只是方法的局部变量，闭包不能访问
}
 aMethod(eClosure) //输出: clat 
 
 def fClosure = {
 name="Aldern"; eClosure() //同样是闭包，能访问到name（其实就是可执行片段修改了外围的一个变量）
}
 fClosure() //输出：Aldern


闭包可以返回值

1、def gClosure={number ->
 return number*2
 }
 println gClosure(3)

闭包返回6，其中return 可以省略


闭包与集合、字符串

1、闭包在Groovy中频繁出现，但最常用于对一系列值上迭代，如列表/映射/范围/String/File
2、闭包可以用更简洁的方式对集合进行迭代，已经不需要Java的迭代器了
3、用each遍历list:
 def nameList = ["clat","escaflone","Aldern"]
 nameList.each{name ->
prinl name+ ' '
 }
 输出 clat escaflone Aldern


遍历Map,Range,GString

1、遍历Map:
 def nameMap = [1:'clat',2:'escaflone',3:'Aldern']
 nameMap.each{name ->
 print name.key + ' ' + name.value + ' '
 }
2、遍历Range
 (1..<5).each{print it +'-'} // 1-2-3-4-
3、遍历GString 
 'clat'.each{print it +'-'} //c-l-a-t-


闭包为参数的迭代集合的方法

1、boolean any(Closure clos)
 有一个集合元素满足闭包条件则返回true
2、List collect(Closure clos)
 把集合每个元素用闭包转换后返回列表
3、List clooect(Collection coll,Closure clos)
 把集合每个元素用闭包转换后放到coll中
4、bollean every(Closure clos)
 判断是否每个元素都满足闭包条件
5、List findAll(Closure clos)
 从集合中找到满足闭包条件的所有元素
6、Object find(Closure clos)
 从集合中找的满足闭包条件的第一个元素
7、int findindexOf(Closure clos)
 从集合中找到满足闭包条件的第一个元素的索引
8、Object inject(Object value,Closure clos)
 value 与第一个元素传给闭包，结果值与第二个集合元素又传给闭包，类推。（可以用来求阶乘）
9、void reverseEach(Closure clos)
 反向迭代
10、List sort(Closure clos) 
 排序集合


find()方法


1、def value = [1,3,5,7,9].find{element -> element >6}
 println "Found : ${value}" // Found : 7
2、value = [1,3,5,7,9].find{element -> element >10}
 println "Found : ${value}" // Found: null
3、value = ["Java":21 , "Groovy" :22 , "Grails" :25].find{lang ->lang.value >21}
 println "Found : ${value}" //Found : Groovy=22


findAll()方法


1、def values= [1,3,5,7,9].findAll{element -> element >6}
 values.each{println it}
 // 输出:7
 9
2、values=['Java':21,'Groovy':22,'Grails':25].findAll{lang -> lang.value >21}
 values.each{prinln it}
 //输出: Grails=25
 Groovy=22

any()与every()


1、def anyElement = [11,12,13,14].any{element -> element >12}
 //true
2、def allElement = [11,12,13,14].every{element -> element >10}
 //true
3、def anyLang= ['Java':21 ,'Groovy':22,'Grails':25].any{lang -> lang.value>30}
 // false


collect()方法

1、def list= [1,2,3,4].collect{element -> return element*element}
 // [1,4,9,16]
2、list = (0..<5).collect{element -> 2*element }
 // [0,2,4,6,8]
3、def lang = ['Java':21,'Groovy':22,'Grails':25]
 list = lang.collect{entry -> ++entry.value}
def olderLang = lang.collect{entry -> ++entry.value ; return entry}
 println "lang : ${lang}"
 println "list: ${list}"
 prinltn "olderLang: ${olderLang}"
 //结果输出 lang:['Java':23,'Groovy':24,'Grails':27] //collect 会修改原数据
 list:[22,23,26]
 olderLang:[Java=23,Groovy=24,Grails=27]



inject()方法求阶乘

1、def numList = [2,3,4,5]
 factorial = numList.inject(1){previous, element -> previous*element} 
 // 输出: 120
2、numList = [2,3,4,5]
 closure={previous,element -> previous*element}
 factorial = numList.inject(1,closure)
 // 输出 120



闭包的其他特性

1、闭包可以嵌套。
 def outerClosure = {country -> 
 println country
//嵌套定义闭包，方法则不运行
 def innerClosure = {city ->
 println city
 }
 innerClosure('shanghai')
 }
 outerClosure('china') //先打印china 再打印shanghai

iteye_887

关注

0
点赞
踩
0

收藏

觉得还不错? 一键收藏
0
评论
Groovy笔记(6)_闭包

闭包介绍1、由{}包围起来的代码块就是闭包 println{} //执行该行，结果如下： com.clat.GroovyTest$_run_closure1@10a2d43符合格式：类$匿名内部类@hash code 结论：闭包是一个匿名内部类的对象。2、也可以给闭包取名字： def aClosure = {println "Hello Closure!"...
复制链接

扫一扫