String data = getStringData();

            Pattern repPattern = Pattern.compile("(\\s)(repetition)([\\s;\\.,])");

            Matcher repMatcher = repPattern.matcher(data);

            String newData = repMatcher.replaceAll("$1duplication$3");  

为了查找单词，需要捕获它前后的空白(或标点符号)。需要注意的是，如果此单词出现在data字符串的开头，那么上述的代码不会匹配它，因为已假定它的前后存在空白符。除了单词repetition被替换外，我们希望文本中的其他内容与原始文本保持一致，包括单词周围的空白字符。这里的美元符号($)显然不表示货币。它表示对从regex模式中捕获的组1和组3的逆向引用，包含最初匹配的空白或标点符号。这样，与它们对应的值将插入到替换文本中。

String类(在JDK 1.4或更高的版本中)有一个replaceAll方法，其工作机制类似于Matcher中的replaceAll方法。这使得它可以很方便地替换一个与模式匹配的子串：

String data = getStringData();

            String result =

            data.replaceAll("(\\s)(repetition)([\\s;\\.,])", "$1duplication$3");    

replaceAll方法返回一个新的字符串，其中所有匹配的部分已被新值替换。但是，使用Matcher仍有很多优点，因为相对于字符串它有更大的灵活性。

可以使用Matcher的find循环用新值依次替换每个匹配的部分。这样使你能够更好地控制替换过程。比如，可以在每次匹配的过程中应用其他逻辑，甚至每次可以替换不同的值。这就用到了StringBuffer，StringBuffer用于保存更新的文本，并且一旦调用appendReplacement方法，Matcher就追加更新后的文本到缓存中。在处理每个匹配并执行替换后，需要使用appendTail方法将最后一次匹配后的剩余字符串放置在输出缓存中。图2-1说明了子串匹配和这两种方法之间的关系。

图2-1  Matcher类的append方法

StringBuffer result = new StringBuffer();

            String[] wordChoices = new String[]

            {"repetition", "duplication", "copying",

            "reiteration", "recurrence", "redundancy"};

            Random rand = new Random();

            String data = getStringData();

            Pattern repPattern = Pattern.compile("(\\s)(repetition)([\\s;\\.,])");

            Matcher repMatcher = repPattern.matcher(data);

            while (repMatcher.find()) {

            // pick a word at random

            int wordIndex = rand.nextInt(wordChoices.length);

            String replacement = "$1" + wordChoices[wordIndex] + "$3";

            repMatcher.appendReplacement(result, replacement);

            }

            repMatcher.appendTail(result);

            System.out.println(result);   

// assume urlMatcher instance as in the previous example while (urlMatcher.find()) { int startIndex = urlMatcher.start(); int endIndex = urlMatcher.end(); String currentMatch = data.substring(startIndex, endIndex); // the brute force approach, using a new pattern! Pattern restricted = Pattern.compile(".*(abc|cbs|nbc)\\.com.*"); Matcher restrictMatcher = restricted.matcher(currentMatch); if (!restrictMatcher.matches()) { System.out.println(currentMatch); } }

在捕获的URL中匹配域名并不是一个非常高效的方法。由于已经使用find方法完成了提取URL的困难工作，不应该仅仅为了获得结果的一部分而编写另一个regex，并且也不必这样做。正则表达式允许将模式分解成子序列。使用圆括号，将以后要用到的模式部分括起来，这样，我们就可以忽略其余部分单独读取这些部分的值。重写URL模式以使域名可以与URL的其他部分相分离：

String urlPattern = "(http|https|ftp)://([a-zA-Z0-9-\\.]+)[/\\w\\.\\-\\+\\?%=&;:,#]*";

当在模式中存在用括号括起来的组时，可以分别检索每个组的匹配值。从最左边的组开始编为1，然后依次对每对括号相对应的组进行编号。在上面的模式中，第一组是协议(如http)，第二组是域名。为了在匹配的字符串中访问组，可以使用Matcher的group方法。下面的代码示例从每个URL中检索域名并显示它们的值：

String data = getStringData(); // load the document String urlString = "(http|https|ftp)://([a-zA-Z0-9-\\.]+)[/\\w\\.\\-\\+\\?%=&;:,#]*"; Pattern urlPattern = Pattern.compile(urlString); Matcher urlMatcher = urlPattern.matcher(data); // print out the domain from each URL while (urlMatcher.find()) { String domain = urlMatcher.group(2); // 2nd group is the domain System.out.println(domain); }

保存每个匹配的组以便可以随后引用它们。在一个模式内引用一个以前的匹配组称为逆向引用(backreference)。为了对第三个组进行逆向引用，在模式中包括\3即可。这将会只匹配一个与以前的组相匹配的严格重复的数据。为了说明此问题，考虑一个在文本文件中常见的错误—— 一个句子中意外地重复出现某个常用的单词，如“the”或“of”。

" The the water molecules are made of of hydrogen and oxygen."

下面编写一个模式来找出文件中存在的这些问题。该模式将捕获第一个单词，后跟一些空白符，而其后又跟着匹配第一个单词的重复模式：

String wordPattern = "\\s(of|or|the|to)\\s+\\1[\\s\\.,;]";

该模式匹配情况如下：一个空白字符、特殊的单词列表中的一个单词、更多的空白、再次重复的相同的单词(使用\1逆向引用)以及空白符或标点符号。这种匹配应不区分大小写，以便能够捕获到“The the”以及类似的变型。如以下的代码段所示，该模式不区分大小写，能在一个字符串中查找重复出现的模式：

String data = getStringData(); String patternStr = "\\s(of|or|the|to)\\s+\\1[\\s\\.,;]"; Pattern wordPattern = Pattern.compile(patternStr, Pattern.CASE_INSENSITIVE); Matcher wordMatcher = wordPattern.matcher(data); while (wordMatcher.find()) { int start = wordMatcher.start(); String word = wordMatcher.group(1); // print the index location of the repeated word System.out.println("Repeated " + word + " starting at " + start); }

有一种简便和强大的匹配文件中文本的方法，该方法允许使用多个正则表达式来处理文件，本章后面的“使用Scanner类进行语法分析”一节将会讲解此方法。若想了解使用内置索引进行更为复杂的文本搜索的解决方法，请参考第3章中“使用Lucene进行搜索”一节的内容。

在Java中，通过使用适当命名的Pattern类可以容易地确定String是否匹配某种模式。模式可以像匹配某个特定的String值那样简单，也可以很复杂，需要采用分组和字符类，如空白、数字、字母或控制符。由于它们是Java字符串并且基于Unicode(统一字符编码)，正则表达式也适用于国际化的应用程序。

正则式是最简单的能准确匹配一个给定String的模式。换句话说，模式与所要匹配的文本是等价的。静态的Pattern.matches方法用于比较一个String是否匹配一个给定模式。 以下的代码将检查变量data中的值是否与单词“Java”相匹配：

String data = getStringData(); // populate the String somehow

            boolean result = Pattern.matches("Java", data); // is it "Java"?  

对于直接匹配字符串和简单的模式而言，你很可能不会使用正则表达式，因为这实际上就是低效率版本的"Java".equals(data)。Regex的真正强大之处体现在使用包括字符类和量词(*、+和?)的更复杂的模式上。目前已有很多优秀的有关正则表达式模式的书籍，因此这里只讨论模式的一些基本特性并重点讨论Java的regex类和方法。为了快速了解这些特性，这里给出一些在正则表达式中使用的特殊字符，其中每一个均代表一类字符，在regex术语中它称为字符类：

\d   数字 \D  非数字 \w  单字字符(0–9，A–Z，a–z，_ ) \W  非单字字符 \s   空白(空格符、换行符、回车键、制表符) \S   非空白 [ ]  由方括号内的一个字符列表创建的自定义字符类 .    匹配任何单个字符(除了换行符)

大多数字符在一个模式表达式中代表它们自己，但是一些字符有其特殊含义。上面使用的反斜杠(转义字符)就是一个例子。下面的字符用于控制将一个子模式应用到匹配过程的次数。这些特殊字符的处理方式不同于其他字符：

?   重复前面的子模式零次或一次 *   重复前面的子模式零次或多次 +   重复前面的子模式一次或多次

下面的正则表达式可以匹配任何对先辈的称呼，如father、great-great-grandmother或great-great-great-grandfather。正如下面的示例所示，通过使用括弧中的子表达式可以创建更复杂的正则表达式：

((great–)*grand)?(mother|father)

接下来这个模式表达式将会匹配一个以一个数字开头后跟零个或多个非空白字符的任意字符串(例如它将匹配“3”、“5x”和“56abcd9”，而不匹配“8 5”或“hello”)：

\d\S*

要谨慎使用regex反斜杠字符，因为在Java中它也是String文字转义字符。如果使用一个String文字来保存正则表达式，将需要通过使用两个反斜杠来转义反斜杠本身。例如：

String digitNonSpacePattern = "\\d\\S*"; String data = getStringData(); boolean isMatch = Pattern.matches(digitNonSpacePattern, data);

此外，模式匹配也内置于String类本身。在String类中有一个新的简便方法：matches。可以如下重写以上的代码：

boolean isMatch = getStringData().matches("\\d\\S*");

Pattern.matches方法和String的matches方法都适合一次性使用，但是若重复使用它们的效率较低。通过使用静态的Pattern.compile方法创建一个Pattern实例可以得到一个更高效的用于执行多次匹配的编译版本的模式。Pattern对象可以和java.util.regex.Matcher类协同工作。为了执行复杂的匹配，需要创建Matcher(匹配器)。Matcher将一个模式表达式绑定到一个特定的字符串，以便执行更高级的匹配操作。以下的代码段编译了一个匹配仅由单个字符组成的模式：

String data = getStringData(); Pattern namePattern = Pattern.compile("\\w+"); // get a Matcher to apply the pattern to the data Matcher nameMatcher = namePattern.matcher(data); boolean isMatch = nameMatcher.matches();

要记住matches方法将会对整个输入字符串和模式进行匹配。如果希望检查字符串是否仅以模式开头，则可以使用lookingAt方法：

boolean startsWith = nameMatcher.lookingAt();

在以下几个小节中将会讨论其他一些匹配技术，包括查找匹配一个模式的子串以及执行文本替换。

这里举出一个Java编程程序员经常碰到的问题。例如现在是凌晨3点，在你喝完第4杯咖啡后，你设法找到正确的逻辑来解决复杂的编程问题。到目前，你几乎不能思考String和Object引用，因为你已经昏昏欲睡了。然后糟糕的事情发生了……不，并不是Java溢出，而是如下所示。

String name = getName(); if (name == "Sleepy") // oops! { doSomething(); }

你快速编译并测试代码后，代码似乎正常运行。终于到下班回家休息的时候了！然而，一段时间后，应用程序测试发现了一个间歇性错误，并跟踪到此错误的来源恰好是这段代码。

“怎么会这样？”你可能会愤怒地说，“前几天我还试验过类似的String比较，并且能够正确运行！”。但是，你需要首先重温一下Java对象引用的概念。一个对象变量是一个指向存储在堆内存(heap memory)中实际对象的引用(指针)。当为另一个变量分配一个变量时，事实上分配的是引用而不是实际的对象(如图1-1所示)：

String a, b, c, d; a = "123"; b = a; c = new String("123"); d = "WCJ";

图 1-1  对象引用

Java中，“==”运算符用来比较两个引用以查看它们是否指向同一个内存对象。而对于String实例，运行时状态会尽可能地确保任意两个具有相同字符信息的String字面值指向同一个内部对象。此过程称为驻留(interning)，但是它并不有助于每个String的比较。一个原因是垃圾收集器线程删除了驻留值，另一个原因是String所在的位置可能被一个由String构造函数创建的新实例占用。如果是这样，“==”将总是返回false。
可以设计equals方法来比较两个对象的状态(state)或每个对象的内容。对你自己的类，必须重写此方法来使它正确操作。但是如果使用equals方法，String实例总是能够正确地比较。假定所有的String值是驻留的，下面的代码段说明了此问题：

String name1, name2, name3; name1 = "123"; name2 = name1; if (name1 == name2) {}         // true if (name1.equals(name2)) {}    // true name2 = "123"; if (name1 == name2) {}         // usually true if (name1.equals(name2)) {}    // true name3 = new String("123"); if (name1 == name3) {}         // false if (name1.equals(name3)) {}    // true

注意：

总是使用.equals来比较两个String值，尽管使用“==”运算符看似能够正确操作。对于大多数应用程序而言，即使它能正确运行，但“==”代码事实上是错误的，而只有equals是正确的。因此告诉所有你的开发同行支持String的“equals(平等)”权吧(这很可能是本书中最差的双关语)！

Java1.1+

当进行Java开发时，有时需要实现一个仅包含1~2个方法的接口，并且每个方法只有1~2行代码。在AWT和Swing开发中经常会出现这种情况，例如当一个display组件需要一个事件回调方法(如一个按钮的ActionListener)时。如果使用普通的类来实现此操作，最终会得到很多仅在单个位置上使用的小型类。其实，Java允许定义内部类，而且可以在GUI架构外使用内部类。

内部类(inner class)是指在另一个类内部定义的一个类。可以将内部类定义为一个类的成员，如下例所示：

public class Linker {

            public class LinkedNode {

            LinkedNode prev, next;

            Object contents;

            }
            
public Linker() {

            LinkedNode first = new LinkedNode();

            LinkedNode second = new LinkedNode();

            first.next = second;

            first.contents = "This is the first item";

            second.prev = first;

            second.contents = "This is the second item";

            }

            }   
            

这是一个在Java中实现的简单链表。LinkedNode类是Linker类的内部类。尽管此类包含在Linker类中，仍可以从其他类访问它，因为将它定义为公有的(public)。通过使用new Linker.LinkedNode()，可以从其他类创建它的一个实例。源自核心API的Map.Entry类就是这样一个类，当在一个映射表中检索“键/值”表项的集合时，java.util.Map类会用到此类。

此外，还可以定义一个局限于一个方法的内部类。这种类型的类只在定义它的方法内是可见的。如果要实现一个接口并且希望在方法内不止一次地使用局部类，那么很可能这样做，如下面这个实例所示：

public class Happiness { interface Smiler { public void smile(); } public static void main(String[] args) { class Happy implements Smiler { private String more = ""; public void smile() { System.out.println(":-)" + more); } public void happier() { more += ")"; } } Happy h1 = new Happy(); h1.smile(); Happy h2 = new Happy(); h2.happier(); h2.smile(); } }

局部内部类的名称为Happy(我喜欢把它看作内部者的类)。它不能从其他任何类或方法中访问。使用这个局部类是为了实现Smiler接口(它是在Happiness内部定义的)。对于很多情况而言，甚至不需要为一个局部内部类命名—— 它可以保持为匿名的。对于实现仅有1~2个方法的接口而言匿名类非常有用，尤其是当需要创建一个仅使用一次的实例的时候。通常情况下不能直接实例化一个接口。例如，不能调用Runnable接口的构造函数(这是由Thread使用的接口)。下面的做法是非法的：

Runnable runner = new Runnable(); // not allowed!

但是，Java确实允许创建一个用于实现接口的匿名局部类的实例。可以使用一种特殊的语法来创建一个接口的实例：

Runnable runner = new Runnable() { public void run() { for (int i=0; i<10000000; i++) { countSheep(); } } };

此代码创建了一个局部匿名类，实例化该类并为runner变量分配新的实例。需要确保你的类定义(外层花括号之间的代码)实现了接口的所有方法。此外，还可以按照这种方式创建子类。下面的代码实例化Object的一个匿名子类并将它分配给一个变量：

Object timePrinter = new Object() { public String toString() { return String.valueOf(System.currentTimeMillis()); } }; System.out.println(timePrinter);

匿名类是Java开发人员常用的一个有用工具。无论何时需要一次性地实现一个接口(或子类)，都可以考虑使用这些类。但最好将它们用于仅有一到两个方法的小型接口。

Java1.1+

正如上一节中所讨论的，Java 5在System类中添加了一个nanoTime方法来确保时间度量能够适应更快的系统。即使在早期版本的Java中，线程可以具有少于1毫秒的休眠时间。回想一下Java的线程机制有一个sleep方法，该方法采用一个int参数来表示以毫秒计量的休眠时间。此外还有一个sleep方法，它接受一个毫秒参数和一个以纳秒计量的时间参数。如果将毫秒时间设为零，那么线程将会休眠指定的纳秒(ns)数。

public class MyThread extends Thread { public void run() { try { sleep(10);          // sleep for 10 milliseconds sleep(0, 10000);    // sleep for 0.01 milliseconds (10000 ns) } catch (InterruptedException e) { e.printStackTrace(); } } }

就像前面介绍的nanoTime方法一样，该方法存在同样的问题。由于操作系统特性、机器处理速度和系统负载的不同，实际的休眠时间可能与期望的不同。

Java5+

摩尔定律是一种众所周知的现象，即计算机中的晶体管数量和它的处理速度随时间呈指数规律增长。作为仙童半导体公司(Fairchild Semiconductor)的研发领导人，戈登•摩尔于1965年提出了这一伟大发现。迄今为止，它仍有效。
与Java首次出现的时候相比，当前计算机的速度要快得多，对于很多应用程序而言以毫秒计时已不再能够满足要求。你可能使用过java.lang.System类，利用currentTimeMillis方法来获得一个方法调用或一段代码的定时信息。此方法可以用来度量执行某操作所花费的时间。但是，在运算速度更快的计算机上操作花费的时间可能远小于1毫秒，于是可以在一个for循环中执行此操作上百次或上千次，然后除以循环次数来计算此操作的单位时间。考虑下面的示例：

long startTime = System.currentTimeMillis(); for (int i=0; i<1000; i++) { performOperation(); // something we want to measure } long endTime = System.currentTimeMillis(); long totalTimeInMillis = endTime - startTime; // because the count was 1000, it's easy to get the unit time long unitTimeInMicros = totalTimeInMillis;

这种一种很简单的运算，因为使用了for循环1000次。但是如果要度量亚微秒该如何实现呢？

for(int i=0; i<1000000; i++) { performOperation(); }

如果从人类的角度来看，可怜的for循环将不得不不厌其烦地百万次的频繁循环！此外，只有在重复执行操作没有副作用的情况下使用for循环来计算时间才是有用的。如果操作是调用java.util.Collections.sort方法，那么将很难计算出排序过程花费的时间。在Java 5中，System类有一个新的nanoTime方法，它能返回一个纳秒精度的计数器。尽管不能将它用于度量绝对时间，但是它能够很好地度量时间差别。

List myList = initializeList();  // initialize the List somehow long startTime = System.nanoTime(); Collections.sort(myList);         // measuring the sort time long endTime = System.nanoTime(); long differenceInNanoseconds = endTime - startTime;

遗憾的是，运行上面的代码时无法保证实际上获得的是纳秒级的度量。但是使用更快的机器和良好的JRE实现，对于测试目的而言它是一种有用的度量方法。可以在JDK 5文档中找到更多有关此方法的信息。鉴于操作系统特性、机器处理速度和系统负载的不同，得到的由nanoTime方法返回的值可能会有很大的变化。随着时间的推移此问题应该会有所改善，摩尔定律基本上能保证这一点。

参考资料：

想要了解摩尔的原始论文，请参看Gordon E. Moore, Cramming More Components onto Integrated Circuits, Electronics, Vol. 38, No. 8 (April 19, 1965)。此外，还可以在网上获得该论文，参看本书的网站http:// wickedcooljava.com以获得URL。

Java5+

“编程人员总是正确的—— 是编译器和解释器造成的错误。”我确信你认同这种说法。作为编程人员，经常要对变量的值做出假设并且基于此编写代码。尽管非常不愿意承认可能在设计或实现上有错误，但有时变量和参数却没有获得期望的值。

当设计和编写代码时，只有在最初的假设仍然成立的情况下代码才能正确运行。如果没有任何有关这些假设的声明，那么阅读代码的任何人(甚至你自己)都不清楚它们的含义是什么。从而导致今后的改动可能会违反这些假设并引入难以查找的错误。通常，在注释中说明假设能使以后修改代码的人避免出错。

使用注释来说明假设是一个好的开始。但是当出现违反假设的情况时，程序有时会继续运行就像未出现任何问题一样。一些情况下，开发人员能够马上看到结果，并且可以纠正出现的问题。但在另一些情况下，存在一个潜伏的错误时，可能会对应用程序的其他部分造成负面影响，对于分布式系统而言，则可能会对完全不同的另一个应用程序造成负面影响！跟踪这样的问题非常困难。

Java 1.4在语言中添加了断言特性来简化测试和调试，加强文档编制并提高基于Java的可维护性。可以使用一个布尔表达式来创建一个断言，以便测试有关系统的当前状态所假定的某些情况。如果断言失败，运行库会抛出一个AssertionError。下面给出一个很简单的断言：

String name = "Brian"; assert name != null;

这里，可以确定在给name分配了值“Brian”后它的值将不会为空。如果它的值为空，则出现了某种严重的错误！此断言是当时在程序中对变量的值所做的假定的声明。为如此简单的例子做这种声明看似可笑和多余。但是，当多个方法会影响一个对象的状态时，这种方法是有效的。在下面的示例中，示例了这样一个断言，即在向新员工分配任何任务之前必须已经指派了一名管理人员。

Employee worker = new Employee("John", "Smith", 100000, "Developer"); assignOffice(worker); setUpVoiceMail(worker); moreAdministrivia(worker); assert worker.getSupervisor() != null : "Supervisor cannot be null"; assignTasks(worker);

通常，在对某个对象执行关键操作时会需要对它创建断言。这有助于增强代码的健壮性，比如如果在程序中出现了某种错误，可以更方便地调试程序。这样做要比程序在某处执行失败造成不良后果来发现错误要好得多。当知道程序失败是由于它违反了假设而引起的时候，跟踪失败的原因要简单得多。在这个代码样例中，使用了assert选项来返回更有用的信息。没有此选项时，除了行号之外将无法得到有关断言的标识信息。

在某些版本的编译器上，当编译源代码时需要使用一个命令选项来设置编译器的源兼容性模式(取决于编译器的版本，如1.4或1.5)。

javac -source 1.5 MyClass.java

现在强制断言失败并观察会出现什么情况：

public class AssertBad { public static void main(String[] args) { int total = 20; int itemCount = 0; assert itemCount > 0; int average = total / itemCount; } }

默认情况下，运行时环境不支持断言，必须使用ea(允许断言)命令选项来启动JRE。上面的代码会引起以下的结果：

C:\projects\wcj1> java -ea AssertBad Exception in thread "main" java.lang.AssertionError at AssertBad.main(AssertBad.java:12)

要记住断言是用来对那些不应该出现的情况进行实际的“健全性检查”，因此不应该使用它们来替代常规的错误检查。

警告：
不要让断言语句更改代码中的状态/值。否则当最终关闭断言时，代码的行为方式将不同于启用断言时代码的行为。例如，不要创建如下的断言：

assert (++i > 10); // BAD: i changes only with assertions enabled!

通常，在整个开发阶段都会启用断言。一旦完全测试了系统并将它移送到产品环境时，则希望禁用断言，因为这样做会略微改善性能。但是不要改动代码来完成此操作，并且也不要删除断言。不管怎样，为了编制文档的目的，断言也应保留在代码中。这样，当以后更改代码时，会提醒程序员要保持所有假设都是有效的，并且这也是可测试的。

Java5+

Java编程人员常常需要为方法定义一个包含多个值的参数。这时可以采用List或数组的形式，如下例所示。

public int add(int[] list) { int sum = 0; for (int i=0; i < list.length; i++) { sum += list[i]; } return sum; }

也可以将它实现为几个重载的方法，每个方法接受不同数量的int参数。这样做有时可以令方法更容易使用，因为调用代码不需要首先创建一个数组。

public int add(int a, int b) { return a + b; } public int add(int a, int b, int c) { return a + b + c; } public int add(int a, int b, int c, int d) { return a + b + c + d; }

如果只有少量值，这对于调用代码更为方便，因为现在可以使用add(12,14,16)来代替add(new int[] {12,14,16})。但是，编写类似这样的方法存在问题，需要为每种可能的参数组合编写不同版本的方法。如果希望在方法的使用方式上具有最大的灵活性则与其创建一个庞大的具有上千个方法的类，不如对重载的方法接受的参数数量进行很小的限制。

在Java 5中，可以编写一个方法以使它允许可变数量的参数并让编译器完成将列表包装到一个数组中的操作。虽然内部仍是处理数组，但此时的编译器已隐藏了细节。以下的代码使用可变参数(vararg)重写了add方法。

public int add(int... list) { int sum = 0; for (int item : list) { sum += item; } return sum; }

注意，那些奇怪的圆点正是可变参数的实际语法！并且，由于这种改动要用到Java 5，我们也可以趁机使用Java 5增强的for循环语法。一旦按照这种方式编写了方法，可以使用实际数量的参数来调用它！此外，还可以传递一个作为参数的数组(但不允许是List或Collection对象)：

add(1,3,5,7,9,11,13,15,17,19,21,23,25); add(new int[] {12,14,16});

需要注意的是当定义一个参数列表时该语法只能使用一次，并且它必须是最后一项。以下的代码不能正常运行，因为可变参数不是最后一项：

public void badMethod(int... data, String comment) { } // wrong!

必须将此代码改写成以下形式：

public void goodMethod(String comment, int... data) { }

在一些情况下，在方法定义中使用可变参数可以使方法更简便。这在参数列表包含字面(硬编码)值的情况下尤其如此，如上面的示例中给出的int值。

Java5+

前面的小节介绍了泛型可以简化Java代码并使代码能够防范ClassCastException错误。除了作为JDK的一部分来使用泛型之外，还可以编写你自己的泛型。当对类型相同的对象进行操作时泛型是很有用的，但是对象的具体类型直到对类实例化时才能知道。这种方式非常适合于包含关联项目的集合或涉及查找的类。

下面编写一个使用泛型参数的方法。回想一下前面是怎样使用ArrayList类的—— 只在构造ArrayList时才指定它使用哪些对象类型。注意，在定义类时并不知道其类型，并且不能将java.lang.Object作为类型使用，因为最后将遇到类似以前的类型强制转换问题。当定义泛型时，必须使用一种特殊的语言来代表类型。当声明类名时要完成此操作。在下面的示例中，<T>表示一种类将使用的类型：

public class RandomSelection<T> { }

这里，类型指示符的尖括号看起来类似HTML语法，但实际上和HTML没有关系，它们也不表示小于或大于！尖括号在一个泛型的类名与一个类型相结合的情况下使用，正如前面的ArrayList<Integer>那样。尽管直到调用构造函数时才知道真实的类型，但我们可以在方法定义中使用替换类型。假定定义了一个叫做RandomSelection的类，该类使用另一个类的某个类型，暂时将该类型称为T。但是，此类的名字仍是RandomSelection。另外，每次可以对多个类型执行这种操作，正如java.util.Map的定义所示的那样。在这种情况下，在类名之后使用一个由逗号分隔的标识符列表即可。

public class MyGeneric<T,U,V> { }

上面定义的MyGeneric类涉及到三个类型，它们分别称为T、U和V。下面编写一个方法来扩展RandomSelection类，该方法将一个项目添加到一个由内部管理的泛型(类型为T)的ArrayList中：

public class RandomSelection<T> { private ArrayList<T> list; public RandomSelection() { list = new ArrayList<T>(); } public void add(T element) { list.add(element); } }

注意，实际上并不是处理一个叫作T的类。T代表当某人创建RandomSelection的一个实例时使用的任意类。Java规范允许使用任意标识符，但是一般是使用单个大写字母来和普通的类名进行区别。既然已经定义add方法接受一个类型T参数，则只能使用在构造RandomSelection实例时采用的相同的类型来调用此方法。以下的代码是非法的并会产生一个编译错误：

RandomSelection<String> rs = new RandomSelection<String>(); rs.add(new Date()); // illegal for a RandomSelection<String>

如果希望一个方法返回一个泛型类型，可以将方法签名的返回类型设为T，正如下面的定义所示：

import java.util.Random; public class RandomSelection<T> { private java.util.Random random = new Random(); // ..... earlier methods omitted public T getRandomElement() { int index = random.nextInt(list.size()); return list.get(index); } }

getRandomElement方法返回一个类型T，即与在类声明中定义的类型相同。通过构造一个类型实例，现在可以使用刚才定义的RandomSelection类：

RandomSelection<Integer> selector = new RandomSelection<Integer>(); selector.add(2); selector.add(3); selector.add(5); selector.add(7); selector.add(11); Integer choice = selector.getRandomElement(); System.out.println(choice);

给一个整型变量choice赋值是安全的，因为selector的getRandomElement方法返回的总是一个Integer。情况确实如此，因为是使用Integer作为泛型类型来构造的selector实例。Add和getRandomElement方法的定义具有和构造函数的定义相同的类型，并且编译器将会强制执行此约束。尝试在构造函数中以一个不同的类型来使用RandomSelection类，这次使用前面定义的Fruit enum类：

RandomSelection<Fruit> fruitSelector = new RandomSelection<Fruit>(); fruitSelector.add(Fruit.APPLE); fruitSelector.add(Fruit.ORANGE); fruitSelector.add(Fruit.GRAPEFRUIT); fruitSelector.add(Fruit.BANANA); fruitSelector.add(Fruit.DURIAN); Fruit fruitChoice = fruitSelector.getRandomElement(); System.out.println(fruitChoice);

可以看出，能够直接使用来自getRandomElement方法的Fruit返回值，正如前面对待Integer那样。如果你想要一个类与某种类型(直到构造该类时才知道具体的类型)的对象协同操作以及希望编译器严格执行类型限制，那么你可以定义自己的泛型。这样做的主要优点体现在它的安全和便利性上。若想了解有关泛型的更多信息，请查阅网址http:// java.sun.com/j2se/1.5.0/docs/guide/language/generics.html上的Generics Tutorial(泛型指南) 和Java 5文档。

Java5+

正如前面讨论for循环时看到的那样，使用泛型有助于简化代码并降低出错概率。for循环会假定ArrayList仅包含Integer对象，因为ArrayList严格地被定义为由Integer对象组成。因而当从列表检索项目时可以避免从Object到Integer的强制类型转换。

Java 5对核心API做出了很多利用泛型的更改。查看相关文档你会发现已重新定义了很多类以允许使用泛型。如果愿意的话，仍可以按照以前的方式构造和使用这些类，例如使用new ArrayList()。这样做的原因是为了兼容性，以便仍可以在旧版本的编译器下运行代码。当然，这样会失去泛型提供的类型检查带来的便利性和安全性。

一个得到很好修订的类是java.util.Map (和HashMap)。我们知道，映射操作就像查表一样，每个值都存储在一个唯一的键标下。在早期的Java版本中，当在映射表中放置表项时，它们是作为Object项存放的。当从映射表中检索表项时，它被作为标准的Object引用来对待，即被强制转换成正确的子类以便能够识别为它的实际类型。这与List中存在的危险相同。要么对象不正确，要么出现ClassCastException异常，这样的情况太常见了。

假定有一个用于维护员工数据的Employee类。下面给出一些使用HashMap的典型代码：

Employee brian = new Employee(); brian.setName("Brian", "Eubanks"); brian.setSalary(100000.00); brian.setTitle("Boss"); HashMap employees = new HashMap(); employees.put("Brian", brian); Employee newHire = (Employee) employees.get("Brian"); newHire.setHireDate(new Date());

在检索项目时，最大的危险位于强制类型转换的过程中。使用Java 5，不用强制类型转换也可完成此操作，只要使用正确的类型来实例化Map。可以对键和值的类型添加约束。在下面的示例中，只允许String键和Employee值：

Employee brian = new Employee(); brian.setName("Brian", "Eubanks"); brian.setSalary(100000.00); brian.setTitle("Boss"); HashMap<String,Employee> employees = new HashMap<String,Employee>(); employees.put("Brian", brian); // no cast is necessary here Employee newHire = employees.get("Brian"); newHire.setHireDate(new Date());

通过使用类型安全映射，当从映射表中检索表项时可以避免ClassCastException错误。这样做使代码更加稳定并且降低对映射内容的敏感性。但如果代码必须运行在早期版本的Java上，那么将处于不利的情况并且需要暂时继续执行强制类型转换。但可以采用下一节中的方法，创建自己的泛型类。

Java5+

大多数应用程序需要记录一个值的有限集—— 即应用程序中表示一组选择或状态的常量。一种常见的Java编程惯例是使用static int变量来表示这些值。然后让程序通过比较这些值和其他变量的值来做出决定。尽管核心Java API本身也采用这种惯例，但它很可能导致严重的问题！下面是一个有关水果信息的示例。该示例给出了使用int变量来表示枚举数据时会出现的一些问题。

public class FruitConstants { // this is not such a good practice public static final int APPLE = 1; public static final int ORANGE = 2; public static final int GRAPEFRUIT = 3; public static final int BANANA = 4; public static final int DURIAN = 5; public static final int CITRUS = 6; public static final int SWEET = 7; public static final int SMELLY = 8; public static final int UNKNOWN = 9; public static int getCategory(int fruit) { switch(fruit) { case APPLE: case BANANA: return SWEET; case ORANGE: case GRAPEFRUIT: return CITRUS; case DURIAN: return SMELLY; } return UNKNOWN; } }

其中，来自东南亚的水果榴莲(Durian)具备“Sweet”和“Smelly”，但是这里的水果只能返回一个特点，也就是说，所有的值只能是对应单一的值而不是对应多个值。另外一个主要的问题是任何int值都可以传递给getCategory方法，无论它是否代表一个有效的水果。这可能导致细微的错误，因为编译器不关心是调用getCategory(SWEET)还是调用getCategory(42)。并且如果整型常量的值发生了变化，getCategory(3)显示的将不再是正确的信息！
另一个问题是使用水果和类别的int值并无区别—— 它们都只是普通的int值。通过简单地将类别常量置于一个不同的类中可以部分地解决水果和类别分离的问题，但是它们仍只是int值而不是类型安全(typesafe)的，也就是没能将getCategory的参数限制到一个固定的值集合。
在Java 5中，有一个优雅的解决方法：可以像在C语言中那样创建枚举类型。这是一个新特性，它创建一个类，该类包含一个所有它允许的实例清单。除了enum内定义的实例外，不允许其他的实例。下面看一些enum的示例：

enum Fruit {APPLE, ORANGE, GRAPEFRUIT, BANANA, DURIAN} enum FruitCategory {SWEET, CITRUS, SMELLY, UNKNOWN} enum Dessert {PIE, CAKE, ICECREAM, BROWNIE}

以上每个例子均定义了一组不同的枚举元素(选择)。这样做的好处是不会将Fruit值与其他类型的相混合或相混淆。对待每个enum就好像它是一个不同的类一样。不能将FruitCategory作为一个参数传递给一个期望Dessert的值方法，也不能传递一个int值。下面扩展Fruit enum以包含最初的FruitConstants类具有的功能：

public enum Fruit { APPLE, ORANGE, GRAPEFRUIT, BANANA, DURIAN; public static FruitCategory getCategory(Fruit fruit) { switch(fruit) { case APPLE: case BANANA: return FruitCategory.SWEET; case ORANGE: case GRAPEFRUIT: return FruitCategory.CITRUS; case DURIAN: return FruitCategory.SMELLY; } return FruitCategory.UNKNOWN; } }

可以看出一个enmu也可以像一个类那样定义方法。现在的getCategory方法采用Fruit作为参数，并且只允许使用enum中定义的值。接下来这个代码段将引起编译错误，而不会出现调用最初的未受保护的getCategory方法时出现的运行时异常：

Fruit.getCategory(Dessert.PIE); // compile error Fruit.getCategory(10); // compile error

如果每种水果管理它自己的类别将会更好，因此为了完善Fruit类，将删除getCategory的水果参数并使该方法为每个enum状态返回不同的值。通过创建一个适用于所有值的抽象的getCategory方法并对每个enum以不同的方式重写它，可以完成此操作。它非常类似于为每个枚举值编写一个不同的子类，并让每个这样的子类重写抽象的方法。

public enum Fruit { APPLE { FruitCategory getCategory() {return FruitCategory.SWEET;} }, ORANGE { FruitCategory getCategory() {return FruitCategory.CITRUS;} }, GRAPEFRUIT { FruitCategory getCategory() {return FruitCategory.CITRUS;} }, BANANA { FruitCategory getCategory() {return FruitCategory.SWEET;} }, DURIAN { FruitCategory getCategory() {return FruitCategory.SMELLY;} }; abstract FruitCategory getCategory(); }

一旦创建一个类似这样的enum，就可以像对待其他对象那样来对待APPLE值(使用静态的Fruit.APPLE引用)，并且可以调用它的getCategory方法来得到它的相应类别。现在可以为上面的类添加一个main方法来说明如何使用新的Fruit enum：

public static void main(String[] args) { Fruit a = Fruit.APPLE; // toString() returns "APPLE" System.out.println ("The toString() for a: " + a); // getCategory() returns "SWEET" System.out.println ("a.getCategory() is: " + a.getCategory()); for (Fruit f : Fruit.values()) { System.out.println ("Fruit is: " + f); } }

正如代码中所示的那样，可以使用values方法来迭代enum内的所有值。enum的toString方法将会返回一个String，它具有和值相同的名字。使用enum而不是int来表示状态，可以使代码具有更好的可读性和更强的防错性。它明确地定义了一个特殊的枚举状态的所有值并可以防止有人使用不正确的值。

Java5+

在一些编程语言中，通过列表或数组可以非常方便地进行遍历，通过一个循环即可逐个遍历项并将该项赋值一个局部变量从而实现自动循环。我曾经告诉过一个同事我认为Java中的“for”循环功能是不完全的，因为它没有“for-each”。我的朋友也是一个有经验的Java开发人员，他的回答是“你疯了吗？，在Java中当然有for！”在此之后很长一段时间里他为此而不断地嘲笑我，并定期地提醒我在Java中存在for(为了防止我遗忘此事) 。但是我有一个好消息要告诉他和所有Java开发人员：目前在Java中有了真正的for！

考虑这样一种情况，你希望对一个整型对象集合(如java.util.ArrayList)中的所有数值求和。你很可能编写过类似于下面这样的代码：

ArrayList theList = new ArrayList();

            theList.add(new Integer(2));

            theList.add(new Integer(3));

            theList.add(new Integer(5));

            theList.add(new Integer(7));

            int sum = 0;

            // The old way to iterate

            for (Iterator iter = theList.iterator(); iter.hasNext(); ) {

            Integer x = (Integer) iter.next();

            sum = sum + x.intValue();

            }

            System.out.println("The sum is " + sum);  

这段代码多麻烦啊，难道编译器不应该知道你正在进行迭代吗?毕竟这是一个for循环，不是吗？而在Java 5中，增强的for循环现已支持集合对象。因此不再需要使用迭代器。在下面的修订的代码中，一个for循环通过列表进行迭代并显示出每个值：

ArrayList<Integer> theList = new ArrayList<Integer>(); theList.add(2); theList.add(3); theList.add(5); theList.add(7); int sum = 0; // new Java 5 iteration syntax for (Integer item : theList) { sum = sum + item; } System.out.println("The sum is " + sum);

for循环定义了一个叫做item的局部变量，在每次迭代过程中，它将得到列表中的下一个值。除了完美的for循环语法外，此代码在以下两个方面也不同于过去的Java代码。

使用了泛型

上面带有尖括号的语法是Java 5新增加的泛型特性。泛型允许为一些具体类型的对象定义类，但是直到创建该类的一个实例时才能知道具体的类型。编译器将会强迫执行类型检查。在这个示例中，ArrayList是一个特殊的类，对于add方法它只接受整数(并只从它的Iterator的next方法中返回整数)。这意味着当从列表中检索对象时不需要强制类型转换，可以立即将它们作为Integer实例来对待。不使用泛型时，仍可以使用新的for循环语法，但需要将Object强制转换成Integer。在1.4节中将我们更详细地介绍泛型。

整型对象到整型数值的自动转换

在Java 5中，可以将Integer对象作为int来对待。编译器将自动执行从int到Integer对象的转换(反之亦然)，此过程称为自动装箱(autoboxing)。当循环中得到一个Integer对象时，可以将它与一个int值相加而不需要执行显式的转换。
新的for语言也适用于数组：

int[] theList = new int[] {2,3,5,7}; int sum = 0; for (int x : theList) { sum = sum + x; } System.out.println("The sum is " + sum);

这种新的语法的确使代码变得更加易读和紧凑。但还不能完全放弃迭代器，至少暂时是这样，因为还有很多开发人员没有将他们的JDK升级到版本5。