Java编程思想第4版[中文版](PDF格式)-第66部分
按键盘上方向键 ← 或 → 可快速上下翻页，按键盘上的 Enter 键可回到本书目录页，按键盘上方向键 ↑ 可回到本页顶部！
————未阅读完？加入书签已便下次继续阅读！
⑥：写作本章时，Java 1。2 尚处于β测试阶段，所以这张示意图没有包括以后会加入的TreeSet。
虚线框代表“接口”，点线框代表“抽象”类，而实线框代表普通（实际）类。点线箭头表示一个特定的类
准备实现一个接口（在抽象类的情况下，则是“部分”实现一个接口）。双线箭头表示一个类可生成箭头指
向的那个类的对象。例如，任何集合都可以生成一个反复器（Iterator），而一个列表可以生成一个
ListIterator （以及原始的反复器，因为列表是从集合继承的）。
致力于容纳对象的接口是Collection，List，Set 和Map。在传统情况下，我们需要写大量代码才能同这些
接口打交道。而且为了指定自己想使用的准确类型，必须在创建之初进行设置。所以可能创建下面这样的一
个List ：
List x = new LinkedList（）；
当然，也可以决定将x 作为一个LinkedList 使用（而不是一个普通的List ），并用x 负载准确的类型信
息。使用接口的好处就是一旦决定改变自己的实施细节，要做的全部事情就是在创建的时候改变它，就象下
面这样：
List x = new ArrayList（）；
其余代码可以保持原封不动。
在类的分级结构中，可看到大量以“Abstract ”（抽象）开头的类，这刚开始可能会使人感觉迷惑。它们实
际上是一些工具，用于“部分”实现一个特定的接口。举个例子来说，假如想生成自己的Set，就不是从 Set
接口开始，然后自行实现所有方法。相反，我们可以从AbstractSet 继承，只需极少的工作即可得到自己的
新类。尽管如此，新集合库仍然包含了足够的功能，可满足我们的几乎所有需求。所以考虑到我们的目的，
可忽略所有以“Abstract ”开头的类。
因此，在观看这张示意图时，真正需要关心的只有位于最顶部的“接口”以及普通（实际）类——均用实线
方框包围。通常需要生成实际类的一个对象，将其上溯造型为对应的接口。以后即可在代码的任何地方使用
234
…………………………………………………………Page 236……………………………………………………………
那个接口。下面是一个简单的例子，它用 String 对象填充一个集合，然后打印出集合内的每一个元素：
//： SimpleCollection。java
// A simple example using the new Collections
package c08。newcollections；
import java。util。*；
public class SimpleCollection ｛
public static void main（String＇＇ args） ｛
Collection c = new ArrayList（）；
for（int i = 0； i 《 10； i＋＋）
c。add（Integer。toString（i））；
Iterator it = c。iterator（）；
while（it。hasNext（））
System。out。println（it。next（））；
｝
｝ ///：~
新集合库的所有代码示例都置于子目录newcollections 下，这样便可提醒自己这些工作只对于Java 1。2 有
效。这样一来，我们必须用下述代码来调用程序：
java c08。newcollections。SimpleCollection
采用的语法与其他程序是差不多的。
大家可以看到新集合属于java。util 库的一部分，所以在使用时不需要再添加任何额外的 import语句。
main（）的第一行创建了一个ArrayList 对象，然后将其上溯造型成为一个集合。由于这个例子只使用了
Collection 方法，所以从 Collection 继承的一个类的任何对象都可以正常工作。但ArrayList 是一个典型
的Collection，它代替了 Vector 的位置。
显然，add（）方法的作用是将一个新元素置入集合里。然而，用户文档谨慎地指出 add（） “保证这个集合包含
了指定的元素”。这一点是为Set 作铺垫的，后者只有在元素不存在的前提下才会真的加入那个元素。对于
ArrayList 以及其他任何形式的List，add（）肯定意味着“直接加入”。
利用 iterator（）方法，所有集合都能生成一个“反复器”（Iterator）。反复器其实就象一个“枚举”
（Enumeration），是后者的一个替代物，只是：
（1） 它采用了一个历史上默认、而且早在OOP 中得到广泛采纳的名字（反复器）。
（2） 采用了比Enumeration 更短的名字：hasNext（）代替了 hasMoreElement（），而next（）代替了
nextElement（） 。
（3） 添加了一个名为remove（） 的新方法，可删除由Iterator 生成的上一个元素。所以每次调用 next（）的时
候，只需调用remove（）一次。
在SimpleCollection。java 中，大家可看到创建了一个反复器，并用它在集合里遍历，打印出每个元素。
8。7。1 使用 Collections
下面这张表格总结了用一个集合能做的所有事情（亦可对 Set 和List 做同样的事情，尽管 List 还提供了一
些额外的功能）。Map 不是从Collection 继承的，所以要单独对待。
B o o l e a n a d d （ O b j e c t ） *Ensures that the Collection contains the argument。 Returns false if
it doesn ’t add the argument。
B o o l e a n *Adds all the elements in the argument。 Returns true if any elements
a d d A l l （ C o l l e c t i o n ） were added。
v o i d c l e a r （ ） *Removes all the elements in the Collection。
Boolean contains（Object） True if the Collection contains the argument。
B o o l e a n True if the Collection contains all the elements in the argument。
235
…………………………………………………………Page 237……………………………………………………………
containsAll（Collection）
B o o l e a n i s E m p t y （ ） True if the Collection has no elements。
Iterator iterator（ ） Returns an Iterator that you can use to move through the elements in
the Collection。
Boolean remove（Object） *If the argument is in the Collection； one instance of that element
is removed。 Returns true if a removal occurred。
B o o l e a n *Removes all the elements that are contained in the argument。
removeAll（Collection） Returns true if any removals occurred。
B o o l e a n *Retains only elements that are contained in the argument （an
retainAll（Collection） “intersection” from set theory）。 Returns true if any changes
occurred。
i n t s i z e （ ） Returns the number of elements in the Collection。
O b j e c t ＇ ＇ t o A r r a y （ ） Returns an array containing all the elements in the Collection。
O b j e c t ＇ ＇ Returns an array containing all the elements in the Collection；
t o A r r a y （ O b j e c t ＇ ＇ a ） whose type is that of the array a rather than plain Object （you must
cast the array to the right type）。
*This is an “optional ” method； which means it might not be
implemented by a particular Collection。 If not； that method throws
an U n s u p p o r t e d O p e r a t i o n E x c e p t i o n 。 Exceptions will be covered in
Chapter 9。
boolean add（Object） ＊保证集合内包含了自变量。如果它没有添加自变量，就返回false （假）
boolean addAll（Collection） ＊添加自变量内的所有元素。如果没有添加元素，则返回true （真）
void clear（） ＊删除集合内的所有元素
boolean contains（Object） 若集合包含自变量，就返回“真”
boolean containsAll（Collection） 若集合包含了自变量内的所有元素，就返回“真”
boolean isEmpty（） 若集合内没有元素，就返回“真”
Iterator iterator（） 返回一个反复器，以用它遍历集合的各元素
boolean remove（Object） ＊如自变量在集合里，就删除那个元素的一个实例。如果已进行了删除，就返回
“真”
boolean removeAll（Collection） ＊删除自变量里的所有元素。如果已进行了任何删除，就返回“真”
boolean retainAll（Collection） ＊只保留包含在一个自变量里的元素（一个理论的“交集”）。如果已进
行了任何改变，就返回“真”
int size（） 返回集合内的元素数量
Object＇＇ toArray（） 返回包含了集合内所有元素的一个数组
＊这是一个“可选的”方法，有的集合可能并未实现它。若确实如此，该方法就会遇到一个
UnsupportedOperatiionException，即一个“操作不支持”违例，详见第9 章。
下面这个例子向大家演示了所有方法。同样地，它们只对从集合继承的东西有效，一个ArrayList 作为一种
“不常用的分母”使用：
//： Collection1。java
// Things you can do with all Collections
package c08。newcollections；
import java。util。*；
public class Collection1 ｛
// Fill with 'size' elements； start
236
…………………………………………………………Page 238……………………………………………………………
// counting at 'start'：
public static Collection
fill（Collection c； int start； int size） ｛
for（int i = start； i 《 start ＋ size； i＋＋）
c。add（Integer。toString（i））；
return c；
｝
// Default to a 〃start〃 of 0：
public static Collection
fill（Collection c； int size） ｛
return fill（c； 0； size）；
｝
// Default to 10 elements：
public static Collection fill（Collection c） ｛
return fill（c； 0； 10）；
｝
// Create & upcast to Collection：
public static Collection newCollection（） ｛
return fill（new ArrayList（））；
// ArrayList is used for simplicity； but it's
// only seen as a generic Collection
// everywhere else in the program。
｝
// Fill a Collection with a range of values：
public static Collection
newCollection（int start； int size） ｛
return fill（new ArrayList（）； start； size）；
｝
// Moving through a List with an iterator：
public static void print（Collection c） ｛
for（Iterator x = c。iterator（）； x。hasNext（）；）
System。out。print（x。next（） ＋ 〃 〃）；
System。out。println（）；
｝
public static void main（String＇＇ args） ｛
Collection c = newCollection（）；
c。add （〃ten〃）；
c。add（〃eleven〃）；
print（c）；
// Make an array from the List：
Object＇＇ array = c。toArray（）；
// Make a String array from the List：
String＇＇ str =
（String＇＇）c。toArray（new String＇1＇）；
// Find max and min elements； this means
// different things depending on the way
// the parable interface is implemented：
System。out。println（〃Collections。max（c） = 〃 ＋
Collections。max（c））；
System。out。println（〃Collections。min（c） = 〃 ＋
Collections。min（c））；
// Add a Collection to another Collection
237
…………………………………………………………Page 239……………………………………………………………
c。addAll（newCollection（））；
print（c）；
c。remove（〃3〃）； // Removes the first one
print（c）；
c。remove（〃3〃）； // Removes the second one
print（c）；
