1.Groovy 中的闭包
Java的一些不足可以通过使用groovy的闭包很好的解决，通过下面这个例子来看看使用闭包的优势：
在Java中遍历一个集合的方法是使用迭代，就像下面这样：
def acoll = ["Groovy", "Java", "Ruby"] for(Iterator iter = acoll.iterator(); iter.hasNext();){
println iter.next()
}
实际上在 for 循环中并不需要类型声明，因为 Groovy 已经将迭代转变为任何集合的直接成员。在这个示例中，不必获取 Iterator 实例并直接操纵它，可以直接在集合上迭代。而且，通常放在循环构造内的行为（例如 for 循环体中 println）接下来要放在闭包内。在深入之前，先看看如何执行这步操作。
对于上面的代码，可以用更简洁的方式对集合进行迭代，如下所示：
def acoll = ["Groovy", "Java", "Ruby"]
acoll.each{
println it
}
请注意，each 直接在 acoll 实例内调用，而 acoll 实例的类型是 ArrayList。在 each 调用之后，引入了一种新的语法 — {，然后是一些代码，然后是 }。由 {} 包围起来的代码块就是闭包。
闭包是可执行的代码块。它们不需要名称，可以在定义之后执行。所以，在上面的示例中，包含输出 it（后面将简单解释 it）的行为的无名闭包将会在 acoll 集合类型中的每个值上被调用。
在较高层面上，{} 中的代码会执行三次，从而生成如图所示的输出。
Groovy
Java
Ruby
2声明闭包
迄今为止，我们已经使用了闭包的简单语法：在一个方法调用的后面，放置闭包代码在一对花括号里，闭包的参数和代码通过（->）进行分隔。
2.1简单的声明方式
下图中显示了闭包语法的简单方式和一个新的特性，当只有一个参数传递的时候，这个参数是可选的，魔术变量it代替了声明
log='' (1..10).each{counter -> log += counter }
println log //12345678910 log='' (1..10).each{log += it }
println log //12345678910
上面两个闭包声明是等价的，注意，不像counter，魔术变量it是不需要声明的。
2.2 使用赋值的方式声明闭包
第二种声明闭包的方式是直接将它赋值给一个变量
def printer={ line -> println line}
闭包声明在花括号中，并且赋给了printer变量
通过方法的返回值也是一种闭包的声明方式
def Closure getPrinter(){ return {line -> println line}
}
花括号指明构建了一个新的闭包对象，这个对象通过方法的调用返回
2.3引用一个方法作为闭包
第三种声明闭包的方式是重用已有的声明：一个方法。方法有一个方法体，可选的返回值，能够接受参数，并且能够被调用，于grooovy的闭包的相似性显而易见，因此groovy可以重用你已经在方法中存在的代码作为一个闭包，引用一个方法作为闭包使用reference.&操作符， reference是闭包调用时使用的对象实例，正如一个一般的方法调用使用reference.someMethod().
上图显示了闭包的调用方法。
下面代码演示了方法闭包的使用
class MethodClosureSample{ int limit
MethodClosureSample(int limit){ this.limit = limit
} boolean validate(String value){ return value.length() <= limit
}
}
MethodClosureSample first = new MethodClosureSample(6)
MethodClosureSample second = new MethodClosureSample(4)
def firstClosure = first.&validate; //方法作为闭包 def words=['Hello','Synvata','I','Love','you']
println words.findAll(firstClosure) //[Hello, I, Love, you] println words.findAll(second.&validate) //[I, Love, you]
3 比较
下面展示了创建和使用闭包的所有方式：使用简单声明、赋值变量和方法闭包
map=['a':1,'b':2,'c':3] /*直接把闭包作为参数传递，这是常用的方式*/ map.each{key,value -> map[key] = value * 2 }
println map //[a:2, b:4, c:6] /*将闭包对象赋值给变量doubler*/ doubler={key,value -> map[key] = value * 2 }
map.each(doubler)
println map //[a:4, b:8, c:12] /*声明一个普通的方法*/ def doubleMethod(entry){
map[entry.key]=entry.value * 2 } /*reference.&操作符引用方法作为一个闭包*/ doubler=this.&doubleMethod
println doubler //org.codehaus.groovy.runtime.MethodClosure@3fb547 map.each(doubler)
println map //[a:8, b:16, c:24]
4 调用闭包
假设有一个引用x指向一个闭包，我们能通过x.call()来调用闭包，或者简单的x()
def col={println 'Hello, Groovy'}
col(); //Hello, Groovy col.call() //Hello, Groovy
现在，我们来试试更复杂的一些东西，从一个方法的内部调用闭包
def benchmark(repeat,Closure worker){
start=System.currentTimeMillis()
repeat.times{worker(it)}
stop=System.currentTimeMillis() return stop-start
}
slow=benchmark(1000){ (int)it / 2 }
fast=benchmark(1000){ it.intdiv(2) }
println slow
println fast
在benchmark中我们把闭包作为最后一个参数，这样在调用该方法的时候就可以使用闭包的简单语法声明benchmark(){Closure}。方法参数中Closure声明了闭包的类型，该声明是可选的。repeat.times{worker(it)}根据repeat参数重复的调用闭包，并把当前重复的次数传入闭包
因为不想编写文档，就COPY了一下博客园的一篇博文，不敢说是自己写的，说明出处：
