Java编程思想第4版[中文版](PDF格式)-第43部分

快捷操作: 按键盘上方向键 ← 或 → 可快速上下翻页 按键盘上的 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。*；　　

　　

public　class　StringSortTest　｛　　

　　static　class　Stringpare　implements　pare　｛　　

　　　　public　boolean　lessThan（Object　l；　Object　r）　｛　　

　　　　　　return　（（String）l）。toLowerCase（）。pareTo（　　

　　　　　　　　（（String）r）。toLowerCase（））　《　0；　　

　　　　｝　　

　　　　public　boolean　　　

　　　　lessThanOrEqual（Object　l；　Object　r）　｛　　

　　　　　　return　（（String）l）。toLowerCase（）。pareTo（　　

　　　　　　　　（（String）r）。toLowerCase（））