第8章 对象的容纳

“如果一个程序只含有数量固定的对象，而且已知它们的存在时间，那么这个程序可以说是相当简单的。”

通常，我们的程序需要根据程序运行时才知道的一些标准创建新对象。若非程序正式运行，否则我们根本不知道自己到底需要多少数量的对象，甚至不知道它们的准确类型。为了满足常规编程的需要，我们要求能在任何时候、任何地点创建任意数量的对象。所以不可依赖一个已命名的句柄来容纳自己的每一个对象，就象下面这样：

MyObject myHandle;

因为根本不知道自己实际需要多少这样的东西。

为解决这个非常关键的问题，Java提供了容纳对象（或者对象的句柄）的多种方式。其中内建的类型是数组，我们之前已讨论过它，本章准备加深大家对它的认识。此外，Java的工具（实用程序）库提供了一些“集合类”（亦称作“容器类”，但该术语已由AWT使用，所以这里仍采用“集合”这一称呼）。利用这些集合类，我们可以容纳乃至操纵自己的对象。本章的剩余部分会就此进行详细讨论。

8.1 数组

对数组的大多数必要的介绍已在第4章的最后一节进行。通过那里的学习，大家已知道自己该如何定义及初始化一个数组。对象的容纳是本章的重点，而数组只是容纳对象的一种方式。但由于还有其他大量方法可容纳数组，所以是哪些地方使数组显得如此特别呢？

有两方面的问题将数组与其他集合类型区分开来：效率和类型。对于Java来说，为保存和访问一系列对象（实际是对象的句柄）数组，最有效的方法莫过于数组。数组实际代表一个简单的线性序列，它使得元素的访问速度非常快，但我们却要为这种速度付出代价：创建一个数组对象时，它的大小是固定的，而且不可在那个数组对象的“存在时间”内发生改变。可创建特定大小的一个数组，然后假如用光了存储空间，就再创建一个新数组，将所有句柄从旧数组移到新数组。这属于“矢量”（Vector）类的行为，本章稍后还会详细讨论它。然而，由于为这种大小的灵活性要付出较大的代价，所以我们认为矢量的效率并没有数组高。

C++的矢量类知道自己容纳的是什么类型的对象，但同Java的数组相比，它却有一个明显的缺点：C++矢量类的operator[]不能进行范围检查，所以很容易超出边界（然而，它可以查询vector有多大，而且at()方法确实能进行范围检查）。在Java中，无论使用的是数组还是集合，都会进行范围检查——若超过边界，就会获得一个RuntimeException（运行期违例）错误。正如大家在第9章会学到的那样，这类违例指出的是一个程序员错误，所以不需要在代码中检查它。在另一方面，由于C++的vector不进行范围检查，所以访问速度较快——在Java中，由于对数组和集合都要进行范围检查，所以对性能有一定的影响。

本章还要学习另外几种常见的集合类：Vector（矢量）、Stack（堆栈）以及Hashtable（散列表）。这些类都涉及对对象的处理——好象它们没有特定的类型。换言之，它们将其当作Object类型处理（Object类型是Java中所有类的“根”类）。从某个角度看，这种处理方法是非常合理的：我们仅需构建一个集合，然后任何Java对象都可以进入那个集合（除基本数据类型外——可用Java的基本类型封装类将其作为常数置入集合，或者将其封装到自己的类内，作为可以变化的值使用）。这再一次反映了数组优于常规集合：创建一个数组时，可令其容纳一种特定的类型。这意味着可进行编译期类型检查，预防自己设置了错误的类型，或者错误指定了准备提取的类型。当然，在编译期或者运行期，Java会防止我们将不当的消息发给一个对象。所以我们不必考虑自己的哪种做法更加危险，只要编译器能及时地指出错误，同时在运行期间加快速度，目的也就达到了。此外，用户很少会对一次违例事件感到非常惊讶的。

考虑到执行效率和类型检查，应尽可能地采用数组。然而，当我们试图解决一个更常规的问题时，数组的局限也可能显得非常明显。在研究过数组以后，本章剩余的部分将把重点放到Java提供的集合类身上。

8.1.1 数组和第一类对象

无论使用的数组属于什么类型，数组标识符实际都是指向真实对象的一个句柄。那些对象本身是在内存“堆”里创建的。堆对象既可“隐式”创建（即默认产生），亦可“显式”创建（即明确指定，用一个new表达式）。堆对象的一部分（实际是我们能访问的唯一字段或方法）是只读的length（长度）成员，它告诉我们那个数组对象里最多能容纳多少元素。对于数组对象，“[]”语法是我们能采用的唯一另类访问方法。

下面这个例子展示了对数组进行初始化的不同方式，以及如何将数组句柄分配给不同的数组对象。它也揭示出对象数组和基本数据类型数组在使用方法上几乎是完全一致的。唯一的差别在于对象数组容纳的是句柄，而基本数据类型数组容纳的是具体的数值（若在执行此程序时遇到困难，请参考第3章的“赋值”小节）：

//: ArraySize.java

// Initialization & re-assignment of arrays

package c08;

class Weeble {} // A small mythical creature

public class ArraySize {

 public static void main(String[] args) {

  // Arrays of objects:

  Weeble[] a; // Null handle

  Weeble[] b = new Weeble[5]; // Null handles

  Weeble[] c = new Weeble[4];

  for(int i = 0; i < c.length; i++)

   c[i] = new Weeble();

  Weeble[] d = {

   new Weeble(), new Weeble(), new Weeble()

  };

  // Compile error: variable a not initialized:

  //!System.out.println("a.length=" + a.length);

  System.out.println("b.length = " + b.length);

  // The handles inside the array are

  // automatically initialized to null:

  for(int i = 0; i < b.length; i++)

   System.out.println("b[" + i + "]=" + b[i]);

  System.out.println("c.length = " + c.length);

  System.out.println("d.length = " + d.length);

  a = d;

  System.out.println("a.length = " + a.length);

  // Java 1.1 initialization syntax:

  a = new Weeble[] {

   new Weeble(), new Weeble()

  };

  System.out.println("a.length = " + a.length);

  // Arrays of primitives:

  int[] e; // Null handle

  int[] f = new int[5];

  int[] g = new int[4];

  for(int i = 0; i < g.length; i++)

   g[i] = i*i;

  int[] h = { 11, 47, 93 };

  // Compile error: variable e not initialized:

  //!System.out.println("e.length=" + e.length);

  System.out.println("f.length = " + f.length);

  // The primitives inside the array are

  // automatically initialized to zero:

  for(int i = 0; i < f.length; i++)

   System.out.println("f[" + i + "]=" + f[i]);

  System.out.println("g.length = " + g.length);

  System.out.println("h.length = " + h.length);

  e = h;

  System.out.println("e.length = " + e.length);

  // Java 1.1 initialization syntax:

  e = new int[] { 1, 2 };

  System.out.println("e.length = " + e.length);

 }

} ///:~

Here’s the output from the program:

b.length = 5

b[0]=null

b[1]=null

b[2]=null

b[3]=null

b[4]=null

c.length = 4

d.length = 3

a.length = 3

a.length = 2

f.length = 5

f[0]=0

f[1]=0

f[2]=0

f[3]=0

f[4]=0

g.length = 4

h.length = 3

e.length = 3

e.length = 2

其中，数组a只是初始化成一个null句柄。此时，编译器会禁止我们对这个句柄作任何实际操作，除非已正确地初始化了它。数组b被初始化成指向由Weeble句柄构成的一个数组，但那个数组里实际并未放置任何Weeble对象。然而，我们仍然可以查询那个数组的大小，因为b指向的是一个合法对象。这也为我们带来了一个难题：不可知道那个数组里实际包含了多少个元素，因为length只告诉我们可将多少元素置入那个数组。换言之，我们只知道数组对象的大小或容量，不知其实际容纳了多少个元素。尽管如此，由于数组对象在创建之初会自动初始化成null，所以可检查它是否为null，判断一个特定的数组“空位”是否容纳一个对象。类似地，由基本数据类型构成的数组会自动初始化成零（针对数值类型）、null（字符类型）或者false（布尔类型）。

数组c显示出我们首先创建一个数组对象，再将Weeble对象赋给那个数组的所有“空位”。数组d揭示出“集合初始化”语法，从而创建数组对象（用new命令明确进行，类似于数组c），然后用Weeble对象进行初始化，全部工作在一条语句里完成。

下面这个表达式：

a = d;

向我们展示了如何取得同一个数组对象连接的句柄，然后将其赋给另一个数组对象，就象我们针对对象句柄的其他任何类型做的那样。现在，a和d都指向内存堆内同样的数组对象。

Java 1.1加入了一种新的数组初始化语法，可将其想象成“动态集合初始化”。由d采用的Java 1.0集合初始化方法则必须在定义d的同时进行。但若采用Java 1.1的语法，却可以在任何地方创建和初始化一个数组对象。例如，假设hide()方法用于取得一个Weeble对象数组，那么调用它时传统的方法是：

hide(d);

但在Java 1.1中，亦可动态创建想作为参数传递的数组，如下所示：

hide(new Weeble[] {new Weeble(), new Weeble() });

这一新式语法使我们在某些场合下写代码更方便了。

上述例子的第二部分揭示出这样一个问题：对于由基本数据类型构成的数组，它们的运作方式与对象数组极为相似，只是前者直接包容了基本类型的数据值。

1. 基本数据类型集合

集合类只能容纳对象句柄。但对一个数组，却既可令其直接容纳基本类型的数据，亦可容纳指向对象的句柄。利用象Integer、Double之类的“封装器”类，可将基本数据类型的值置入一个集合里。但正如本章后面会在WordCount.java例子中讲到的那样，用于基本数据类型的封装器类只是在某些场合下才能发挥作用。无论将基本类型的数据置入数组，还是将其封装进入位于集合的一个类内，都涉及到执行效率的问题。显然，若能创建和访问一个基本数据类型数组，那么比起访问一个封装数据的集合，前者的效率会高出许多。

当然，假如准备一种基本数据类型，同时又想要集合的灵活性（在需要的时候可自动扩展，腾出更多的空间），就不宜使用数组，必须使用由封装的数据构成的一个集合。大家或许认为针对每种基本数据类型，都应有一种特殊类型的Vector。但Java并未提供这一特性。某些形式的建模机制或许会在某一天帮助Java更好地解决这个问题（注释①）。

①：这儿是C++比Java做得好的一个地方，因为C++通过template关键字提供了对“参数化类型”的支持。

8.1.2 数组的返回

假定我们现在想写一个方法，同时不希望它仅仅返回一样东西，而是想返回一系列东西。此时，象C和C++这样的语言会使问题复杂化，因为我们不能返回一个数组，只能返回指向数组的一个指针。这样就非常麻烦，因为很难控制数组的“存在时间”，它很容易造成内存“漏洞”的出现。

Java采用的是类似的方法，但我们能“返回一个数组”。当然，此时返回的实际仍是指向数组的指针。但在Java里，我们永远不必担心那个数组的是否可用——只要需要，它就会自动存在。而且垃圾收集器会在我们完成后自动将其清除。

作为一个例子，请思考如何返回一个字串数组：

//: IceCream.java

// Returning arrays from methods

public class IceCream {

 static String[] flav = {

  "Chocolate", "Strawberry",

  "Vanilla Fudge Swirl", "Mint Chip",

  "Mocha Almond Fudge", "Rum Raisin",

  "Praline Cream", "Mud Pie"

 };

 static String[] flavorSet(int n) {

  // Force it to be positive & within bounds:

  n = Math.abs(n) % (flav.length + 1);

  String[] results = new String[n];

  int[] picks = new int[n];

  for(int i = 0; i < picks.length; i++)

   picks[i] = -1;

  for(int i = 0; i < picks.length; i++) {

   retry:

   while(true) {

    int t =

     (int)(Math.random() * flav.length);

    for(int j = 0; j < i; j++)

     if(picks[j] == t) continue retry;

    picks[i] = t;

    results[i] = flav[t];

    break;

   }

  }

  return results;

 }

 public static void main(String[] args) {

  for(int i = 0; i < 20; i++) {

   System.out.println(

    "flavorSet(" + i + ") = ");

   String[] fl = flavorSet(flav.length);

   for(int j = 0; j < fl.length; j++)

    System.out.println("\t" + fl[j]);

  }

 }

} ///:~

flavorSet()方法创建了一个名为results的String数组。该数组的大小为n——具体数值取决于我们传递给方法的自变量。随后，它从数组flav里随机挑选一些“香料”（Flavor），并将它们置入results里，并最终返回results。返回数组与返回其他任何对象没什么区别——最终返回的都是一个句柄。至于数组到底是在flavorSet()里创建的，还是在其他什么地方创建的，这个问题并不重要，因为反正返回的仅是一个句柄。一旦我们的操作完成，垃圾收集器会自动关照数组的清除工作。而且只要我们需要数组，它就会乖乖地听候调遣。

另一方面，注意当flavorSet()随机挑选香料的时候，它需要保证以前出现过的一次随机选择不会再次出现。为达到这个目的，它使用了一个无限while循环，不断地作出随机选择，直到发现未在picks数组里出现过的一个元素为止（当然，也可以进行字串比较，检查随机选择是否在results数组里出现过，但字串比较的效率比较低）。若成功，就添加这个元素，并中断循环（break），再查找下一个（i值会递增）。但假若t是一个已在picks里出现过的数组，就用标签式的continue往回跳两级，强制选择一个新t。用一个调试程序可以很清楚地看到这个过程。

main()能显示出20个完整的香料集合，所以我们看到flavorSet()每次都用一个随机顺序选择香料。为体会这一点，最简单的方法就是将输出重导向进入一个文件，然后直接观看这个文件的内容。

8.2 集合

现在总结一下我们前面学过的东西：为容纳一组对象，最适宜的选择应当是数组。而且假如容纳的是一系列基本数据类型，更是必须采用数组。在本章剩下的部分，大家将接触到一些更常规的情况。当我们编写程序时，通常并不能确切地知道最终需要多少个对象。有些时候甚至想用更复杂的方式来保存对象。为解决这个问题，Java提供了四种类型的“集合类”：Vector（矢量）、BitSet（位集）、Stack（堆栈）以及Hashtable（散列表）。与拥有集合功能的其他语言相比，尽管这儿的数量显得相当少，但仍然能用它们解决数量惊人的实际问题。

这些集合类具有形形色色的特征。例如，Stack实现了一个LIFO（先入先出）序列，而Hashtable是一种“关联数组”，允许我们将任何对象关联起来。除此以外，所有Java集合类都能自动改变自身的大小。所以，我们在编程时可使用数量众多的对象，同时不必担心会将集合弄得有多大。

8.2.1 缺点：类型未知

使用Java集合的“缺点”是在将对象置入一个集合时丢失了类型信息。之所以会发生这种情况，是由于当初编写集合时，那个集合的程序员根本不知道用户到底想把什么类型置入集合。若指示某个集合只允许特定的类型，会妨碍它成为一个“常规用途”的工具，为用户带来麻烦。为解决这个问题，集合实际容纳的是类型为Object的一些对象的句柄。这种类型当然代表Java中的所有对象，因为它是所有类的根。当然，也要注意这并不包括基本数据类型，因为它们并不是从“任何东西”继承来的。这是一个很好的方案，只是不适用下述场合：

(1) 将一个对象句柄置入集合时，由于类型信息会被抛弃，所以任何类型的对象都可进入我们的集合——即便特别指示它只能容纳特定类型的对象。举个例子来说，虽然指示它只能容纳猫，但事实上任何人都可以把一条狗扔进来。

(2) 由于类型信息不复存在，所以集合能肯定的唯一事情就是自己容纳的是指向一个对象的句柄。正式使用它之前，必须对其进行造型，使其具有正确的类型。

值得欣慰的是，Java不允许人们滥用置入集合的对象。假如将一条狗扔进一个猫的集合，那么仍会将集合内的所有东西都看作猫，所以在使用那条狗时会得到一个“违例”错误。在同样的意义上，假若试图将一条狗的句柄“造型”到一只猫，那么运行期间仍会得到一个“违例”错误。

下面是个例子：

//: CatsAndDogs.java

// Simple collection example (Vector)

import java.util.*;

class Cat {

 private int catNumber;

 Cat(int i) {

  catNumber = i;

 }

 void print() {

  System.out.println("Cat #" + catNumber);

 }

}

class Dog {

 private int dogNumber;

 Dog(int i) {

  dogNumber = i;

 }

 void print() {

  System.out.println("Dog #" + dogNumber);

 }

}

public class CatsAndDogs {

 public static void main(String[] args) {

  Vector cats = new Vector();

  for(int i = 0; i < 7; i++)

   cats.addElement(new Cat(i));

  // Not a problem to add a dog to cats:

  cats.addElement(new Dog(7));

  for(int i = 0; i < cats.size(); i++)

   ((Cat)cats.elementAt(i)).print();

  // Dog is detected only at run-time

 }

} ///:~

可以看出，Vector的使用是非常简单的：先创建一个，再用addElement()置入对象，以后用elementAt()取得那些对象（注意Vector有一个size()方法，可使我们知道已添加了多少个元素，以便防止误超边界，造成违例错误）。

Cat和Dog类都非常浅显——除了都是“对象”之外，它们并无特别之处（倘若不明确指出从什么类继承，就默认为从Object继承。所以我们不仅能用Vector方法将Cat对象置入这个集合，也能添加Dog对象，同时不会在编译期和运行期得到任何出错提示。用Vector方法elementAt()获取原本认为是Cat的对象时，实际获得的是指向一个Object的句柄，必须将那个对象造型为Cat。随后，需要将整个表达式用括号封闭起来，在为Cat调用print()方法之前进行强制造型；否则就会出现一个语法错误。在运行期间，如果试图将Dog对象造型为Cat，就会得到一个违例。

这些处理的意义都非常深远。尽管显得有些麻烦，但却获得了安全上的保证。我们从此再难偶然造成一些隐藏得深的错误。若程序的一个部分（或几个部分）将对象插入一个集合，但我们只是通过一次违例在程序的某个部分发现一个错误的对象置入了集合，就必须找出插入错误的位置。当然，可通过检查代码达到这个目的，但这或许是最笨的调试工具。另一方面，我们可从一些标准化的集合类开始自己的编程。尽管它们在功能上存在一些不足，且显得有些笨拙，但却能保证没有隐藏的错误。

1. 错误有时并不显露出来

在某些情况下，程序似乎正确地工作，不造型回我们原来的类型。第一种情况是相当特殊的：String类从编译器获得了额外的帮助，使其能够正常工作。只要编译器期待的是一个String对象，但它没有得到一个，就会自动调用在Object里定义、并且能够由任何Java类覆盖的toString()方法。这个方法能生成满足要求的String对象，然后在我们需要的时候使用。

因此，为了让自己类的对象能显示出来，要做的全部事情就是覆盖toString()方法，如下例所示：

//: WorksAnyway.java

// In special cases, things just seem

// to work correctly.

import java.util.*;

class Mouse {

 private int mouseNumber;

 Mouse(int i) {

  mouseNumber = i;

 }

 // Magic method:

 public String toString() {

  return "This is Mouse #" + mouseNumber;

 }

 void print(String msg) {

  if(msg != null) System.out.println(msg);

  System.out.println(

   "Mouse number " + mouseNumber);

 }

}

class MouseTrap {

 static void caughtYa(Object m) {

  Mouse mouse = (Mouse)m; // Cast from Object

  mouse.print("Caught one!");

 }

}

public class WorksAnyway {

 public static void main(String[] args) {

  Vector mice = new Vector();

  for(int i = 0; i < 3; i++)

   mice.addElement(new Mouse(i));

  for(int i = 0; i < mice.size(); i++) {

   // No cast necessary, automatic call

   // to Object.toString():

   System.out.println(

    "Free mouse: " + mice.elementAt(i));

   MouseTrap.caughtYa(mice.elementAt(i));

  }

 }

} ///:~

可在Mouse里看到对toString()的重定义代码。在main()的第二个for循环中，可发现下述语句：

System.out.println("Free mouse: " +

mice.elementAt(i));

在“+”后，编译器预期看到的是一个String对象。elementAt()生成了一个Object，所以为获得希望的String，编译器会默认调用toString()。但不幸的是，只有针对String才能得到象这样的结果；其他任何类型都不会进行这样的转换。

隐藏造型的第二种方法已在Mousetrap里得到了应用。caughtYa()方法接收的不是一个Mouse，而是一个Object。随后再将其造型为一个Mouse。当然，这样做是非常冒失的，因为通过接收一个Object，任何东西都可以传递给方法。然而，假若造型不正确——如果我们传递了错误的类型——就会在运行期间得到一个违例错误。这当然没有在编译期进行检查好，但仍然能防止问题的发生。注意在使用这个方法时毋需进行造型：

MouseTrap.caughtYa(mice.elementAt(i));

2. 生成能自动判别类型的Vector

大家或许不想放弃刚才那个问题。一个更“健壮”的方案是用Vector创建一个新类，使其只接收我们指定的类型，也只生成我们希望的类型。如下所示：

//: GopherVector.java

// A type-conscious Vector

import java.util.*;

class Gopher {

 private int gopherNumber;

 Gopher(int i) {

  gopherNumber = i;

 }

 void print(String msg) {

  if(msg != null) System.out.println(msg);

  System.out.println(

   "Gopher number " + gopherNumber);

 }

}

class GopherTrap {

 static void caughtYa(Gopher g) {

  g.print("Caught one!");

 }

}

class GopherVector {

 private Vector v = new Vector();

 public void addElement(Gopher m) {

  v.addElement(m);

 }

 public Gopher elementAt(int index) {

  return (Gopher)v.elementAt(index);

 }

 public int size() { return v.size(); }

 public static void main(String[] args) {

  GopherVector gophers = new GopherVector();

  for(int i = 0; i < 3; i++)

   gophers.addElement(new Gopher(i));

  for(int i = 0; i < gophers.size(); i++)

   GopherTrap.caughtYa(gophers.elementAt(i));

 }

} ///:~

这前一个例子类似，只是新的GopherVector类有一个类型为Vector的private成员（从Vector继承有些麻烦，理由稍后便知），而且方法也和Vector类似。然而，它不会接收和产生普通Object，只对Gopher对象感兴趣。

由于GopherVector只接收一个Gopher（地鼠），所以假如我们使用：

gophers.addElement(new Pigeon());

就会在编译期间获得一条出错消息。采用这种方式，尽管从编码的角度看显得更令人沉闷，但可以立即判断出是否使用了正确的类型。

注意在使用elementAt()时不必进行造型——它肯定是一个Gopher。

3. 参数化类型

这类问题并不是孤立的——我们许多时候都要在其他类型的基础上创建新类型。此时，在编译期间拥有特定的类型信息是非常有帮助的。这便是“参数化类型”的概念。在C++中，它由语言通过“模板”获得了直接支持。至少，Java保留了关键字generic，期望有一天能够支持参数化类型。但我们现在无法确定这一天何时会来临。

8.3 枚举器（反复器）

在任何集合类中，必须通过某种方法在其中置入对象，再用另一种方法从中取得对象。毕竟，容纳各种各样的对象正是集合的首要任务。在Vector中，addElement()便是我们插入对象采用的方法，而elementAt()是提取对象的唯一方法。Vector非常灵活，我们可在任何时候选择任何东西，并可使用不同的索引选择多个元素。

若从更高的角度看这个问题，就会发现它的一个缺陷：需要事先知道集合的准确类型，否则无法使用。乍看来，这一点似乎没什么关系。但假若最开始决定使用Vector，后来在程序中又决定（考虑执行效率的原因）改变成一个List（属于Java1.2集合库的一部分），这时又该如何做呢？

可利用“反复器”（Iterator）的概念达到这个目的。它可以是一个对象，作用是遍历一系列对象，并选择那个序列中的每个对象，同时不让客户程序员知道或关注那个序列的基础结构。此外，我们通常认为反复器是一种“轻量级”对象；也就是说，创建它只需付出极少的代价。但也正是由于这个原因，我们常发现反复器存在一些似乎很奇怪的限制。例如，有些反复器只能朝一个方向移动。

Java的Enumeration（枚举，注释②）便是具有这些限制的一个反复器的例子。除下面这些外，不可再用它做其他任何事情：

(1) 用一个名为elements()的方法要求集合为我们提供一个Enumeration。我们首次调用它的nextElement()时，这个Enumeration会返回序列中的第一个元素。

(2) 用nextElement()获得下一个对象。

(3) 用hasMoreElements()检查序列中是否还有更多的对象。

②：“反复器”这个词在C++和OOP的其他地方是经常出现的，所以很难确定为什么Java的开发者采用了这样一个奇怪的名字。Java 1.2的集合库修正了这个问题以及其他许多问题。

只可用Enumeration做这些事情，不能再有更多。它属于反复器一种简单的实现方式，但功能依然十分强大。为体会它的运作过程，让我们复习一下本章早些时候提到的CatsAndDogs.java程序。在原始版本中，elementAt()方法用于选择每一个元素，但在下述修订版中，可看到使用了一个“枚举”：

//: CatsAndDogs2.java

// Simple collection with Enumeration

import java.util.*;

class Cat2 {

 private int catNumber;

 Cat2(int i) {

  catNumber = i;

 }

 void print() {

  System.out.println("Cat number " +catNumber);

 }

}

class Dog2 {

 private int dogNumber;

 Dog2(int i) {

  dogNumber = i;

 }

 void print() {

  System.out.println("Dog number " +dogNumber);

 }

}

public class CatsAndDogs2 {

 public static void main(String[] args) {

  Vector cats = new Vector();

  for(int i = 0; i < 7; i++)

   cats.addElement(new Cat2(i));

  // Not a problem to add a dog to cats:

  cats.addElement(new Dog2(7));

  Enumeration e = cats.elements();

  while(e.hasMoreElements())

   ((Cat2)e.nextElement()).print();

  // Dog is detected only at run-time

 }

} ///:~

我们看到唯一的改变就是最后几行。不再是：

for(int i = 0; i < cats.size(); i++)

((Cat)cats.elementAt(i)).print();

而是用一个Enumeration遍历整个序列：

while(e.hasMoreElements())

((Cat2)e.nextElement()).print();

使用Enumeration，我们不必关心集合中的元素数量。所有工作均由hasMoreElements()和nextElement()自动照管了。

下面再看看另一个例子，让我们创建一个常规用途的打印方法：

//: HamsterMaze.java

// Using an Enumeration

import java.util.*;

class Hamster {

 private int hamsterNumber;

 Hamster(int i) {

  hamsterNumber = i;

 }

 public String toString() {

  return "This is Hamster #" + hamsterNumber;

 }

}

class Printer {

 static void printAll(Enumeration e) {

  while(e.hasMoreElements())

   System.out.println(

    e.nextElement().toString());

 }

}

public class HamsterMaze {

 public static void main(String[] args) {

  Vector v = new Vector();

  for(int i = 0; i < 3; i++)

   v.addElement(new Hamster(i));

  Printer.printAll(v.elements());

 }

} ///:~

仔细研究一下打印方法：

static void printAll(Enumeration e) {

 while(e.hasMoreElements())

  System.out.println(

   e.nextElement().toString());

}

注意其中没有与序列类型有关的信息。我们拥有的全部东西便是Enumeration。为了解有关序列的情况，一个Enumeration便足够了：可取得下一个对象，亦可知道是否已抵达了末尾。取得一系列对象，然后在其中遍历，从而执行一个特定的操作——这是一个颇有价值的编程概念，本书许多地方都会沿用这一思路。

这个看似特殊的例子甚至可以更为通用，因为它使用了常规的toString()方法（之所以称为常规，是由于它属于Object类的一部分）。下面是调用打印的另一个方法（尽管在效率上可能会差一些）：

System.out.println("" + e.nextElement());

它采用了封装到Java内部的“自动转换成字串”技术。一旦编译器碰到一个字串，后面跟随一个“+”，就会希望后面又跟随一个字串，并自动调用toString()。在Java 1.1中，第一个字串是不必要的；所有对象都会转换成字串。亦可对此执行一次造型，获得与调用toString()同样的效果：

System.out.println((String)e.nextElement())

但我们想做的事情通常并不仅仅是调用Object方法，所以会再度面临类型造型的问题。对于自己感兴趣的类型，必须假定自己已获得了一个Enumeration，然后将结果对象造型成为那种类型（若操作错误，会得到运行期违例）。

8.4 集合的类型

标准Java 1.0和1.1库配套提供了非常少的一系列集合类。但对于自己的大多数编程要求，它们基本上都能胜任。正如大家到本章末尾会看到的，Java 1.2提供的是一套重新设计过的大型集合库。

8.4.1 Vector

Vector的用法很简单，这已在前面的例子中得到了证明。尽管我们大多数时候只需用addElement()插入对象，用elementAt()一次提取一个对象，并用elements()获得对序列的一个“枚举”。但仍有其他一系列方法是非常有用的。同我们对于Java库惯常的做法一样，在这里并不使用或讲述所有这些方法。但请务必阅读相应的电子文档，对它们的工作有一个大概的认识。

1. 崩溃Java

Java标准集合里包含了toString()方法，所以它们能生成自己的String表达方式，包括它们容纳的对象。例如在Vector中，toString()会在Vector的各个元素中步进和遍历，并为每个元素调用toString()。假定我们现在想打印出自己类的地址。看起来似乎简单地引用this即可（特别是C++程序员有这样做的倾向）：

//: CrashJava.java

// One way to crash Java

import java.util.*;

public class CrashJava {

 public String toString() {

  return "CrashJava address: " + this + "\n";

 }

 public static void main(String[] args) {

  Vector v = new Vector();

  for(int i = 0; i < 10; i++)

   v.addElement(new CrashJava());

  System.out.println(v);

 }

} ///:~

若只是简单地创建一个CrashJava对象，并将其打印出来，就会得到无穷无尽的一系列违例错误。然而，假如将CrashJava对象置入一个Vector，并象这里演示的那样打印Vector，就不会出现什么错误提示，甚至连一个违例都不会出现。此时Java只是简单地崩溃（但至少它没有崩溃我的操作系统）。这已在Java 1.1中测试通过。

此时发生的是字串的自动类型转换。当我们使用下述语句时：

"CrashJava address: " + this

编译器就在一个字串后面发现了一个“+”以及好象并非字串的其他东西，所以它会试图将this转换成一个字串。转换时调用的是toString()，后者会产生一个递归调用。若在一个Vector内出现这种事情，看起来堆栈就会溢出，同时违例控制机制根本没有机会作出响应。

若确实想在这种情况下打印出对象的地址，解决方案就是调用Object的toString方法。此时就不必加入this，只需使用super.toString()。当然，采取这种做法也有一个前提：我们必须从Object直接继承，或者没有一个父类覆盖了toString方法。

8.4.2 BitSet

BitSet实际是由“二进制位”构成的一个Vector。如果希望高效率地保存大量“开－关”信息，就应使用BitSet。它只有从尺寸的角度看才有意义；如果希望的高效率的访问，那么它的速度会比使用一些固有类型的数组慢一些。

此外，BitSet的最小长度是一个长整数（Long）的长度：64位。这意味着假如我们准备保存比这更小的数据，如8位数据，那么BitSet就显得浪费了。所以最好创建自己的类，用它容纳自己的标志位。

在一个普通的Vector中，随我们加入越来越多的元素，集合也会自我膨胀。在某种程度上，BitSet也不例外。也就是说，它有时会自行扩展，有时则不然。而且Java的1.0版本似乎在这方面做得最糟，它的BitSet表现十分差强人意（Java1.1已改正了这个问题）。下面这个例子展示了BitSet是如何运作的，同时演示了1.0版本的错误：

//: Bits.java

// Demonstration of BitSet

import java.util.*;

public class Bits {

 public static void main(String[] args) {

  Random rand = new Random();

  // Take the LSB of nextInt():

  byte bt = (byte)rand.nextInt();

  BitSet bb = new BitSet();

  for(int i = 7; i >=0; i--)

   if(((1 << i) & bt) != 0)

    bb.set(i);

   else

    bb.clear(i);

  System.out.println("byte value: " + bt);

  printBitSet(bb);

  short st = (short)rand.nextInt();

  BitSet bs = new BitSet();

  for(int i = 15; i >=0; i--)

   if(((1 << i) & st) != 0)

    bs.set(i);

   else

    bs.clear(i);

  System.out.println("short value: " + st);

  printBitSet(bs);

  int it = rand.nextInt();

  BitSet bi = new BitSet();

  for(int i = 31; i >=0; i--)

   if(((1 << i) & it) != 0)

    bi.set(i);

   else

    bi.clear(i);

  System.out.println("int value: " + it);

  printBitSet(bi);

  // Test bitsets >= 64 bits:

  BitSet b127 = new BitSet();

  b127.set(127);

  System.out.println("set bit 127: " + b127);

  BitSet b255 = new BitSet(65);

  b255.set(255);

  System.out.println("set bit 255: " + b255);

  BitSet b1023 = new BitSet(512);

// Without the following, an exception is thrown

// in the Java 1.0 implementation of BitSet:

//  b1023.set(1023);

  b1023.set(1024);

  System.out.println("set bit 1023: " + b1023);

 }

 static void printBitSet(BitSet b) {

  System.out.println("bits: " + b);

  String bbits = new String();

  for(int j = 0; j < b.size() ; j++)

   bbits += (b.get(j) ? "1" : "0");

  System.out.println("bit pattern: " + bbits);

 }

} ///:~

随机数字生成器用于创建一个随机的byte、short和int。每一个都会转换成BitSet内相应的位模型。此时一切都很正常，因为BitSet是64位的，所以它们都不会造成最终尺寸的增大。但在Java 1.0中，一旦BitSet大于64位，就会出现一些令人迷惑不解的行为。假如我们设置一个只比BitSet当前分配存储空间大出1的一个位，它能够正常地扩展。但一旦试图在更高的位置设置位，同时不先接触边界，就会得到一个恼人的违例。这正是由于BitSet在Java 1.0里不能正确扩展造成的。本例创建了一个512位的BitSet。构建器分配的存储空间是位数的两倍。所以假如设置位1024或更高的位，同时没有先设置位1023，就会在Java 1.0里得到一个违例。但幸运的是，这个问题已在Java 1.1得到了改正。所以如果是为Java 1.0写代码，请尽量避免使用BitSet。

8.4.3 Stack

Stack有时也可以称为“后入先出”（LIFO）集合。换言之，我们在堆栈里最后“压入”的东西将是以后第一个“弹出”的。和其他所有Java集合一样，我们压入和弹出的都是“对象”，所以必须对自己弹出的东西进行“造型”。

一种很少见的做法是拒绝使用Vector作为一个Stack的基本构成元素，而是从Vector里“继承”一个Stack。这样一来，它就拥有了一个Vector的所有特征及行为，另外加上一些额外的Stack行为。很难判断出设计者到底是明确想这样做，还是属于一种固有的设计。

下面是一个简单的堆栈示例，它能读入数组的每一行，同时将其作为字串压入堆栈。

//: Stacks.java

// Demonstration of Stack Class

import java.util.*;

public class Stacks {

 static String[] months = {

  "January", "February", "March", "April",

  "May", "June", "July", "August", "September",

  "October", "November", "December" };

 public static void main(String[] args) {

  Stack stk = new Stack();

  for(int i = 0; i < months.length; i++)

   stk.push(months[i] + " ");

  System.out.println("stk = " + stk);

  // Treating a stack as a Vector:

  stk.addElement("The last line");

  System.out.println(

   "element 5 = " + stk.elementAt(5));

  System.out.println("popping elements:");

  while(!stk.empty())

   System.out.println(stk.pop());

 }

} ///:~

months数组的每一行都通过push()继承进入堆栈，稍后用pop()从堆栈的顶部将其取出。要声明的一点是，Vector操作亦可针对Stack对象进行。这可能是由继承的特质决定的——Stack“属于”一种Vector。因此，能对Vector进行的操作亦可针对Stack进行，例如elementAt()方法。

8.4.4 Hashtable

Vector允许我们用一个数字从一系列对象中作出选择，所以它实际是将数字同对象关联起来了。但假如我们想根据其他标准选择一系列对象呢？堆栈就是这样的一个例子：它的选择标准是“最后压入堆栈的东西”。这种“从一系列对象中选择”的概念亦可叫作一个“映射”、“字典”或者“关联数组”。从概念上讲，它看起来象一个Vector，但却不是通过数字来查找对象，而是用另一个对象来查找它们！这通常都属于一个程序中的重要进程。

在Java中，这个概念具体反映到抽象类Dictionary身上。该类的接口是非常直观的size()告诉我们其中包含了多少元素；isEmpty()判断是否包含了元素（是则为true）；put(Object key, Object value)添加一个值（我们希望的东西），并将其同一个键关联起来（想用于搜索它的东西）；get(Object key)获得与某个键对应的值；而remove(Object Key)用于从列表中删除“键－值”对。还可以使用枚举技术：keys()产生对键的一个枚