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

快捷操作: 按键盘上方向键 ← 或 → 可快速上下翻页 按键盘上的 Enter 键可回到本书目录页 按键盘上方向键 ↑ 可回到本页顶部! 如果本书没有阅读完，想下次继续接着阅读，可使用上方 "收藏到我的浏览器" 功能 和 "加入书签" 功能！


想情况下，它应该产生一系列完美的随机分布数字。但为了验证这一点，我们需要生成数量众多的随机数　

字，然后计算落在不同范围内的数字多少。散列表可以极大简化这一工作，因为它能将对象同对象关联起来　

　（此时是将Math。random（）生成的值同那些值出现的次数关联起来）。如下所示：　　

　　

//：　Statistics。java　　

//　Simple　demonstration　of　Hashtable　　

import　java。util。*；　　

　　

class　Counter　｛　　　

　　int　i　=　1；　　　

　　public　String　toString（）　｛　　　

　　　　return　Integer。toString（i）；　　　

　　｝　　

｝　　

　　

class　Statistics　｛　　

　　public　static　void　main（String＇＇　args）　｛　　

　　　　Hashtable　ht　=　new　Hashtable（）；　　

　　　　for（int　i　=　0；　i　《　10000；　i＋＋）　｛　　

　　　　　　//　Produce　a　number　between　0　and　20：　　

　　　　　　Integer　r　=　　　

　　　　　　　　new　Integer（（int）（Math。random（）　*　20））；　　

　　　　　　if　（ht。containsKey（r））　　

　　　　　　　　（（Counter）ht。get（r））。i＋＋；　　

　　　　　　else　　

　　　　　　　　ht。put（r；　new　Counter（））；　　

　　　　｝　　

　　　　System。out。println（ht）；　　

　　｝　　

｝　///：~　　

　　

在main（）中，每次产生一个随机数字，它都会封装到一个Integer　对象里，使句柄能够随同散列表一起使用　

　（不可对一个集合使用基本数据类型，只能使用对象句柄）。containKey（）方法检查这个键是否已经在集合　

里（也就是说，那个数字以前发现过吗？）若已在集合里，则　get（）方法获得那个键关联的值，此时是一个　

Counter　（计数器）对象。计数器内的值i　随后会增加　1，表明这个特定的随机数字又出现了一次。　　

假如键以前尚未发现过，那么方法　put（）仍然会在散列表内置入一个新的“键－值”对。在创建之初，　

Counter会自己的变量　i　自动初始化为1，它标志着该随机数字的第一次出现。　　

为显示散列表，只需把它简单地打印出来即可。Hashtable　toString（）方法能遍历所有键－值对，并为每一　

对都调用toString（）。Integer　toString（）是事先定义好的，可看到计数器使用的toString。一次运行的结　

果（添加了一些换行）如下：　　

　　

｛19=526；　18=533；　17=460；　16=513；　15=521；　14=495；　　

　13=512；　12=483；　11=488；　10=487；　9=514；　8=523；　　

　7=497；　6=487；　5=480；　4=489；　3=509；　2=503；　1=475；　　

　0=505｝　　

　　

大家或许会对Counter　类是否必要感到疑惑，它看起来似乎根本没有封装类　Integer　的功能。为什么不用　

int或　Integer　呢？事实上，由于所有集合能容纳的仅有对象句柄，所以根本不可以使用整数。学过集合　



　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　225　


…………………………………………………………Page　227……………………………………………………………

后，封装类的概念对大家来说就可能更容易理解了，因为不可以将任何基本数据类型置入集合里。然而，我　

们对Java　封装器能做的唯一事情就是将其初始化成一个特定的值，然后读取那个值。也就是说，一旦封装器　

对象已经创建，就没有办法改变一个值。这使得　Integer　封装器对解决我们的问题毫无意义，所以不得不创　

建一个新类，用它来满足自己的要求。　　

　　

1。　创建“关键”类　　

在前面的例子里，我们用一个标准库的类（Integer）作为Hashtable　的一个键使用。作为一个键，它能很好　

地工作，因为它已经具备正确运行的所有条件。但在使用散列表的时候，一旦我们创建自己的类作为键使　

用，就会遇到一个很常见的问题。例如，假设一套天气预报系统将Groundhog　（土拔鼠）对象匹配成　

Prediction　（预报）。这看起来非常直观：我们创建两个类，然后将Groundhog　作为键使用，而将　

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代表本次比较