Groovy 学习手册（6）
9. 不可变特性
不可变特性和函数式编程在一起就像是花生酱和果酱在一起一样。虽然没有必要非要在一起使用，但他们相处得很好。
在纯正的函数式语言中，每个函数对本身之外没有影响，即没有副作用。这意味着每次调用函数时，返回相同输入的相同值。
为了适应这种行为，需要不可变的数据结构。不可变的数据结构不能直接更改，但每次操作都返回一个新的数据结构。
例如，Scala语言里的 Map 就是不可变的。
val map = Map("Smaug" -> "deadly")
val map2 = map + ("Norbert" -> "cute")
println(map2) // Map(Smaug -> deadly, Norbert -> cute)
所以，在上面的代码中，map是保持不变的。
每个语言里都会提供一个关键字来定义一个变量或值是不可变的，在 Java 中使用 final 关键字来表示，Groovy 里面也是一样。
public class Centaur {
final String name
public Centaur(name) {this.name=name}
}
Centaur c = new Centaur("Bane");
println(c.name) // Bane
c.name = "Firenze" //error
除此而外，Groovy 还提供了 @Immutable 注解来标注一个类为不可变类。它也提供了默认的构造方法，还有带有属性的构造方法，hashCode 方法，equals 方法和 toString 方法。下下面的例子。
import groovy.transform.Immutable
@Immutable
public class Dragon {
String name
int scales
}
Dragon smaug = new Dragon('Smaug', 499)
println smaug
// Output: Dragon(Smaug, 499)
10. Groovy Fluent GDK
在 Groovy 中，findAll和其他方法可以用在任何对象上，但尤其用在 List，Set，Range 上更加好用。除了findAll，collect，inject还有以下的方法都可以在 Groovy 中使用。
- each：根据给定的闭包条件遍历所有的值；
- eachWithIndex：在遍历值时带有两个参数，一是具体的值，二是值对应的索引；
- find：根据匹配的闭包条件找到满足条件的第一个元素；
- findIndexOf：根据匹配的闭包条件找到满足条件的第一个元素，并返回对应的索引。
例如，collect方法用在对 List 的元素操作上非常简单。
def list = ['foo','bar']
def newList = []
list.collect( newList ) { it.substring(1) }
println newList // [oo, ar]
在另一个例子里，
def dragons = [new Dragon('Smaug', 499), new Dragon('Norbert', 488)]
String longestName = dragons.
findAll { it.name != null }.
collect { it.name }.
inject("") { n1, n2 -> n1.length() > n2.length() ? n1 : n2 }
上面的代码首先查找所有不为 null 的名字，收集对象元素里的的名字属性，然后再使用聚合方法找到所有名字里最长的那个。
11. Groovy Curry
curry方法用来在给闭包里的参数预定义一个默认值。它可以接受多个参数，并且在你预想的情况下从左到右逐一替换。请看下面的代码：
def concat = { x, y -> return x + y }
// closure
def burn = concat.curry("burn")
def inate = concat.curry("inate")
因为你只提供了第一个参数，它们的闭包会准备已经给定的字符串，burn方法准备了“burn”字符串，而inate方法准备了“inate”字符串。
burn(" wood") // == burn wood
你还可以使用composition闭包应用于两个方法和一个输入参数。
def composition = { f, g, x -> return f(g(x)) }
def burninate = composition.curry(burn, inate)
def trogdor = burninate(' all the people')
println "Trogdor: ${trogdor}"
// Trogdor: burninate all the people
函数组合是函数编程中的一个重要思想。它允许你组合多个功能在一起创建复杂的算法。
12. 方法句柄
方法句柄允许你引用实际方法，就像它们是闭包一样。当你想使用现有的方法，而不是闭包，或者你只是想一个替代的闭包语法时，这是非常有用的。例如，给定一个方法：
def breathFire(name) { println "Burninating $name!" }
在定义了breathFire方法的类里面可以做如下操作：
['the country side', 'all the people'].each(this.&breathFire)
这样就会把breathFire方法作为一个闭包传递给 each 方法，然后会打印如下结果：
Burninating the country side
Burninating all the people
13. 尾递归
在 Groovy 1.8版本中，trampoline方法被用来引入到闭包中用于对尾递归的优化。这允许闭包被顺序调用而不是内存堆积，从而避免栈溢出和提高性能。
从Groovy 2.3 版本以后，可以使用trampoline方法来解决递归，甚至更好的办法是使用注解 @TailRecursive， 例如，
import groovy.transform.*
@TailRecursive
long totalPopulation(list, total = 0) {
if (list.size() == 0)
total
else
totalPopulation(list.tail(), total + list.first().population)
}
在 Groovy 的 List中，tail 方法会返回不包含第一个元素的 List，而first方法则返回 List 的第一个元素。直接上代码：
@Canonical class City {int population}
def cities = (10..1000).collect{new City(it)}
totalPopulation(cities)
// 500455
