Java编程思想第4版[中文版](PDF格式)-第64部分
按键盘上方向键 ← 或 → 可快速上下翻页，按键盘上的 Enter 键可回到本书目录页，按键盘上方向键 ↑ 可回到本页顶部！
————未阅读完？加入书签已便下次继续阅读！
Prediction 作为值使用。如下所示：
//： SpringDetector。java
// Looks plausible； but doesn't work right。
import java。util。*；
class Groundhog ｛
int ghNumber；
Groundhog（int n） ｛ ghNumber = n； ｝
｝
class Prediction ｛
boolean shadow = Math。random（） 》 0。5；
public String toString（） ｛
if（shadow）
return 〃Six more weeks of Winter！〃；
else
return 〃Early Spring！〃；
｝
｝
public class SpringDetector ｛
public static void main（String＇＇ args） ｛
Hashtable ht = new Hashtable（）；
for（int i = 0； i 《 10； i＋＋）
ht。put（new Groundhog（i）； new Prediction（））；
System。out。println（〃ht = 〃 ＋ ht ＋ 〃n〃）；
System。out。println（
〃Looking up prediction for groundhog #3：〃）；
Groundhog gh = new Groundhog（3）；
if （ht。containsKey（gh））
System。out。println（（Prediction）ht。get（gh））；
｝
｝ ///：~
每个Groundhog 都具有一个标识号码，所以赤了在散列表中查找一个Prediction，只需指示它“告诉我与
Groundhog 号码3 相关的 Prediction”。Prediction 类包含了一个布尔值，用Math。random（）进行初始化，
以及一个toString（）为我们解释结果。在main（）中，用Groundhog 以及与它们相关的Prediction 填充一个
散列表。散列表被打印出来，以便我们看到它们确实已被填充。随后，用标识号码为 3 的一个Groundhog 查
找与Groundhog #3 对应的预报。
看起来似乎非常简单，但实际是不可行的。问题在于Groundhog 是从通用的 Object 根类继承的（若当初未指
定基础类，则所有类最终都是从Object 继承的）。事实上是用 Object 的hashCode（）方法生成每个对象的散
226
…………………………………………………………Page 228……………………………………………………………
列码，而且默认情况下只使用它的对象的地址。所以，Groundhog（3）的第一个实例并不会产生与
Groundhog（3）第二个实例相等的散列码，而我们用第二个实例进行检索。
大家或许认为此时要做的全部事情就是正确地覆盖 hashCode（）。但这样做依然行不能，除非再做另一件事
情：覆盖也属于Object 一部分的 equals（）。当散列表试图判断我们的键是否等于表内的某个键时，就会用
到这个方法。同样地，默认的Object。equals（）只是简单地比较对象地址，所以一个Groundhog（3）并不等于
另一个Groundhog（3）。
因此，为了在散列表中将自己的类作为键使用，必须同时覆盖 hashCode（）和 equals（），就象下面展示的那
样：
//： SpringDetector2。java
// If you create a class that's used as a key in
// a Hashtable； you must override hashCode（）
// and equals（）。
import java。util。*；
class Groundhog2 ｛
int ghNumber；
Groundhog2（int n） ｛ ghNumber = n； ｝
public int hashCode（） ｛ return ghNumber； ｝
public boolean equals（Object o） ｛
return （o instanceof Groundhog2）
&& （ghNumber == （（Groundhog2）o）。ghNumber）；
｝
｝
public class SpringDetector2 ｛
public static void main（String＇＇ args） ｛
Hashtable ht = new Hashtable（）；
for（int i = 0； i 《 10； i＋＋）
ht。put（new Groundhog2（i）；new Prediction（））；
System。out。println（〃ht = 〃 ＋ ht ＋ 〃n〃）；
System。out。println（
〃Looking up prediction for groundhog #3：〃）；
Groundhog2 gh = new Groundhog2（3）；
if（ht。containsKey（gh））
System。out。println（（Prediction）ht。get（gh））；
｝
｝ ///：~
注意这段代码使用了来自前一个例子的Prediction，所以SpringDetector。java 必须首先编译，否则就会在
试图编译SpringDetector2。java 时得到一个编译期错误。
Groundhog2。hashCode（）将土拔鼠号码作为一个标识符返回（在这个例子中，程序员需要保证没有两个土拔鼠
用同样的 ID 号码并存）。为了返回一个独一无二的标识符，并不需要hashCode（），equals（）方法必须能够
严格判断两个对象是否相等。
equals（）方法要进行两种检查：检查对象是否为null ；若不为null ，则继续检查是否为Groundhog2 的一个
实例（要用到 instanceof 关键字，第 11章会详加论述）。即使为了继续执行 equals（），它也应该是一个
Groundhog2。正如大家看到的那样，这种比较建立在实际ghNumber 的基础上。这一次一旦我们运行程序，就
会看到它终于产生了正确的输出（许多Java 库的类都覆盖了hashcode（）和 equals（）方法，以便与自己提供
的内容适应）。
2。 属性：Hashtable 的一种类型
在本书的第一个例子中，我们使用了一个名为 Properties （属性）的Hashtable 类型。在那个例子中，下述
227
…………………………………………………………Page 229……………………………………………………………
程序行：
Properties p = System。getProperties（）；
p。list（System。out）；
调用了一个名为getProperties（）的static 方法，用于获得一个特殊的Properties 对象，对系统的某些特
征进行描述。list（）属于 Properties 的一个方法，可将内容发给我们选择的任何流式输出。也有一个 save（）
方法，可用它将属性列表写入一个文件，以便日后用 load（）方法读取。
尽管Properties 类是从Hashtable 继承的，但它也包含了一个散列表，用于容纳“默认”属性的列表。所以
假如没有在主列表里找到一个属性，就会自动搜索默认属性。
Properties 类亦可在我们的程序中使用（第 17章的ClassScanner。java 便是一例）。在 Java 库的用户文档
中，往往可以找到更多、更详细的说明。
8。4。5 再论枚举器
我们现在可以开始演示 Enumeration （枚举）的真正威力：将穿越一个序列的操作与那个序列的基础结构分
隔开。在下面的例子里，PrintData 类用一个 Enumeration 在一个序列中移动，并为每个对象都调用
toString（）方法。此时创建了两个不同类型的集合：一个 Vector 和一个 Hashtable。并且在它们里面分别填
充Mouse 和 Hamster 对象（本章早些时候已定义了这些类；注意必须先编译HamsterMaze。java 和
WorksAnyway。java，否则下面的程序不能编译）。由于Enumeration 隐藏了基层集合的结构，所以
PrintData 不知道或者不关心Enumeration 来自于什么类型的集合：
//： Enumerators2。java
// Revisiting Enumerations
import java。util。*；
class PrintData ｛
static void print（Enumeration e） ｛
while（e。hasMoreElements（））
System。out。println（
e。nextElement（）。toString（））；
｝
｝
class Enumerators2 ｛
public static void main（String＇＇ args） ｛
Vector v = new Vector（）；
for（int i = 0； i 《 5； i＋＋）
v。addElement（new Mouse（i））；
Hashtable h = new Hashtable（）；
for（int i = 0； i 《 5； i＋＋）
h。put（new Integer（i）； new Hamster（i））；
System。out。println（〃Vector〃）；
PrintData。print（v。elements（））；
System。out。println（〃Hashtable〃）；
PrintData。print（h。elements（））；
｝
｝ ///：~
注意PrintData。print（）利用了这些集合中的对象属于 Object 类这一事实，所以它调用了toString（）。但在
解决自己的实际问题时，经常都要保证自己的 Enumeration 穿越某种特定类型的集合。例如，可能要求集合
中的所有元素都是一个 Shape （几何形状），并含有draw（）方法。若出现这种情况，必须从
Enumeration。nextElement（）返回的 Object 进行下溯造型，以便产生一个 Shape。
228
…………………………………………………………Page 230……………………………………………………………
8。5 排序
Java 1。0 和 1。1 库都缺少的一样东西是算术运算，甚至没有最简单的排序运算方法。因此，我们最好创建一
个Vector，利用经典的Quicksort （快速排序）方法对其自身进行排序。
编写通用的排序代码时，面临的一个问题是必须根据对象的实际类型来执行比较运算，从而实现正确的排
序。当然，一个办法是为每种不同的类型都写一个不同的排序方法。然而，应认识到假若这样做，以后增加
新类型时便不易实现代码的重复利用。
程序设计一个主要的目标就是“将发生变化的东西同保持不变的东西分隔开”。在这里，保持不变的代码是
通用的排序算法，而每次使用时都要变化的是对象的实际比较方法。因此，我们不可将比较代码“硬编码”
到多个不同的排序例程内，而是采用“回调”技术。利用回调，经常发生变化的那部分代码会封装到它自己
的类内，而总是保持相同的代码则“回调”发生变化的代码。这样一来，不同的对象就可以表达不同的比较
方式，同时向它们传递相同的排序代码。
下面这个“接口”（Interface）展示了如何比较两个对象，它将那些“要发生变化的东西”封装在内：
//： pare。java
// Interface for sorting callback：
package c08；
interface pare ｛
boolean lessThan（Object lhs； Object rhs）；
boolean lessThanOrEqual（Object lhs； Object rhs）；
｝ ///：~
对这两种方法来说，lhs代表本次比较中的“左手”对象，而 rhs 代表“右手”对象。
可创建Vector 的一个子类，通过 pare 实现“快速排序”。对于这种算法，包括它的速度以及原理等等，
在此不具体说明。欲知详情，可参考Binstock 和 Rex 编著的《Practical Algorithms for Programmers》，
由Addison…Wesley 于 1995 年出版。
//： SortVector。java
// A generic sorting vector
package c08；
import java。util。*；
public class SortVector extends Vector ｛
private pare pare； // To hold the callback
public SortVector（pare p） ｛
pare = p；
｝
public void sort（） ｛
quickSort（0； size（） 1）；
｝
private void quickSort（int left； int right） ｛
if（right 》 left） ｛
Object o1 = elementAt（right）；
int i = left 1；
int j = right；
while（true） ｛
while（pare。lessThan（
elementAt（＋＋i）； o1））
；
while（j 》 0）
if（pare。lessThanOrEqual（
elementAt（……j）； o1））
229
…………………………………………………………Page 231……………………………………………………………
break； // out of while
if（i 》= j） break；
swap（i； j）；
｝
swap（i ； right）；
quickSort（left； i…1）；
quickSort（i＋1； right）；
｝
｝
private void swap（int loc1； int loc2） ｛
Object tmp = elementAt（loc1）；
setElementAt（elementAt（loc2）； loc1）；
setElementAt（tmp； loc2）；
｝
｝ ///：~
现在，大家可以明白“回调”一词的来历，这是由于quickSort（）方法“往回调用”了pare 中的方法。
从中亦可理解这种技术如何生成通用的、可重复利用（再生）的代码。
为使用 SortVector，必须创建一个类，令其为我们准备排序的对象实现pare。此时内部类并不显得特别
重要，但对于代码的组织却是有益的。下面是针对 String 对象的一个例子：
//： StringSortTest。java
// Testing the generic sorting Vector
package c08；
import java。util。*；
