转自：http://www.ibm.com/developerworks/cn/education/java/j-groovy/
如果现在有人要开始完全重写 Java，那么 Groovy 就像是 Java 2.0。Groovy 并没有取代 Java，而是作为 Java 的补充，它提供了更简单、更灵活的语法，可以在运行时动态地进行类型检查。您可以使用 Groovy 随意编写 Java 应用程序，连接 Java 模块，甚至扩展现有的 Java 应用程序 — 甚至可以用 Groovy 对 Java 代码进行单元测试。Groovy 的美妙之处还在于，它能够比编写纯粹的 Java 代码更快地完成所有工作 — 有时候会快许多。
在本教程中，您将了解到 Groovy 是一门动态语言，它能够像 Java 语言本身一样很好地应用于 Java 平台。
本教程将逐步向您介绍 Groovy 的基本概念。您将学习 Groovy 集合、Groovy 类，当然还有 Groovy 的语法。完成本教程之后，您将了解将 Java 和 Groovy 结合使用的好处，从此您将能够在日常的 Java 开发中使用 Groovy。
为了从本教程得到最大收获，您应该熟悉 Java 语法和在 Java 平台上进行面向对象开发的基本概念。
要尝试本教程的代码，需要安装以下环境之一：
另外，本章教程假设您正在使用 Eclipse IDE。不需要安装 Groovy，因为本教程会介绍如何安装 Groovy Eclipse 插件。
本教程推荐系统的配置如下：
- 支持 Sun JDK 1.5.0_09（或更高版本）或 IBM JDK 1.5.0 SR3 的系统，拥有至少 500 MB 主内存
- 至少 20 MB 可用硬盘空间，用来安装本教程涉及的软件组件和示例
本教程的操作说明和示例均基于 Microsoft Windows 操作系统。本教程涉及的所有工具在 Linux 和 Unix 系统上也能工作。
关于 Groovy
这一节将学习 Groovy 的基础知识：它是什么，它与 Java 语言和 JVM 的关系，以及编写 Groovy 代码的一些要点。
Groovy 是 JVM 的一个替代语言 — 替代 是指可以用 Groovy 在 Java 平台上进行 Java 编程，使用方式基本与使用 Java 代码的方式相同。在编写新应用程序时，Groovy 代码能够与 Java 代码很好地结合，也能用于扩展现有代码。目前的 Groovy 版本是 1.5.4，在 Java 1.4 和 Java 5 平台上都能使用，也能在 Java 6 上使用。
Groovy 的一个好处是，它的语法与 Java 语言的语法很相似。虽然 Groovy 的语法源于 Smalltalk 和 Ruby 这类语言的理念，但是可以将它想像成 Java 语言的一种更加简单、表达能力更强的变体。（在这点上，Ruby 与 Groovy 不同，因为它的语法与 Java 语法差异很大。）
许多 Java 开发人员非常喜欢 Groovy 代码和 Java 代码的相似性。从学习的角度看，如果知道如何编写 Java 代码，那就已经了解 Groovy 了。Groovy 和 Java 语言的主要区别是：完成同样的任务所需的 Groovy 代码比 Java 代码更少。（有时候会少很多！）
开始使用 Groovy 时，您会发现它使日常的编程活动变得快了许多。完成本教程之后，您会了解更多的 Groovy 语法快捷方式。不过现在只需知道以下这些要点：
- Groovy 的松散的 Java 语法允许省略分号和修改符。
- 除非另行指定，Groovy 的所有内容都为
public。 - Groovy 允许定义简单脚本，同时无需定义正规的
class对象。 - Groovy 在普通的常用 Java 对象上增加了一些独特的方法和快捷方式，使得它们更容易使用。
- Groovy 语法还允许省略变量类型。
虽然 Groovy 允许省略 Java 语法中的一些元素，但也增加了一些新特性，例如本地集合、内置的正则表达式和闭包。在标准的 Java 代码中，如果想要创建一个项列表，首先要导入 java.util.ArrayList，然后程序化地初始化 ArrayList 实例，然后 再向实例中添加项。在 Groovy 中，列表和映射都内置在语法中 — 无需导入任何内容。正则表达式也不需要额外的导入或对象；它们可以通过特殊的 Groovy 语法来创建。
对于任何 Java 开发人员来说，闭包都是一个令人兴奋的新技巧。这些神奇的构造将会包含在未来的 Java 发行版（很可能是 Java 7）中，成为正式的 Java 语法，但现在已经可以在 Groovy 中使用了。可以将闭包 想像为一个代码块，可以现在定义，以后再执行。可以使用这些强大的构造做许多漂亮的事，不过最著名的是简化迭代。使用 Groovy 之后，就有可能再也不需要编写 Iterator 实例了。
从技术上讲，Groovy 可能是您最近听说过的类型最松散的动态语言之一。从这个角度讲，Groovy 与 Java 语言的区别很大，Java 语言是一种固定类型语言。在 Groovy 中，类型是可选的，所以您不必输入 String myStr = "Hello"; 来声明 String 变量。
除此之外，Groovy 代码还能在运行时轻松地改变自己。这实际上意味着，能够在运行时轻松地为对象指定新方法和属性。这一编程领域称为元编程，Groovy 能够很好地支持这种编程方式。在学习本教程的过程中，您将了解到关于 Groovy 的动态性质的更多内容。现在惟一要补充的是，您会惊讶地发现，在 Groovy 会使操作 XML 或普通的 java.io.File 实例变得非常轻松。
用 Groovy 编写的任何内容都可以编译成标准的 Java 类文件并在 Java 代码中重用。类似地，用标准 Java 代码编写的内容也可以在 Groovy 中重用。所以，可以轻易地使用 Groovy 为 Java 代码编写单元测试。而且，如果用 Groovy 编写一个方便的小工具，那么也可以在 Java 程序中使用这个小工具。
Groovy 初探
学习新语言并不是件小事，即使是 Groovy 也不例外。这一节将介绍学习 Groovy 的更多动力。另外还将第一次看到一些 Groovy 代码，并了解 Groovy 与 Java 编程的比较。
即使 Groovy 与 Java 语言有许多相似之处，它仍然是另一个语言。您可能想知道为什么应该花时间学习它。简单的回答就是：Groovy 是一种更有生产力 的语言。它具有松散的语法和一些特殊功能，能够加快编码速度。
只用一个示例即可说明问题：一旦发现使用 Groovy 在集合中导航的容易程度，您就再也不会用 Java 处理集合导航了。能够用 Groovy 快速编写代码，这还意味着能够更快地收到反馈，更不用说完成任务列表中的工作带来的满足感了。在较高层面上，如果能更快地将代码交付给利益相关者，那么就 能在更短的时间内交给他们更多发行版。实际上，Groovy 比 Java 更有助于敏捷开发。
如果仍然觉得采用新语言很困难，那么可以看看将 Groovy 集成到开发环境有多么容易。您无需安装新的运行时工具或专门的 IDE。实际上，只需将 Groovy 的一个 jar 文件放在类路径中即可。
而且，Groovy 是一种开源语言，由热心的 Java 开发人员社区管理。因为 Groovy 获得 Apache Software License, Version 2.0，所以可以自由地使用它开发自由软件和私有软件。
买车的时候，如果不试驾一下，是不会买的。所以，在要求您安装 Groovy 之前，我会演示一些代码。首先，回顾一下用 Java 如何创建、编译和运行标准的 Hello World 示例；然后再看看如何使用 Groovy 代码执行同一过程。比较这两个示例，很容易就能看到这两种语言之间的差异。
用 Java 编写的典型的 Hello World 示例如下所示：
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World!");
}
}
|
在这个简单的 HelloWorld 类中，我省略了包，而且向控制台输出的时候没有使用任何多余的编码约定。下一步是用 javac 编译这个类，如下所示：
c:>javac HelloWorld.java |
最后，运行经过编译的类：
c:>java HelloWorld |
迄今为止还不错 — 很久以前就会编这么基础的代码了，所以这里只是回顾一下。下面，请看用 Groovy 编码的相同过程。
就像前面提到过的，Groovy 支持松散的 Java 语法 — 例如，不需要为打印 “Hello World!” 这样的简单操作定义类。
而且，Groovy 使日常的编码活动变得更容易，例如，Groovy 允许输入 println，而无需输入 System.out.println。当您输入 println 时，Groovy 会非常聪明地知道您指的是 System.out。
所以，用 Groovy 编写 Hello World 程序就如下面这样简单：
println "Hello World!" |
请注意，在这段代码周围没有类结构，而且也没有方法结构！我还使用 println 代替了 System.out.println。
假设我将代码保存在文件 MyFirstExample.groovy 内，只要输入以下代码就能运行这个示例：
c:>groovy MyFirstExample.groovy |
在控制台上输出 “Hello World!” 所需的工作就这么多。
您可能注意到了，我不必编译 .groovy 文件。这是因为 Groovy 属于脚本语言。脚本语言的一个特点就是能够在运行时进行解释。（在 Java 中，要从源代码编译生成字节码，然后才能进行解释。区别在于脚本语言能够直接 解释源代码。）
Groovy 允许完全省略编译步骤，不过仍然可以 进行编译。如果想要编译代码，可以使用 Groovy 编译器 groovyc。用 groovyc 编译 Groovy 代码会产生标准的 Java 字节码，然后可以通过 java 命令运行生成的字节码。这是 Groovy 的一项经常被忽略的关键特性：用 Groovy 编写的所有代码都能够通过标准 Java 运行时编译和运行。
至于运行代码，如果我希望更加简洁，我甚至还能输入
c:>groovy -e "println 'Hello World!'" |
这会生成相同的结果，而且甚至无需定义任何文件！
Groovy 入门
在这一节中，将真正开始进行 Groovy 编程。首先，学习如何轻松地安装 Groovy（通过 Eclipse Groovy 插件），然后从一些有助于了解 Groovy 的简单示例开始。
为了迅速开始使用 Groovy，需要做的全部工作就是安装 Eclipse 的 Groovy 插件。打开 Ecliplse，在 Help 菜单中选择 Software Updates > Find and Install...。
图 1 显示了执行以上步骤之后出现的对话框：
图 1. Eclipse Feature Updates 对话框
接下来，出现一个对话框，里面包含两个选项。请选择 Search for new features to install 单选按钮。单击 Next 按钮，然后选择 New Remote Site...。出现一个新的对话框，里面包含两个需要填写的字段：新位置的名称和该位置的 URL，如图 2 所示：
输入 “Groovy plugin” 作为名称，输入 “http://dist.codehaus.org/groovy/distributions/update/” 作为位置，单击 OK 按钮，在随后出现的 Sites to include in search 框中确保选中了名为 “Groovy plugin” 的项目 — 现在的列表应该如图 3 所示。
单击 Finish 按钮之后，应该会出现 Search Results 对话框。请再次确定选中了 “Groovy plugin” 框并单击 Next 按钮，这一步骤如图 4 所示：
经过一系列确认之后，将会下载插件，然后可能需要重新启动 Eclipse。
Eclipse 重启之后，就能够创建第一个 Groovy 项目了。请确保创建两个源文件夹 — 一个称为 “groovy”，另一个称为 “java”。编写的 Groovy 代码放在 groovy 文件夹，Java 代码放在 java 文件夹。我发现将二者分开将会很有用，如图 5 所示：
项目创建之后，右键单击项目的图标，应该会看到一个 Groovy 选项，如图 6 所示。请选择该选项，然后选择 Add Groovy Nature 选项。这样做可以将必要的 Groovy 库、编译器和运行程序导入到项目中。
创建 Groovy 类很简单。选择 groovy 文件夹并右键单击它。选择 New，然后选择 Other，如图 7 所示：
在这里，找到 Groovy 文件夹，并选择 Groovy Class — 应该会看到一个对话框，如图 8 所示。
单击 Next 按钮，系统将要求您提供类的名称。输入 HelloWorld。
现在可以将 HelloWorld Groovy 类保留在默认包内，如图 9 所示。
虽然步骤看起来很多，但这与创建标准的 Java 类并没有什么区别。
Hello World! — 用 Groovy 编写的 Java 程序
单击 Finish 按钮，应该会看到如下所示的代码段：
class HelloWorld {
static void main(args) {
}
}
|
这看起来同前面的 Java HelloWorld 示例惊人地相似。但是请注意，它不包含 public 修改符。而且，如果仔细查看 main 方法的参数，会注意到它没有类型。
现在在 main 方法内加入 println "Hello World"，完成后的代码看起来如下所示：
class HelloWorld {
static void main(args) {
println "Hello World"
}
}
|
在源代码编辑器中应该能够右键单击，并选择 Compile Groovy File 选项，如图 10 所示。
接下来，再次右键单击文件，选择 Run As 选项，然后选择 Groovy 选项。在 Eclipse 控制台中应该会看到输出的 “Hello World”，如图 11 所示。
OK，那么这是一种突出重点的取巧方式。Groovy 实际上就是 Java。其语法不同 — 多数情况下会短一些 — 但 Groovy 代码 100％ 符合 Java 字节码标准。下一节将进一步介绍这两种语言的交叉。
Groovy 变身为 Java
前面已经看到 Groovy 与 Java 代码实际上可以互换的第一个证据。这一节将进一步证明这点，继续使用 Groovy 构建的 HelloWorld 类。
为了使您确信 Groovy 就是 Java，现在在 HelloWorld 类声明和方法声明前面加上 public 修改符，如下所示：
public class HelloWorld {
public static void main(args) {
println "Hello World"
}
}
|
这个代码运行起来同前面的代码完全一样。但是，如果仍不确信，还可以在 args 参数前加上 String[]：
public class HelloWorld {
public static void main(String[]args) {
println "Hello World"
}
}
|
现在，还可以将 println 替换为 System.out.println — 而且不要忘记加上括号。
public class HelloWorld {
public static void main(String[] args) {
System.out.println("Hello World")
}
}
|
现在的代码与前面用 Java 编写的 Hello World 示例完全相同，但是哪个示例更容易编写呢？
请注意，原来的基于 Groovy 的 HelloWorld 类没有任何 public 修改符，没有任何类型（没有 String[]），而且提供了没有括号的 println 快捷方式。
如果喜欢，可以将这个过程完全翻转过来，回到基于 Java 的 Hello World 示例，删除文件里的所有内容，只保留 System.out 行，然后在这行删除 System.out 和括号。最后只剩下：
println "Hello World" |
现在，哪个程序更容易编写呢？
Groovy 代码完全符合 Java 字节码标准，这个练习证明了这一点。在 Eclipse 中，选择 Run 菜单选项 Open Run Dialog...。选择一个新的 Java Application 配置。确保项目是您的 Groovy 项目。对于 Main 类，单击 Search 按钮，找到 HelloWorld 类。请注意，单词 class 表明 Eclipse Groovy 插件已经将 .groovy 文件编译为 .class 文件。
在图 12 中可以看到整个这个过程 — 如果以前在 Eclipse 中运行过 Java 类，那么您应该对这个过程很熟悉。
图 12. Groovy 代码完全符合 Java 字节码标准
单击 Run 按钮，看到什么了？实际上，“Hello World!” 从未像现在这样能够说明问题。
Groovy 是没有类型的 Java 代码
很可能将 Groovy 当成是没有规则的 Java 代码。但实际上，Groovy 只是规则少一些。这一节的重点是使用 Groovy 编写 Java 应用程序时可以不用考虑的一个 Java 编程的具体方面：类型定义。
在 Java 中，如果要声明一个 String 变量，则必须输入：
String value = "Hello World"; |
但是，如果仔细想想，就会看出，等号右侧的字符已经表明 value 的类型是 String。所以，Groovy 允许省略 value 前面的 String 类型变量，并用 def 代替。
def value = "Hello World" |
实际上，Groovy 会根据对象的值来判断它的类型。
将 HelloWorld.groovy 文件中的代码编辑成下面这样：
String message = "Hello World" println message |
运行这段代码，应该会在控制台上看到与前面一样的 “Hello World”。现在，将变量类型 String 替换为 def 并重新运行代码。是不是注意到了相同的结果？
除了输出 message 的值，还可以用以下调用输出它的类型：
def message = "Hello World" println message.class |
输出 “class java.lang.String” 应该是目前为止很受欢迎的一项变化！如果想知道到底发生了什么，那么可以告诉您：Groovy 推断出 message 一定是 String 类型的，因为它的值是用双引号括起来的。
您可能听说过，在 Groovy 中 “一切都是对象” — 但对于类型来说这句话意味着什么呢？让我们看看如果将前面示例中的 String 替换为数字会怎么样，如下所示：
def message = 12 println message.class |
message 变量的数字值看起来像是 Java 的原生类型 int。但是，运行这个代码就可以看出，Groovy 将它作为 Integer。这是因为在 Groovy 中 “一切都是对象”。
Java 中的所有对象都扩展自 java.lang.Object，这对 Groovy 来说非常方便。即使在最糟的情况下，Groovy 运行时不能确定变量的类型，它只需将变量当成 Object，问题就解决了。
继续使用这段代码。将 message 改成自己喜欢的任意类型：Groovy 会在运行时尽其所能推断出这个变量的类型。
那么，Groovy 缺少类型意味着所需的输入更少。不可否认，将 String 替换成 def 并没有真正节约多少打字工作 — 三个字母并不值得如何夸耀！但是在更高的层次上看，在编写大量不仅仅包含变量声明的代码的时候，没有类型确实减少了许多打字工作。更重要的是，这意味着要 阅读的代码要少得多。最后，Groovy 缺少类型能够带来更高的灵活性 — 不需要接口或抽象类。
所以，只需要使用 def 关键字就能在方法中声明一个独立变量，不需要将 def 关键字作为方法声明中的参数。在 for 循环声明中也不需要它，这意味着不用编写 (int x = 0; x < 5; x++)，相反，可以省略 int，保留空白。
通过 Groovy 进行循环
同大多数脚本语言一样，Groovy 经常被宣传为生产力更高 的 Java 语言替代品。您已经看到了 Groovy 缺少类型能够如何减少打字工作。在这一节，将创建并试用一个 repeat 函数。在这个过程中，将进一步探索 Groovy 提高效率的方式。
下面这种方法可以更好地感受 Groovy 缺乏类型的好处：首先，用与创建 HelloWorld 相同的方式创建一个 Groovy 类，将这个类称为 MethodMadness，并删除自动生成的类体：将要定义一个独立的 repeat 函数。现在在控制台中输入以下代码：
def repeat(val){
for(i = 0; i < 5; i++){
println val
}
}
|
起初，从 Java 的角度来看，这个小函数看起来可能有些怪（实际上，它很像 JavaScript）。但它就是 Java 代码，只不过是用 Groovy 的样式编写的。
repeat 函数接受一个变量 val。请注意参数不需要 def。方法体本质上就是一个 for 循环。
调用这个函数。
repeat("hello
world") |
会输出 “hello world” 五次。请注意，for 循环中省略了 int。没有变量类型的 for 循环要比标准的 Java 代码短些。现在看看如果在代码里加入范围会出现什么情况。
范围 是一系列的值。例如 “0..4” 表明包含 整数 0、1、2、3、4。Groovy 还支持排除范围，“0..<4” 表示 0、1、2、3。还可以创建字符范围：“a..e” 相当于 a、b、c、d、e。“a..<e” 包括小于 e 的所有值。
范围为循环带来了很大的方便。例如，前面从 0 递增到 4 的 for 循环如下所示：
for(i = 0; i < 5; i++) |
范围可以将这个 for 循环变得更简洁，更易阅读：
def repeat(val){
for(i in 0..5){
println val
}
}
|
如果运行这个示例，可能会注意到一个小问题：“Hello World” 输出了六次而不是五次。这个问题有三种解决方法：
- 将包含的范围限制到 4：
for(i in 0..4)
- 从 1 而不是 0 开始：
def repeat(val){ for(i in 1..5){ println val } } - 将范围由包含改为排除：
def repeat(val){ for(i in 0..<5){ println val } }
不论采用哪种方法，都会得到原来的效果 — 输出 “Hello World” 五次。
现在已经成功地使用 Groovy 的范围表达式缩短了 repeat 函数。但这个函数依然有些限制。如果想重复 “Hello World” 八次该怎么办？如果想对不同的值重复不同次数 — 比如 “Hello World” 重复八次，“Goodbye Sunshine” 重复两次，这时该怎么办？
每次调用 repeat 时都要指定需要的重复次数的做法已经过时了，特别是在已经适应了默认行为（重复五次）的时候。
Groovy 支持默认参数值，可以在函数或方法的正式定义中指定参数的默认值。调用函数的程序可以选择省略参数，使用默认值。
使用前面的 repeat 函数时，如果希望调用程序能够指定重复值，可以像下面这样编码：
def repeat(val, repeat=5){
for(i in 0..<repeat){
println val
}
}
|
像下面这样调用该函数：
repeat("Hello World", 2)
repeat("Goodbye sunshine", 4)
repeat("foo")
|
结果会输出 “Hello World” 两次，“Goodbye sunshine” 四次，“foo” 五次（默认次数）。
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 代码创建典型的映射，必须像下面这样操作：
Map<String, String>map = new HashMap<String, String>();
map.put("name", "Andy");
map.put("v*n-#","45");
|
一个 HashMap 实例容纳两个名称-值对，每一个都是 String 的实例。
Groovy 使得处理映射的操作像处理列表一样简单 — 例如，可以用 Groovy 将上面的 Java 映射写成
def hash = [name:"Andy", "v*n-#":45] |
请注意，Groovy 映射中的键不必是
String。在这个示例中，
name 看起来像一个变量，但是在幕后，Groovy 会将它变成
String。