Groovy 集合
在 Groovy 提供的所有方便的快捷方式和功能中,最有帮助的一个可能就是内置的 集合。回想一下在 Java 编程中是如何使用集合的 — 导入 java.util 类,初始化集合,将项加入集合。这三个步骤都会增加不少代码。
而 Groovy 可以直接在语言内使用集合。在 Groovy 中,不需要导入专门的类,也不需要初始化对象。集合是语言本身的本地成员。Groovy 也使集合(或者列表)的操作变得非常容易,为增加和删除项提供了直观的帮助。
可以将范围当作集合
在前一节学习了如何用 Groovy 的范围将循环变得更容易。范围表达式 “0..4” 代表数字的集合— 0、1、2、3 和 4。为了验证这一点,请创建一个新类,将其命名为 Ranger。保留类定义和 main 方法定义。但是这次添加以下代码:
def range = 0..4
println range.class
assert range instanceof List
请注意,assert 命令用来证明范围是 java.util.List 的实例。接着运行这个代码,证实该范围现在是类型 List 的集合。
丰富的支持
Groovy 的集合支持相当丰富,而且美妙之处就在于,在 Groovy 的魔法背后,一切都是标准的 Java 对象。每个 Groovy 集合都是 java.util.Collection 或 java.util.Map 的实例。
前面提到过,Groovy 的语法提供了本地列表和映射。例如,请将以下两行代码添加到 Ranger 类中:
def coll = ["Groovy", "Java", "Ruby"]
assert coll instanceof Collection
assert coll instanceof ArrayList
你将会注意到,coll 对象看起来很像 Java 语言中的数组。实际上,它是一个 Collection。要在普通的 Java 代码中得到集合的相同实例,必须执行以下操作:
Collection<String> coll = new ArrayList<String>();
coll.add("Groovy");
coll.add("Java");
coll.add("Ruby");
在 Java 代码中,必须使用 add() 方法向 ArrayList 实例添加项。
添加项
Groovy 提供了许多方法可以将项添加到列表 — 可以使用 add() 方法(因为底层的集合是一个普通的 ArrayList 类型),但是还有许多快捷方式可以使用。
例如,下面的每一行代码都会向底层集合加入一些项:
coll.add("Python")
coll << "Smalltalk"
coll[5] = "Perl"
请注意,Groovy 支持操作符重载 —<< 操作符被重载,以支持向集合添加项。还可以通过位置参数直接添加项。在这个示例中,由于集合中只有四个项,所以 [5] 操作符将 “Perl” 放在最后。请自行输出这个集合并查看效果。
检索非常轻松
如果需要从集合中得到某个特定项,可以通过像上面那样的位置参数获取项。例如,如果想得到第二个项 “Java”,可以编写下面这样的代码(请记住集合和数组都是从 0 开始):
assert coll[1] == "Java"
Groovy 还允许在集合中增加或去掉集合,如下所示:
def numbers = [1,2,3,4]
assert numbers + 5 == [1,2,3,4,5]
assert numbers - [2,3] == [1,4]
请注意,在上面的代码中, 实际上创建了新的 集合实例,由最后一行可以看出。
魔法方法
Groovy 还为集合添加了其他一些方便的功能。例如,可以在集合实例上调用特殊的方法,如下所示:
def numbers = [1,2,3,4]
assert numbers.join(",") == "1,2,3,4"
assert [1,2,3,4,3].count(3) == 2
join() 和 count() 只是在任何项列表上都可以调用的众多方便方法中的两个。分布操作符(spread operator) 是个特别方便的工具,使用这个工具不用在集合上迭代,就能够调用集合的每个项上的方法。
假设有一个 String 列表,现在想将列表中的项目全部变成大写,可以编写以下代码:
assert ["JAVA", "GROOVY"] ==
["Java", "Groovy"]*.toUpperCase()
请注意 *. 标记。对于以上列表中的每个值,都会调用 toUpperCase(),生成的集合中每个 String 实例都是大写的。
Groovy 映射
除了丰富的列表处理功能,Groovy 还提供了坚固的映射机制。同列表一样,映射也是本地数据结构。而且 Groovy 中的任何映射机制在幕后都是 java.util.Map 的实例。
Java 语言中的映射
Java 语言中的映射是名称-值对的集合。所以,要用 Java 代码创建典型的映射,必须像下面这样操作:
Map<String, String>map = new HashMap<String, String>();
map.put("name", "Andy");
map.put("VPN-#","45");
一个 HashMap 实例容纳两个名称-值对,每一个都是 String 的实例。
通过 Groovy 进行映射
Groovy 使得处理映射的操作像处理列表一样简单 — 例如,可以用 Groovy 将上面的 Java 映射写成
def hash = [name:"Andy", "VPN-#":45]
请注意,Groovy 映射中的键不必是 String。在这个示例中,name 看起来像一个变量,但是在幕后,Groovy 会将它变成 String。
全都是 Java
接下来创建一个新类 Mapper 并加入上面的代码。然后添加以下代码,以证实底层的代码是真正的 Java 代码:
assert hash.getClass() == java.util.LinkedHashMap
可以看到 Groovy 使用了 Java 的 LinkedHashMap 类型,这意味着可以使用标准的 Java 一样语句对 hash 中的项执行 put 和 get 操作。
hash.put("id", 23)
assert hash.get("name") == "Andy"
有 groovy 特色的映射
现在您已经看到,Groovy 给任何语句都施加了魔法,所以可以用 . 符号将项放入映射中。如果想将新的名称-值对加入映射(例如 dob 和 “01/29/76”),可以像下面这样操作:
hash.dob = "01/29/76"
. 符号还可以用来获取项。例如,使用以下方法可以获取 dob 的值:
assert hash.dob == "01/29/76"
当然 . 要比调用 get() 方法更具 Groovy 特色。
位置映射
还可以使用假的位置语法将项放入映射,或者从映射获取项目,如下所示:
assert hash["name"] == "Andy"
hash["gender"] = "male"
assert hash.gender == "male"
assert hash["gender"] == "male"
但是,请注意,在使用 [] 语法从映射获取项时,必须将项作为 String 引用。
Groovy 中的闭包
现在,闭包是 Java 世界的一个重大主题,对于是否会在 Java 7 中包含闭包仍然存在热烈的争论。有些人会问:既然 Groovy 中已经存在闭包,为什么 Java 语言中还需要闭包?这一节将学习 Groovy 中的闭包。如果没有意外,在闭包成为 Java 语法的正式部分之后,这里学到的内容将给您带来方便。
不再需要更多迭代
虽然在前几节编写了不少集合代码,但还没有实际地在集合上迭代。当然,您知道 Groovy 就是 Java,所以如果愿意,那么总是能够得到 Java 的 Iterator 实例,用它在集合上迭代,就像下面这样:
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 集合类型中的每个值上被调用。
在较高层面上,{} 中的代码会执行三次,从而生成如图 13 所示的输出。
图 13. 迭代从未像现在这样容易
闭包中的 it 变量是一个关键字,指向被调用的外部集合的每个值 — 它是默认值,可以用传递给闭包的参数覆盖它。下面的代码执行同样的操作,但使用自己的项变量:
def acoll = ["Groovy", "Java", "Ruby"]
acoll.each{ value ->
println value
}
在这个示例中,用 value 代替了 Groovy 的默认 it。
迭代无处不在
闭包在 Groovy 中频繁出现,但是,通常用于在一系列值上迭代的时候。请记住,一系列值可以用多种方式表示,不仅可以用列表表示 — 例如,可以在映射、String、JDBC Rowset、File 的行上迭代,等等。
如果想在前面一节 “Groovy 中的映射” 中的 hash 对象上迭代,可以编写以下代码:
def hash = [name:"Andy", "VPN-#":45]
hash.each{ key, value ->
println "${key} : ${value}"
}
请注意,闭包还允许使用多个参数 — 在这个示例中,上面的代码包含两个参数(key 和 value)。
使用 Java 代码迭代
以下是使用典型的 Java 构造如何进行同样的迭代:
Map<String, String>map = new HashMap<String, String>();
map.put("name", "Andy");
map.put("VPN-#","45");
for(Iterator iter = map.entrySet().iterator(); iter.hasNext();){
Map.Entry entry = (Map.Entry)iter.next();
System.out.println(entry.getKey() + " : " + entry.getValue());
}
上面的代码比 Groovy 的代码长得多,是不是?如果要处理大量集合,那么显然用 Groovy 处理会更方便。
迭代总结
请记住,凡是集合或一系列的内容,都可以使用下面这样的代码进行迭代。
"ITERATION".each{
println it.toLowerCase()
}
闭包的更多使用方式
虽然在迭代上使用闭包的机会最多,但闭包确实还有其他用途。因为闭包是一个代码块,所以能够作为参数进行传递(Groovy 中的函数或方法不能这样做)。闭包在调用的时候才会执行这一事实(不是在定义的时候)使得它们在某些场合上特别有用。
例如,通过 Eclipse 创建一个 ClosureExample 对象,并保持它提供的默认类语法。在生成的 main() 方法中,添加以下代码:
def excite = { word ->
return "${word}!!"
}
这段代码是名为 excite 的闭包。这个闭包接受一个参数(名为 word),返回的 String 是 word 变量加两个感叹号。请注意在 String 实例中替换 的用法。在 String 中使用 ${value}语法将告诉 Groovy 替换 String 中的某个变量的值。可以将这个语法当成 return word + "!!" 的快捷方式。
延迟执行
既然有了闭包,下面就该实际使用它了。可以通过两种方法调用闭包:直接调用或者通过 call() 方法调用。
继续使用 ClosureExample 类,在闭包定义下面添加以下两行代码:
assert "Groovy!!" == excite("Groovy")
assert "Java!!" == excite.call("Java")
可以看到,两种调用方式都能工作,但是直接调用的方法更简洁。不要忘记闭包在 Groovy 中也是一类对象 — 既可以作为参数传递,也可以放在以后执行。用普通的 Java 代码可以复制同样的行为,但是不太容易。现在不会感到惊讶了吧?