1、获取选中的radio的值：

　　使用元素选择器，再使用属性过滤器name='city'，最后使用:checked选取被选中的元素。

　　2、给指定值的radio设置选中状态：

　　给name="city"而且value="YangZhou"的radio设置选中状态。

　　3、取消name="city"的radio的选中状态：

　　4、获取name="city"的radio的个数：

　　5、获取name="city"而且索引是偶数的radio:

　　索引是从0开始的。

　　6、获取name="city"而且索引是奇数的radio:

　　索引是从0开始的。

　　7、迭代radio:

　　迭代name="city"的radio。

　　8、禁用radio:

　　禁用name="city"的radio。

　　9、启用radio:

　　启用name="city"的radio。

jquery-autocomplete学习

一、用前必备

官方网站：http://bassistance.de/jquery-plugins/jquery-plugin-autocomplete/

当前版本：1.0.2

需要JQuery版本：1.2.6

二、使用

<script src="./jquery-1.3.2.js" type="text/javascript"></script>

<script src="./jquery.autocomplete.js" type="text/javascript"></script>

<link rel="stylesheet" href="./jquery.autocomplete.css" />

autocomplete( url or data, options ) Returns: jQuery

让一个input或textarea有autocomplete功能

例子

Js代码

var data = "Core Selectors Attributes Traversing Manipulation CSS Events Effects Ajax Utilities".split(" ");  

$("#example").autocomplete(data);

以上的例子就是为id为example添加autocomplete

var emails = [

    { name: "Peter Pan", to: "peter@pan.de" },

    { name: "Molly", to: "molly@yahoo.com" },

    { name: "Forneria Marconi", to: "live@japan.jp" },

    { name: "Master <em>Sync</em>", to: "205bw@samsung.com" },

    { name: "Dr. <strong>Tech</strong> de Log", to: "g15@logitech.com" },

    { name: "Don Corleone", to: "don@vegas.com" },

    { name: "Mc Chick", to: "info@donalds.org" },

    { name: "Donnie Darko", to: "dd@timeshift.info" },

    { name: "Quake The Net", to: "webmaster@quakenet.org" },

    { name: "Dr. Write", to: "write@writable.com" }

];

//emails的数组格式如上，formatItem代表的是显示的格式，formatMatch表示匹配的内容，formatResult表示结果的内容

$("#suggest13").autocomplete(emails, {

    minChars: 0,

    width: 310,

    matchContains: true,

    autoFill: false,

    formatItem: function(row, i, max) {

        return i + "/" + max + ": \"" + row.name + "\" [" + row.to + "]";

    },

    formatMatch: function(row, i, max) {

        return row.name + " " + row.to;

    },

    formatResult: function(row) {

        return row.to;

    }

});

三、参数说明：

* minChars (Number):

    在触发autoComplete前用户至少需要输入的字符数.Default: 1，如果设为0，在输入框内双击或者删除输入框内内容时显示列表

* width (Number):

    指定下拉框的宽度. Default: input元素的宽度

* max (Number):

    autoComplete下拉显示项目的个数.Default: 10

* delay (Number):

    击键后激活autoComplete的延迟时间(单位毫秒).Default: 远程为400 本地10

* autoFill (Boolean):

    要不要在用户选择时自动将用户当前鼠标所在的值填入到input框. Default: false

* mustMatch (Booolean):

    如果设置为true,autoComplete只会允许匹配的结果出现在输入框,所有当用户输入的是非法字符时将会得不到下拉框.Default: false

* matchContains (Boolean):

    决定比较时是否要在字符串内部查看匹配,如ba是否与foo bar中的ba匹配.使用缓存时比较重要.不要和autofill混用.Default: false

* selectFirst (Boolean):

    如果设置成true,在用户键入tab或return键时autoComplete下拉列表的第一个值将被自动选择,尽管它没被手工选中(用键盘或鼠标).当然如果用户选中某个项目,那么就用用户选中的值. Default: true

* cacheLength (Number):

    缓存的长度.即对从数据库中取到的结果集要缓存多少条记录.设成1为不缓存.Default: 10

* matchSubset (Boolean):

    autoComplete可不可以使用对服务器查询的缓存,如果缓存对foo的查询结果,那么如果用户输入foo就不需要再进行检索了,直接使用缓存.通常是打开这个选项以减轻服务器的负担以提高性能.只会在缓存长度大于1时有效.Default: true

* matchCase (Boolean):

    比较是否开启大小写敏感开关.使用缓存时比较重要.如果你理解上一个选项,这个也就不难理解,就好比foot要不要到FOO的缓存中去找.Default: false

* multiple (Boolean):

    是否允许输入多个值即多次使用autoComplete以输入多个值. Default: false

* multipleSeparator (String):

    如果是多选时,用来分开各个选择的字符. Default: ","

* scroll (Boolean):

    当结果集大于默认高度时是否使用卷轴显示 Default: true

* scrollHeight (Number):

    自动完成提示的卷轴高度用像素大小表示 Default: 180  

* formatItem (Function):

    为每个要显示的项目使用高级标签.即对结果中的每一行都会调用这个函数,返回值将用LI元素包含显示在下拉列表中. Autocompleter会提供三个参数(row, i, max): 返回的结果数组, 当前处理的行数(即第几个项目,是从1开始的自然数), 当前结果数组元素的个数即项目的个数. Default: none, 表示不指定自定义的处理函数,这样下拉列表中的每一行只包含一个值.

* formatResult (Function):

    和formatItem类似,但可以将将要输入到input文本框内的值进行格式化.同样有三个参数,和formatItem一样.Default: none,表示要么是只有数据,要么是使用formatItem提供的值.

* formatMatch (Function):

    对每一行数据使用此函数格式化需要查询的数据格式. 返回值是给内部搜索算法使用的. 参数值row

* extraParams (Object):

    为后台(一般是服务端的脚本)提供更多的参数.和通常的作法一样是使用一个键值对对象.如果传过去的值是{ bar:4 },将会被autocompleter解析成my_autocomplete_backend.php?q=foo&bar=4 (假设当前用户输入了foo). Default: {}

* result (handler) Returns: jQuery

    此事件会在用户选中某一项后触发，参数为：

    event: 事件对象. event.type为result.

    data: 选中的数据行.

    formatted:formatResult函数返回的值

    例如：

    $("#singleBirdRemote").result(function(event, data, formatted) {

//如选择后给其他控件赋值，触发别的事件等等

});

四、注意问题：

1.网上有人说对中文的检索时处理有问题，经过测试此版本没有问题^-^

2.在使用远程地址时，它默认传入的参数是：q（输入值），limit（返回结果的最大值），可以使用extraParams传入其他的参数

3.autocomplete在使用ajax传递参数时，默认使用了get方式传递，也实在是没有找到可以通过参数提交post方式的办法。

解决方式1：在使用ajax的get方式传递中文时，使用new String(request.getParameter("q").getBytes("iso8859-1"),"utf-8")获得参数值

解决方式2：修改jquery.autocomplete.js代码，把get方式修改为post方式，然后参见之前ajax解决中文乱码的问题的

转载：http://blog.sina.com.cn/s/blog_608475eb0100g6qc.html

from InfoQ <http://www.infoq.com/cn/news/2009/02/grails-10-tips>

如果要列举近些年来Java领域中最令人激动的事件，Grails的诞生绝对应该榜上有名。在打开Grails官方网站<http://www.grails.org/>时， 
你会在浏览器的标题栏上看到这样的内容：“Grails - 寻找就此结束”。虽然这句话不见得适用于所有场合，但对于不少从事Java 
Web开发的人来说，赞同者恐怕不在少数。由于具备Rails风格的框架、兼容绝大多数Java语法的Groovy动态语言、以业界口碑良好的框架为基 
础、对企业现有Java开发资产的保护、Plugin架构等特点，再加上Spring社区的强力介入，Grails行情看涨应该是意料之中的。

然而Grails却没有看上去那么简单，在其包装的糖衣之下，有着许多作为Java Web开发者不得不了解的知识。最近，Peter 
Delahunty<http://blog.peterdelahunty.com/> 
发表了题为Grails开发者需要知道的10个技巧<http://blog.peterdelahunty.com/2009/02/10-ten-tips-for-grails-develop...> 
的博文。不要被标题所迷惑了，这里所说的“技巧”可不是那些语言层面的“技巧”，把它们称为“建议”恐怕更合适一些。

技巧1：把Grails的书籍买来读读。对此，Peter Delahunty推荐了已出版的《Definitive Guide to Grails 2nd 
edition》和《Groovy and Grails Recipes》，以及即将出版的《Grails in Action》。

技巧2：学习Groovy，并按照Groovy进行思考。Peter Delahunty通过一个例子说明了Java思维和Groovy思维的不同。

这儿有个好例子：

传播操作符（spread operator）：*

在Java中，要想遍历一组人并收集人名。我可能得这样写：

List names = new ArrayList(); 
for (Iterator iterator = people.iterator(); iterator.hasNext();) { 
Person person = (Person) iterator.next(); 
names.add(person.getName());

用Groovy，我会这么写：

def names = people*.name 
println names

呵呵，简单吧。我还可以这样写：

def names = people.collect {it.name} 
println names

在这个建议中，他列举了一些资源：

- Groovy官方网站 <http://groovy.codehaus.org/> 
- PLEAC <http://pleac.sourceforge.net/pleac_groovy/index.html>

以及一些书籍：

- Programming Groovy 
- Groovy Recipies 
- Groovy in action

技巧3：了解Grails的各个插件。Peter 
Delahunty给出的理由：Grails本身是个插件系统，而且现在已经有大量的插件可供下载。在自行实现之前，不妨看看其中是否有称手的。

技巧4：学习Hibernate和Spring。这一点不难理解，既然Grails是建立在这些工具之上的，了解这些工具本身的使用，对于熟练使用Grails 自然大有脾益。

技巧5：使单元测试、集成测试和一般测试的自动化。Peter Delahunty在这里推荐了两个Grails的插件：Testing 
Plugin<http://www.grails.org/Testing+Plugin> 
和Functional testing plugin 
<http://www.grails.org/Grails+Functional+Testing>。前者将成为Grails 
1.1的内置插件。

技巧6：使用好的IDE。Peter Delahunty表示，他自己使用的是Intellij，但对于Netbeans也寄予厚望。

技巧7：学习并使用HTML W3C标准。“遵循标准将消除你90%的问题”，Peter Delahunty如是说。

技巧8：看上去不错一定不错。这其实说的是“面子工程”，通过提高应用的外观设计来提高应用的竞争力。Peter Delahunty给出了2个资源：

- 99designs.com 
- 圆角矩形产生器 <http://www.roundedcornr.com/>

技巧9：使用Firefox上的Firebug。对于浏览器端的调试工作，Firebug绝对是一个必备工具。

技巧10：跟上Groovy和Grails社区的步伐。在这最后一个建议中，Peter 
Delahunty给出了获取Groovy和Grails信息的主要资源链接：

- Grails官方网站 <http://www.grails.org/> 
- Groovy和Grails相关的博客 <http://groovyblogs.org/entries/recent> 
- Grails创始人Graeme Rocher的Twitter <http://twitter.com/graemerocher> 
- Groovy项目领导人Guillaume Laforge的Twitter <http://twitter.com/glaforge> 
- Groovyblogs.org的创始人Glen Smith <http://twitter.com/glen_a_smith>

请务必阅读Peter Delahunty的原文<http://blog.peterdelahunty.com/2009/02/10-ten-tips-for-grails-develop...>。对于Grails的新老使用者，你都可以从Peter 
Delahunty的建议中有所收获。关于InfoQ中文站Groovy和Grails的其它内容，请访问这里<http://www.infoq.com/cn/groovy> 
和这里 <http://www.infoq.com/cn/grails>。

迭代是编程的基础。您经常会遇到需要进行逐项遍历的内容，比如 List、File 和 JDBC ResultSet。Java 语言几乎总是提供了某种方法帮助您逐项遍历所需的内容，但令人沮丧的是，它并没有给出一种标准方法。Groovy 的迭代方法非常实用，在这一点上，Groovy 编程与 Java 编程截然不同。通过一些代码示例，本文将介绍 Groovy 的万能的 each() 方法，从而将 Java 语言的那些迭代怪癖抛在脑后。

Java 迭代策略

假设您有一个 Java 编程语言的 java.util.List。清单 1 展示了在 Java 语言中如何使用编程实现迭代：

import java.util.*;  
public class ListTest{
 public static void main(String[] args){
 List<String> list = new ArrayList<String>();
 list.add("Java");
 list.add("Groovy");
 list.add("JavaScript");
 for(Iterator<String> i = list.iterator(); i.hasNext();){
 String language = i.next();
 System.out.println("I know " + language);
 }
 }
 } 

由于提供了大部分集合类都可以共享的 java.lang.Iterable 接口，您可以使用相同的方法遍历 java.util.Set 或 java.util.Queue。

现在，假设该语言存储在 java.util.Map 中。在编译时，尝试对 Map 获取 Iterator 会导致失败 — Map 并没有实现 Iterable 接口。幸运的是，可以调用 map.keySet() 返回一个 Set，然后就可以继续处理。这些小差异可能会影响您的速度，但不会妨碍您的前进。需要注意的是，List、Set 和 Queue 实现了 Iterable，但是 Map 没有 — 即使它们位于相同的 java.util 包中。

现在假设该语言存在于 String 数组中。数组是一种数据结构，而不是类。不能对 String 数组调用 .iterator()，因此必须使用稍微不同的迭代策略。您再一次受到阻碍，但可以使用如清单 2 所示的方法解决问题：

public class ArrayTest{
 public static void main(String[] args){
 String[] list = {"Java", "Groovy", "JavaScript"};
 for(int i = 0; i < list.length; i++){
 String language = list[i];
 System.out.println("I know " + language);
 }
 }
 } 

但是等一下 — 使用 Java 5 引入的 for-each 语法怎么样？它可以处理任何实现 Iterable 的类和数组，如清单 3 所示：

import java.util.*;
 public class MixedTest{
 public static void main(String[] args){
 List<String> list = new ArrayList<String>();
 list.add("Java");
 list.add("Groovy");
 list.add("JavaScript");
 for(String language: list){
 System.out.println("I know " + language);
 }      
String[] list2 = {"Java", "Groovy", "JavaScript"};
 for(String language: list2){
 System.out.println("I know " + language);
 }
 }
 } 

因此，您可以使用相同的方法遍历数组和集合（Map 除外）。但是如果语言存储在 java.io.File，那该怎么办？如果存储在 JDBC ResultSet，或者存储在 XML 文档、java.util.StringTokenizer 中呢？面对每一种情况，必须使用一种稍有不同的迭代策略。这样做并不是有什么特殊目的 — 而是因为不同的 API 是由不同的开发人员在不同的时期开发的 — 但事实是，您必须了解 6 个 Java 迭代策略，特别是使用这些策略的特殊情况。

Eric S. Raymond 在他的 The Art of Unix Programming 一书中解释了 “最少意外原则”。他写道，“要设计可用的接口，最好不要设计全新的接口模型。新鲜的东西总是难以入门；会为用户带来学习的负担，因此应当尽量减少新内 容。”Groovy 对迭代的态度正是采纳了 Raymond 的观点。在 Groovy 中遍历几乎任何结构时，您只需要使用 each() 这一种方法。

Groovy 中的列表迭代

首先，我将 清单 3 中的 List 重构为 Groovy。在这里，只需要直接对列表调用 each() 方法并传递一个闭包，而不是将 List 转换成 for 循环（顺便提一句，这样做并不是特别具有面向对象的特征，不是吗）。

创建一个名为 listTest.groovy 的文件并添加清单 4 中的代码：

def list = ["Java", "Groovy", "JavaScript"] list.each{language->   println language } 

清单 4 中的第一行是 Groovy 用于构建 java.util.ArrayList 的便捷语法。可以将 println list.class 添加到此脚本来验证这一点。接下来，只需对列表调用 each()，并在闭包体内输出 language 变量。在闭包的开始处使用 language-> 语句命名 language 变量。如果没有提供变量名，Groovy 提供了一个默认名称 it。在命令行提示符中输入 groovy listTest 运行 listTest.groovy。

清单 5 是经过简化的 清单 4 代码版本：

 // shorter, using the default it variable 
def list = ["Java", "Groovy", "JavaScript"]
 list.each{ println it }
 // shorter still, using an anonymous 
list ["Java", "Groovy", "JavaScript"].each{ println it } 

Groovy 允许您对数组和 List 交替使用 each() 方法。为了将 ArrayList 改为 String 数组，必须将 as String[] 添加到行末，如清单 6 所示：

def list = ["Java", "Groovy", "JavaScript"] as String[] list.each{println it} 

在 Groovy 中普遍使用 each() 方法，并且 getter 语法非常便捷（getClass() 和 class 是相同的调用），这使您能够编写既简洁又富有表达性的代码。例如，假设您希望利用反射显示给定类的所有公共方法。清单 7 展示了这个例子：

def s = "Hello World"
 println s 
println s.class
 s.class.methods.each{println it}
 //output: 
$ groovy reflectionTest.groovy
 Hello World
 class java.lang.String
 public int java.lang.String.hashCode()
 public volatile int java.lang.String.compareTo(java.lang.Object)
 public int java.lang.String.compareTo(java.lang.String)
 public boolean java.lang.String.equals(java.lang.Object) ... 

脚本的最后一行调用 getClass() 方法。java.lang.Class 提供了一个 getMethods() 方法，后者返回一个数组。通过将这些操作串连起来并对 Method 的结果数组调用 each()，您只使用了一行代码就完成了大量工作。

但是，与 Java for-each 语句不同的是，万能的 each() 方法并不仅限于 List 和数组。在 Java 语言中，故事到此结束。然而，在 Groovy 中，故事才刚刚开始。

Map 迭代

从前文可以看到，在 Java 语言中，无法直接迭代 Map。在 Groovy 中，这完全不是问题，如清单 8 所示：

def map = ["Java":"server", "Groovy":"server", "JavaScript":"web"] map.each{ println it } 

要处理名称/值对，可以使用隐式的 getKey() 和 getValue() 方法，或在包的开头部分显式地命名变量，如清单 9 所示：

def map = ["Java":"server", "Groovy":"server", "JavaScript":"web"]
 map.each{
 println it.key
 println it.value
 }  
map.each{k,v->
 println k
 println v
 } 

可以看到，迭代 Map 和迭代其它任何集合一样自然。

在继续研究下一个迭代例子前，应当了解 Groovy 中有关 Map 的另一个语法。与在 Java 语言中调用 map.get("Java") 不一样，可以简化对 map.Java 的调用，如清单 10 所示：

def map = ["Java":"server", "Groovy":"server", "JavaScript":"web"]
 //identical results
 println map.get("Java")
 println map.Java 

不可否认，Groovy 针对 Map 的这种便捷语法非常酷，但这也是在对 Map 使用反射时引起一些常见问题的原因。对 list.class 的调用将生成 java.util.ArrayList，而调用 map.class 返回 null。这是因为获得 map 元素的便捷方法覆盖了实际的 getter 调用。Map 中的元素都不具有 class 键，因此调用实际会返回 null，如清单 11 的示例所示：

def list = ["Java", "Groovy", "JavaScript"]
 println list.class
 // java.util.ArrayList
 def map = ["Java":"server", "Groovy":"server", "JavaScript":"web"]
 println map.class
 // null
 map.class = "I am a map element"
 println map.class
 // I am a map element
 println map.getClass()
 // class
 java.util.LinkedHashMap 

这是 Groovy 比较罕见的打破 “最少意外原则” 的情况，但是由于从 map 获取元素要比使用反射更加常见，因此我可以接受这一例外。

String 迭代

现在您已经熟悉 each() 方法了，它可以出现在所有相关的位置。假设您希望迭代一个 String，并且是逐一迭代字符，那么马上可以使用 each() 方法。如清单 12 所示：

def name = "Jane Smith" name.each{letter->
 println letter
 } 

这提供了所有的可能性，比如使用下划线替代所有空格，如清单 13 所示：

def name = "Jane Smith"
 println "replace spaces" 
name.each{
 if(it == " "){
 print "_"
 }else{
 print it
 }
 }
 // output Jane_Smith 

当然，在替换一个单个字母时，Groovy 提供了一个更加简洁的替换方法。您可以将清单 13 中的所有代码合并为一行代码："Jane Smith".replace(" ", "_")。但是对于更复杂的 String 操作，each() 方法是最佳选择。

Range 迭代

Groovy 提供了原生的 Range 类型，可以直接迭代。使用两个点分隔的所有内容（比如 1..10）都是一个 Range。清单 14 展示了这个例子：

def range = 5..10 range.each{
 println it
 }
 //output: 5 6 7 8 9 10 

Range 不局限于简单的 Integer。考虑清单 15 在的代码，其中迭代 Date 的 Range：

def today = new Date()
 def nextWeek = today + 7
 (today..nextWeek).each{
 println it
 } 
 //output: Thu Mar 12 04:49:35 MDT 2009
 Fri Mar 13 04:49:35 MDT 2009 
Sat Mar 14 04:49:35 MDT 2009 
Sun Mar 15 04:49:35 MDT 2009 
Mon Mar 16 04:49:35 MDT 2009 
Tue Mar 17 04:49:35 MDT 2009 
Wed Mar 18 04:49:35 MDT 2009 
Thu Mar 19 04:49:35 MDT 2009 

可以看到，each() 准确地出现在您所期望的位置。Java 语言缺乏原生的 Range 类型，但是提供了一个类似地概念，采取 enum 的形式。毫不奇怪，在这里 each() 仍然派得上用场。

Enumeration 类型

Java enum 是按照特定顺序保存的随意的值集合。清单 16 展示了 each() 方法如何自然地配合 enum，就好象它在处理 Range 操作符一样：

enum DAY{
 MONDAY, TUESDAY, WEDNESDAY, THURSDAY,
 FRIDAY, SATURDAY, SUNDAY
 }
 DAY.each{
 println it
 }
 (DAY.MONDAY..DAY.FRIDAY).each{
 println it
 } 

在 Groovy 中，有些情况下，each() 这个名称远未能表达它的强大功能。在下面的例子中，将看到使用特定于所用上下文的方法对 each() 方法进行修饰。Groovy eachRow() 方法就是一个很好的例子。

SQL 迭代

在处理关系数据库表时，经常会说 “我需要针对表中的每一行执行操作”。比较一下前面的例子。您很可能会说 “我需要对列表中的每一种语言执行一些操作”。根据这个道理，groovy.sql.Sql 对象提供了一个 eachRow() 方法，如清单 17 所示：

import groovy.sql.*
 def sql = Sql.newInstance(
 "jdbc:derby://localhost:1527/MyDbTest;create=true",
 "username",
 "password",
 "org.apache.derby.jdbc.ClientDriver")
 println("grab a specific field")
 sql.eachRow("select name from languages"){ row ->
 println row.name
 }
 println("grab all fields")
 sql.eachRow("select * from languages"){ row ->
 println("Name: ${row.name}")
 println("Version: ${row.version}")
 println("URL: ${row.url}\n")
 } 

该脚本的第一行代码实例化了一个新的 Sql 对象：设置 JDBC 连接字符串、用户名、密码和 JDBC 驱动器类。这时，可以调用 eachRow() 方法，传递 SQL select 语句作为一个方法参数。在闭包内部，可以引用列名（name、version、url），就好像实际存在 getName()、getVersion() 和 getUrl() 方法一样。

这显然要比 Java 语言中的等效方法更加清晰。在 Java 中，必须创建单独的 DriverManager、Connection、Statement 和 JDBCResultSet，然后必须在嵌套的 try/catch/finally 块中将它们全部清除。

对于 Sql 对象，您会认为 each() 或 eachRow() 都是一个合理的方法名。但是在接下来的示例中，我想您会认为 each() 这个名称并不能充分表达它的功能。

文件迭代

我从未想过使用原始的 Java 代码逐行遍历 java.io.File。当我完成了所有的嵌套的 BufferedReader 和 FileReader 后（更别提每个流程末尾的所有异常处理），我已经忘记最初的目的是什么。

清单 18 展示了使用 Java 语言完成的整个过程：

import java.io.BufferedReader;
 import java.io.FileNotFoundException;
 import java.io.FileReader; import java.io.IOException;
 public class WalkFile {
 public static void main(String[] args) {
 BufferedReader br = null;
 try {
 br = new BufferedReader(new FileReader("languages.txt"));
 String line = null;
 while((line = br.readLine()) != null) {
 System.out.println("I know " + line);
 }
 }
 catch(FileNotFoundException e) {
 e.printStackTrace();
 }
 catch(IOException e) {
 e.printStackTrace();
 }
 finally {
 if(br != null) {
 try {
 br.close();
 }             
catch(IOException e) {
 e.printStackTrace();
 }
 }
 }
 }
 } 

清单 19 展示了 Groovy 中的等效过程：

def f = new File("languages.txt") f.eachLine{language->
 println "I know ${language}"
} 

这正是 Groovy 的简洁性真正擅长的方面。现在，我希望您了解为什么我将 Groovy 称为 “Java 程序员的 DSL”。

注意，我在 Groovy 和 Java 语言中同时处理同一个 java.io.File 类。如果该文件不存在，那么 Groovy 代码将抛出和 Java 代码相同的 FileNotFoundException 异常。区别在于，Groovy 没有已检测的异常。在 try/catch/finally 块中封装 eachLine() 结构是我自己的爱好 — 而不是一项语言需求。对于一个简单的命令行脚本中，我欣赏 清单 19 中的代码的简洁性。如果我在运行应用服务的同时执行相同的迭代，我不能对这些异常坐视不管。我将在与 Java 版本相同的 try/catch 块中封装 eachLine() 块。

File 类对 each() 方法进行了一些修改。其中之一就是 splitEachLine(String separator, Closure closure)。这意味着您不仅可以逐行遍历文件，同时还可以将它分为不同的标记。清单 20 展示了一个例子：

// languages.txt
 // notice the space between the language and the version Java 1.5 Groovy 1.6 JavaScript 1.x
 // splitTest.groovy 
def f = new File("languages.txt")
 f.splitEachLine(" "){words->
 words.each{ println it
 }
 } 
 // output Java 1.5 Groovy 1.6 JavaScript 1.x 

如果处理的是二进制文件，Groovy 还提供了一个 eachByte() 方法。

当然，Java 语言中的 File 并不总是一个文件 — 有时是一个目录。Groovy 还提供了一些 each() 修改以处理子目录。

目录迭代

使用 Groovy 代替 shell 脚本（或批处理脚本）非常容易，因为您能够方便地访问文件系统。要获得当前目录的目录列表，参见清单 21：

def dir = new File(".") dir.eachFile{file->
 println file
 } 

eachFile() 方法同时返回了文件和子目录。使用 Java 语言的 isFile() 和 isDirectory() 方法，可以完成更复杂的事情。清单 22 展示了一个例子：

def dir = new File(".") dir.eachFile{file->
 if(file.isFile()){
 println "FILE: ${file}"
 }else if(file.isDirectory()){
 println "DIR:  ${file}"
 }else{
 println "Uh, I'm not sure what it is..."
 }
 } 

由于两种 Java 方法都返回 boolean 值，可以在代码中添加一个 Java 三元操作符。清单 23 展示了一个例子：

def dir = new File(".")
 dir.eachFile{file->
 println file.isDirectory() ? "DIR:  ${file}" : "FILE: ${file}"
 } 

如果只对目录有兴趣，那么可以使用 eachDir() 而不是 eachFile()。还提供了 eachDirMatch() 和 eachDirRecurse() 方法。

可以看到，对 File 仅使用 each() 方法并不能提供足够的含义。典型 each() 方法的语义保存在 File 中，但是方法名更具有描述性，从而提供更多有关这个高级功能的信息。

URL 迭代

理解了如何遍历 File 后，可以使用相同的原则遍历 HTTP 请求的响应。Groovy 为 java.net.URL 提供了一个方便的（和熟悉的）eachLine() 方法。

例如，清单 24 将逐行遍历 ibm.com 主页的 HTML：

def url = new URL("http://www.ibm.com")
 url.eachLine{line->
 println line
 } 

当然，如果这就是您的目的的话，Groovy 提供了一个只包含一行代码的解决办法，这主要归功于 toURL() 方法，它被添加到所有 Strings："http://www.ibm.com".toURL().eachLine{ println it }。

但是，如果希望对 HTTP 响应执行一些更有用的操作，该怎么办呢？具体来讲，如果发出的请求指向一个 RESTful Web 服务，而该服务包含您要解析的 XML，该怎么做呢？each() 方法将在这种情况下提供帮助。

XML 迭代

您已经了解了如何对文件和 URL 使用 eachLine() 方法。XML 给出了一个稍微有些不同的问题 — 与逐行遍历 XML 文档相比，您可能更希望对逐个元素进行遍历。

例如，假设您的语言列表存储在名为 languages.xml 的文件中，如清单 25 所示：

<langs>
 <language>Java</language>
 <language>Groovy</language>
 <language>JavaScript</language>
 </langs> 

Groovy 提供了一个 each() 方法，但是需要做一些修改。如果使用名为 XmlSlurper 的原生 Groovy 类解析 XML，那么可以使用 each() 遍历元素。参见清单 26 所示的例子：

def langs = new XmlSlurper().parse("languages.xml")
 langs.language.each{
 println it
 }
 //output Java Groovy JavaScript 

langs.language.each 语句从名为 <language> 的 <langs> 提取所有元素。如果同时拥有 <format> 和 <server> 元素，它们将不会出现在 each() 方法的输出中。

如果觉得这还不够的话，那么假设这个 XML 是通过一个 RESTful Web 服务的形式获得，而不是文件系统中的文件。使用一个 URL 替换文件的路径，其余代码仍然保持不变，如清单 27 所示：

def langs = new XmlSlurper().parse("http://somewhere.com/languages")
 langs.language.each{
 println it
 } 

这真是个好方法，each() 方法在这里用得很好，不是吗？

结束语

在使用 each() 方法的整个过程中，最妙的部分在于它只需要很少的工作就可以处理大量 Groovy 内容。解了 each() 方法之后，Groovy 中的迭代就易如反掌了。正如 Raymond 所说，这正是关键所在。一旦了解了如何遍历 List，那么很快就会掌握如何遍历数组、Map、String、Range、enum、SQL ResultSet、File、目录和 URL，甚至是 XML 文档的元素。

本文的最后一个示例简单提到使用 XmlSlurper 实现 XML 解析。在下一期文章中，我将继续讨论这个问题，并展示使用 Groovy 进行 XML 解析有多么简单！您将看到 XmlParser 和 XmlSlurper 的实际使用，并更好地了解 Groovy 为什么提供两个类似但又略有不同的类实现 XML 解析。到那时，希望您能发现 Groovy 的更多实际应用。