友情提示：如果本网页打开太慢或显示不完整，请尝试鼠标右键“刷新”本网页！
Java编程思想第4版[中文版](PDF格式)-第45部分
快捷操作: 按键盘上方向键 ← 或 → 可快速上下翻页 按键盘上的 Enter 键可回到本书目录页 按键盘上方向键 ↑ 可回到本页顶部! 如果本书没有阅读完，想下次继续接着阅读，可使用上方 "收藏到我的浏览器" 功能 和 "加入书签" 功能！
print（c）；
c。remove（〃3〃）； // Removes the first one
print（c）；
c。remove（〃3〃）； // Removes the second one
print（c）；
// Remove all ponents that are in the
// argument collection：
c。removeAll（newCollection（））；
print（c）；
c。addAll（newCollection（））；
print（c）；
// Is an element in this Collection？
System。out。println（
〃c。contains（”4”） = 〃 ＋ c。contains（〃4〃））；
// Is a Collection in this Collection？
System。out。println（
〃c。containsAll（newCollection（）） = 〃 ＋
c。containsAll（newCollection（）））；
Collection c2 = newCollection（5； 3）；
// Keep all the elements that are in both
// c and c2 （an intersection of sets）：
c。retainAll（c2）；
print（c）；
// Throw away all the elements in c that
// also appear in c2：
c。removeAll（c2）；
System。out。println（〃c。isEmpty（） = 〃 ＋
c。isEmpty（））；
c = newCollection（）；
print（c）；
c。clear（）； // Remove all elements
System。out。println（〃after c。clear（）：〃）；
print（c）；
｝
｝ ///：~
通过第一个方法，我们可用测试数据填充任何集合。在当前这种情况下，只是将 int 转换成 String。第二个
方法将在本章其余的部分经常采用。
newCollection（）的两个版本都创建了ArrayList，用于包含不同的数据集，并将它们作为集合对象返回。所
以很明显，除了Collection 接口之外，不会再用到其他什么。
print（）方法也会在本节经常用到。由于它用一个反复器（Iterator ）在一个集合内遍历，而任何集合都可以
产生这样的一个反复器，所以它适用于List 和Set，也适用于由一个Map 生成的Collection。
main（）用简单的手段显示出了集合内的所有方法。
在后续的小节里，我们将比较 List ，Set 和 Map 的不同实现方案，同时指出在各种情况下哪一种方案应成为
首选（带有星号的那个）。大家会发现这里并未包括一些传统的类，如Vector，Stack 以及Hashtable 等。
因为不管在什么情况下，新集合内都有自己首选的类。
8。7。2 使用 Lists
L i s t Order is the most important feature of a L i s t ； it promises to maintain elements
238
…………………………………………………………Page 240……………………………………………………………
（interface） in a particular sequence。 L i s t adds a number of methods to Collection that allow
insertion and removal of elements in the middle of a L i s t 。 （This is remended
only for a L i n k e d L i s t 。 ） A List will produce a ListIterator ； and using this you
can traverse the L i s t in both directions； as well as insert and remove elements
in the middle of the list （again； remended only for a L i n k e d L i s t ）。
ArrayList* A L i s t backed by an array。 Use instead of V e c t o r as a general…purpose object
holder。 Allows rapid random access to elements； but is slow when inserting and
removing elements from the middle of a list。 ListIterator should be used only for
back…and…forth traversal of an A r r a y L i s t ； but not for inserting and removing
elements； which is expensive pared to L i n k e d L i s t 。
LinkedList Provides optimal sequential access； with inexpensive insertions and deletions from
the middle of the list。 Relatively slow for random access。 （Use A r r a y L i s t
instead。） Also has a d d F i r s t （ ） ； a d d L a s t （ ） ； g e t F i r s t （ ） ； g e tLast（ ）；
r e m o v e F i r s t （ ） ； and r e m o v e L a s t （ ） （which are not defined in any interfaces or
base classes） to allow it to be used as a stack； a queue； and a dequeue。
List （接口） 顺序是 List 最重要的特性；它可保证元素按照规定的顺序排列。List 为 Collection 添加了
大量方法，以便我们在 List 中部插入和删除元素（只推荐对LinkedList 这样做）。List 也会生成一个
ListIterator （列表反复器），利用它可在一个列表里朝两个方向遍历，同时插入和删除位于列表中部的元
素（同样地，只建议对 LinkedList 这样做）
ArrayList ＊ 由一个数组后推得到的List 。作为一个常规用途的对象容器使用，用于替换原先的Vector。允
许我们快速访问元素，但在从列表中部插入和删除元素时，速度却嫌稍慢。一般只应该用ListIterator 对一
个ArrayList 进行向前和向后遍历，不要用它删除和插入元素；与 LinkedList 相比，它的效率要低许多
LinkedList 提供优化的顺序访问性能，同时可以高效率地在列表中部进行插入和删除操作。但在进行随机访
问时，速度却相当慢，此时应换用ArrayList。也提供了addFirst（），addLast（），getFirst（），
getLast（），removeFirst（） 以及removeLast（） （未在任何接口或基础类中定义），以便将其作为一个规格、
队列以及一个双向队列使用
下面这个例子中的方法每个都覆盖了一组不同的行为：每个列表都能做的事情（basicTest（）），通过一个反
复器遍历（iterMotion（））、用一个反复器改变某些东西（iterManipulation（））、体验列表处理的效果
（testVisual（））以及只有LinkedList 才能做的事情等：
//： List1。java
// Things you can do with Lists
package c08。newcollections；
import java。util。*；
public class List1 ｛
// Wrap Collection1。fill（） for convenience：
public static List fill（List a） ｛
return （List）Collection1。fill（a）；
｝
// You can use an Iterator； just as with a
// Collection； but you can also use random
// access with get（）：
public static void print（List a） ｛
for（int i = 0； i 《 a。size（）； i＋＋）
System。out。print（a。get（i） ＋ 〃 〃）；
System。out。println（）；
｝
239
…………………………………………………………Page 241……………………………………………………………
static boolean b；
static Object o；
static int i；
static Iterator it；
static ListIterator lit；
public static void basicTest（List a） ｛
a。add（1； 〃x〃）； // Add at location 1
a。add（〃x〃）； // Add at end
// Add a collection：
a。addAll（fill（new ArrayList（）））；
// Add a collection starting at location 3：
a。addAll（3； fill（new ArrayList（）））；
b = a。contains（〃1〃）； // Is it in there？
// Is the entire collection in there？
b = a。containsAll（fill（new ArrayList（）））；
// Lists allow random access； which is cheap
// for ArrayList； expensive for LinkedList：
o = a。get（1）； // Get object at location 1
i = a。indexOf（〃1〃）； // Tell index of object
// indexOf； starting search at location 2：
i = a。indexOf（〃1〃； 2）；
b = a。isEmpty（）； // Any elements inside？
it = a。iterator（）； // Ordinary Iterator
lit = a。listIterator（）； // ListIterator
lit = a。listIterator（3）； // Start at loc 3
i = a。lastIndexOf（〃1〃）； // Last match
i = a。lastIndexOf（〃1〃； 2）； // 。。。after loc 2
a。remove（1）； // Remove location 1
a。remove（〃3〃）； // Remove this object
a。set（1； 〃y〃）； // Set location 1 to 〃y〃
// Keep everything that's in the argument
// （the intersection of the two sets）：
a。retainAll（fill（new ArrayList（）））；
// Remove elements in this range：
a。removeRange（0； 2）；
// Remove everything that's in the argument：
a。removeAll（fill（new ArrayList（）））；
i = a。size（）； // How big is it？
a。clear（）； // Remove all elements
｝
public static void iterMotion（List a） ｛
ListIterator it = a。listIterator（）；
b = it。hasNext（）；
b = it。hasPrevious（）；
o = it。next（）；
i = it。nextIndex（）；
o = it。previous（）；
i = it。previousIndex（）；
｝
public static void iterManipulation（List a） ｛
ListIterator it = a。listIterator（）；
it。add（〃47〃）；
240
…………………………………………………………Page 242……………………………………………………………
// Must move to an element after add（）：
it。next（）；
// Remove the element that was just produced：
it。remove（）；
// Must move to an element after remove（）：
it。next（）；
// Change the element that was just produced：
it。set（〃47〃）；
｝
public static void testVisual（List a） ｛
print（a）；
List b = new ArrayList（）；
fill（b）；
System。out。print（〃b = 〃）；
print（b）；
a。addAll（b）；
a。addAll（fill（new ArrayList（）））；
print（a）；
// Shrink the list by removing all the
// elements beyond the first 1/2 of the list
System。out。println（a。size（））；
System。out。println（a。size（）/2）；
a。removeRange（a。size（）/2； a。size（）/2 ＋ 2）；
print（a）；
// Insert； remove； and replace elements
// using a ListIterator：
ListIterator x = a。listIterator（a。size（）/2）；
x。add（〃one〃）；
print（a）；
System。out。println（x。next（））；
x。remove（）；
System。out。println（x。next（））；
x。set（〃47〃）；
print（a）；
// Traverse the list backwards：
x = a。listIterator（a。size（））；
while（x。hasPrevious（））
System。out。print（x。previous（） ＋ 〃 〃）；
System。out。println（）；
System。out。println（〃testVisual finished〃）；
｝
// There are some things that only
// LinkedLists can do：
public static void testLinkedList（） ｛
LinkedList ll = new LinkedList（）；
Collection1。fill（ll； 5）；
print（ll）；
// Treat it like a stack； pushing：
ll。addFirst（〃one〃）；
ll。addFirst（〃two〃）；
print（ll）；
// Like 〃peeking〃 at the top of a stack：
241
…………………………………………………………Page 243……………………………………………………………
System。out。println（ll。getFirst（））；
// Like popping a stack：
System。out。println（ll。removeFirst（））；
System。out。println（ll。removeFirst（））；
// Treat it like a queue； pulling elements
// 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） ｛
快捷操作: 按键盘上方向键 ← 或 → 可快速上下翻页 按键盘上的 Enter 键可回到本书目录页 按键盘上方向键 ↑ 可回到本页顶部!
温馨提示： 温看小说的同时发表评论，说出自己的看法和其它小伙伴们分享也不错哦！发表书评还可以获得积分和经验奖励，认真写原创书评 被采纳为精评可以获得大量金币、积分和经验奖励哦！