Java编程思想第4版[中文版](PDF格式)-第68部分
按键盘上方向键 ← 或 → 可快速上下翻页，按键盘上的 Enter 键可回到本书目录页，按键盘上方向键 ↑ 可回到本页顶部！
————未阅读完？加入书签已便下次继续阅读！
// off the tail end：
System。out。println（ll。removeLast（））；
// With the above operations； it's a dequeue！
print（ll）；
｝
public static void main（String args＇＇） ｛
// Make and fill a new list each time：
basicTest（fill（new LinkedList（）））；
basicTest（fill（new ArrayList（）））；
iterMotion（fill（new LinkedList（）））；
iterMotion（fill（new ArrayList（）））；
iterManipulation（fill（new LinkedList（）））；
iterManipulation（fill（new ArrayList（）））；
testVisual（fill（new LinkedList（）））；
testLinkedList（）；
｝
｝ ///：~
在basicTest（）和 iterMotiion（） 中，只是简单地发出调用，以便揭示出正确的语法。而且尽管捕获了返回
值，但是并未使用它。在某些情况下，之所以不捕获返回值，是由于它们没有什么特别的用处。在正式使用
它们前，应仔细研究一下自己的联机文档，掌握这些方法完整、正确的用法。
8。7。3 使用 Sets
Set 拥有与 Collection 完全相同的接口，所以和两种不同的 List 不同，它没有什么额外的功能。相反，Set
完全就是一个Collection，只是具有不同的行为（这是实例和多形性最理想的应用：用于表达不同的行
为）。在这里，一个Set 只允许每个对象存在一个实例（正如大家以后会看到的那样，一个对象的“值”的
构成是相当复杂的）。
S e t Each element that you add to the Set must be unique； otherwise the Set doesn’t
（interface） add the duplicate element。 Objects added to a Set must define e q u a l s （ ） to
establish object uniqueness。 Set has exactly the same interface as Collection。 The
Set interface does not guarantee it will maintain its elements in any particular
order。
H a s h S e t * For Set s where fast lookup time is important。 Objects must also define
h a s h C o d e （ ） 。
T r e e S e t An ordered Set backed by a red…black tree。 This way； you can extract an ordered
sequence from a Set 。
Set （接口） 添加到 Set 的每个元素都必须是独一无二的；否则Set 就不会添加重复的元素。添加到 Set 里
的对象必须定义equals（），从而建立对象的唯一性。Set 拥有与 Collection 完全相同的接口。一个 Set不能
保证自己可按任何特定的顺序维持自己的元素
HashSet＊ 用于除非常小的以外的所有Set。对象也必须定义hashCode（）
ArraySet 由一个数组后推得到的Set。面向非常小的Set 设计，特别是那些需要频繁创建和删除的。对于小
Set，与HashSet 相比，ArraySet 创建和反复所需付出的代价都要小得多。但随着 Set 的增大，它的性能也
会大打折扣。不需要HashCode（）
242
…………………………………………………………Page 244……………………………………………………………
TreeSet 由一个“红黑树”后推得到的顺序Set （注释⑦）。这样一来，我们就可以从一个Set 里提到一个
顺序集合
⑦：直至本书写作的时候，TreeSet 仍然只是宣布，尚未正式实现。所以这里没有提供使用TreeSet 的例
子。
下面这个例子并没有列出用一个Set 能够做的全部事情，因为接口与Collection 是相同的，前例已经练习过
了。相反，我们要例示的重点在于使一个Set 独一无二的行为：
//： Set1。java
// Things you can do with Sets
package c08。newcollections；
import java。util。*；
public class Set1 ｛
public static void testVisual（Set a） ｛
Collection1。fill（a）；
Collection1。fill（a）；
Collection1。fill（a）；
Collection1。print（a）； // No duplicates！
// Add another set to this one：
a。addAll（a）；
a。add（〃one〃）；
a。add（〃one〃）；
a。add（〃one〃）；
Collection1。print（a）；
// Look something up：
System。out。println（〃a。contains（”one”）： 〃 ＋
a。contains（〃one〃））；
｝
public static void main（String＇＇ args） ｛
testVisual（new HashSet（））；
testVisual（new TreeSet（））；
｝
｝ ///：~
重复的值被添加到 Set，但在打印的时候，我们会发现Set 只接受每个值的一个实例。
运行这个程序时，会注意到由 HashSet 维持的顺序与ArraySet 是不同的。这是由于它们采用了不同的方法来
保存元素，以便它们以后的定位。ArraySet 保持着它们的顺序状态，而HashSet 使用一个散列函数，这是特
别为快速检索设计的）。创建自己的类型时，一定要注意 Set 需要通过一种方式来维持一种存储顺序，就象
本章早些时候展示的“groundhog”（土拔鼠）例子那样。下面是一个例子：
//： Set2。java
// Putting your own type in a Set
package c08。newcollections；
import java。util。*；
class MyType implements parable ｛
private int i；
public MyType（int n） ｛ i = n； ｝
public boolean equals（Object o） ｛
return
243
…………………………………………………………Page 245……………………………………………………………
（o instanceof MyType）
&& （i == （（MyType）o）。i）；
｝
public int hashCode（） ｛ return i； ｝
public String toString（） ｛ return i ＋ 〃 〃； ｝
public int pareTo（Object o） ｛
int i2 = （（MyType） o）。i；
return （i2 《 i ？ …1 ： （i2 == i ？ 0 ： 1））；
｝
｝
public class Set2 ｛
public static Set fill（Set a； int size） ｛
for（int i = 0； i 《 size； i＋＋）
a。add（new MyType（i））；
return a；
｝
public static Set fill（Set a） ｛
return fill（a； 10）；
｝
public static void test（Set a） ｛
fill（a）；
fill（a）； // Try to add duplicates
fill（a）；
a。addAll（fill（new TreeSet（）））；
System。out。println（a）；
｝
public static void main（String＇＇ args） ｛
test（new HashSet（））；
test（new TreeSet（））；
｝
｝ ///：~
对 equals（）及hashCode（）的定义遵照“groundhog”例子已经给出的形式。在两种情况下都必须定义一个
equals（）。但只有要把类置入一个HashSet 的前提下，才有必要使用hashCode（）——这种情况是完全有可能
的，因为通常应先选择作为一个Set 实现。
8。7。4 使用 Maps
M a p Maintains key…value associations （pairs）； so you can look up a value using a key。
（interface）
H a s h M a p * Implementation based on a hash table。 （Use this instead of Hashtable。） Provides
constant…time performance for inserting and locating pairs。 Performance can be
adjusted via constructors that allow you to set the capacity and load factor of
the hash table。
T r e e M a p Implementation based on a red…black tree。 When you view the keys or the pairs；
they will be in sorted order （determined by parable or parator； discussed
later）。 The point of a T r e e M a p is that you get the results in sorted order。
T r e e M a p is the only M a p with the s u b M a p （ ） method； which allows you to return a
portion of the tree。
244
…………………………………………………………Page 246……………………………………………………………
Map （接口） 维持“键－值”对应关系（对），以便通过一个键查找相应的值
HashMap＊ 基于一个散列表实现（用它代替Hashtable）。针对“键－值”对的插入和检索，这种形式具有
最稳定的性能。可通过构建器对这一性能进行调整，以便设置散列表的“能力”和“装载因子”
ArrayMap 由一个ArrayList 后推得到的Map 。对反复的顺序提供了精确的控制。面向非常小的Map 设计，特
别是那些需要经常创建和删除的。对于非常小的Map，创建和反复所付出的代价要比HashMap 低得多。但在
Map 变大以后，性能也会相应地大幅度降低
TreeMap 在一个“红－黑”树的基础上实现。查看键或者“键－值”对时，它们会按固定的顺序排列（取决
于parable 或parator，稍后即会讲到）。TreeMap 最大的好处就是我们得到的是已排好序的结果。
TreeMap 是含有 subMap（）方法的唯一一种Map，利用它可以返回树的一部分
下例包含了两套测试数据以及一个 fill（）方法，利用该方法可以用任何两维数组（由Object 构成）填充任
何Map 。这些工具也会在其他Map 例子中用到。
//： Map1。java
// Things you can do with Maps
package c08。newcollections；
import java。util。*；
public class Map1 ｛
public final static String＇＇＇＇ testData1 = ｛
｛ 〃Happy〃； 〃Cheerful disposition〃 ｝；
｛ 〃Sleepy〃； 〃Prefers dark； quiet places〃 ｝；
｛ 〃Grumpy〃； 〃Needs to work on attitude〃 ｝；
｛ 〃Doc〃； 〃Fantasizes about advanced degree〃｝；
｛ 〃Dopey〃； 〃'A' for effort〃 ｝；
｛ 〃Sneezy〃； 〃Struggles with allergies〃 ｝；
｛ 〃Bashful〃； 〃Needs self…esteem workshop〃｝；
｝；
public final static String＇＇＇＇ testData2 = ｛
｛ 〃Belligerent〃； 〃Disruptive influence〃 ｝；
｛ 〃Lazy〃； 〃Motivational problems〃 ｝；
｛ 〃atose〃； 〃Excellent behavior〃 ｝
｝；
public static Map fill（Map m； Object＇＇＇＇ o） ｛
for（int i = 0； i 《 o。length； i＋＋）
m。put（o＇i＇＇0＇； o＇i＇＇1＇）；
return m；
｝
// Producing a Set of the keys：
public static void printKeys（Map m） ｛
System。out。print（〃Size = 〃 ＋ m。size（） ＋〃； 〃）；
System。out。print（〃Keys： 〃）；
Collection1。print（m。keySet（））；
｝
// Producing a Collection of the values：
public static void printValues（Map m） ｛
System。out。print（〃Values： 〃）；
Collection1。print（m。values（））；
｝
// Iterating through Map。Entry objects （pairs）：
245
…………………………………………………………Page 247……………………………………………………………
public static void print（Map m） ｛
Collection entries = m。entries（）；
Iterator it = entries。iterator（）；
while（it。hasNext（）） ｛
Map。Entry e = （Map。Entry）it。next（）；
System。out。println（〃Key = 〃 ＋ e。getKey（） ＋
〃； Value = 〃 ＋ e。getValue（））；
｝
｝
public static void test（Map m） ｛
fill（m； testData1）；
// Map has 'Set' behavior for keys：
fill（m； testData1）；
printKeys（m）；
printValues（m）；
print（m）；
String key = testData1＇4＇＇0＇；
String value = testData1＇4＇＇1＇；
System。out。println（〃m。containsKey（”〃 ＋ key ＋
〃”）： 〃 ＋ m。containsKey（key））；
System。out。println（〃m。get（”〃 ＋ key ＋ 〃”）： 〃
＋ m。get（key））；
S
