1.类集框架 

java.util 包中包含了一些在 Java 2 中新增加的最令人兴奋的增强功能：类集。

一个类集（collection）是一组对象。类集的增加使得许多 java.util 中的成员在结构和体系结构上发生 根本的改变。它也扩展了包可以被应用的任务范围。类集是被所有 Java 程序员紧密关注的 最新型的技术。

除了类集，java.util 还包含了支持范围广泛的函数的各种各样的类和接口。这些类和接 口被核心的 Java 包广泛使用，同时当然也可以被你编写的程序所使用。对它们的应用包括 产生伪随机数，对日期和时间的操作，观测事件，对位集的操作以及标记字符串。由于 java.util 具有许多特性，因此它是 Java 中最被广泛使用的一个包。

2.类集概述

Java 的类集（Collection）框架使你的程序处理对象组的方法标准化。在 Java 2 出现之前，Java 提供了一些专门的类如 Dictionary，Vector，Stack 和 Properties 去存储和操作对象组。 尽管这些类非常有用，它们却缺少一个集中、统一的主题。因此例如说使用 Vector 的方法就会与使用 Properties 的方法不同。以前的专门的方法也没有被设计成易于扩展和能适应新的环境的形式。而类集解决了这些（以及其他的一些）问题。

2.1.设计类集的目的

类集框架被设计用于适应几个目的。

首先，这种框架是高性能的。对基本类集（动态数组，链接表，树和散列表）的实现是高效率的。一般很少需要人工去对这些“数据引擎”编写 代码（如果有的话）。

第二点，框架必须允许不同类型的类集以相同的方式和高度互操作方式工作。

第三点，类集必须是容易扩展和/或修改的。为了实现这一目标，类集框架被设计 成包含一组标准的接口。对这些接口，提供了几个标准的实现工具（例如 LinkedList，HashSet 和 TreeSet），通常就是这样使用的。如果你愿意的话，也可以实现你自己的类集。为了方 便起见，创建用于各种特殊目的的实现工具。一部分工具可以使你自己的类集实现更加容易。 最后，增加了允许将标准数组融合到类集框架中的机制。

2.2.Algorithms

算法（Algorithms）是类集机制的另一个重要部分。算法操作类集，它在 Collections 类 中被定义为静态方法。因此它们可以被所有的类集所利用。每一个类集类不必实现它自己的 方案，算法提供了一个处理类集的标准方法。

2.3.Iterator

由类集框架创建的另一项是 Iterator 接口。一个迭代程序（iterator）提供了一个多用途 的，标准化的方法，用于每次访问类集的一个元素。因此迭代程序提供了一种枚举类集内容

（enumerating the contents of a collection）的方法。因为每一个类集都实现 Iterator，所以通 过由 Iterator 定义的方法，任一类集类的元素都能被访问到。

除了类集之外，框架定义了几个映射接口和类。映射（Maps）存储键/值对。尽管映射 在对项的正确使用上不是“类集”，但它们完全用类集集成。在类集框架的语言中，可以获得 映射的类集“视图”（collection-view）。这个“视图”包含了从存储在类集中的映射得到的元素。 因此，如果选择了一个映射，就可以将其当做一个类集来处理。

对于由 java.util 定义的原始类，类集机制被更新以便它们也能够集成到新的系统里。所 以理解下面的说法是很重要的：尽管类集的增加改变了许多原始工具类的结构，但它却不会 导致被抛弃。类集仅仅是提供了处理事情的一个更好的方法。

最后的一点：如果你对 C++比较熟悉的话，那么你可以发现 Java 的类集技术与在 C++中 定义的标准模板库（STL）相似。在 C++中叫做容器（container），而在 Java 中叫做类集。

3 复合框架中的接口

所谓框架就是一个类库的集合。集合框架就是一个用来表示和操作集合的统一的架构， 包含了实现集合的接口与类。

除了类集接口之外，类集也使用 Comparator，Iterator 和 ListIterator 接口。简单地说， Comparator 接口定义了两个对象如何比较；Iterator 和 ListIterator 接口枚举类集中的对象。 为了在它们的使用中提供最大的灵活性，类集接口允许对一些方法进行选择。可选择的 方法使得使用者可以更改类集的内容。支持这些方法的类集被称为可修改的（modifiable）。 不允许修改其内容的类集被称为不可修改的（unmodifiable）。如果对一个不可修改的类集 使用这些方法，将引发一个 UnsupportedOperationException 异常。所有内置的类集都是可修改的。

Collection 接口是构造类集框架的基础。它声明所有类集都将拥有的核心方法。因为所 有类集实现 Collection，所以熟悉它的方法对于清楚地理解框架是必要的。其中几种方法可 能会引发一个 UnsupportedOperationException 异常。正如上面解释的那样，这些发生在当类 集不能被修改时。当一个对象与另一个对象不兼容，例如当企图增加一个不兼容的对象到一个类集中时。将产生一个 ClassCastException 异常。调用 add()方法可以将对象加入类集。注 意 add()带一个 Object 类型的参数。因为 Object 是所有类的超类，所以任何类型的对象可以 被存储在一个类集中。然而原始类型不行。例如，一个类集不能直接存储类型 int，char， double 等的值。当然如果想存储这些对象，也可以使用原始类型包装器。可以通过调用 addAll() 方法将一个类集的全部内容增加到另一个类集中。可以通过调用 remove()方法将一个对象删 除。为了删除一组对象，可以调用 removeAll()方法。调用 retainAll()方法可以将除了一组指 定的元素之外的所有元素删除。为了清空类集，可以调用 clear()方法。通过调用 contains() 方法，可以确定一个类集是否包含了一个指定的对象。为了确定一个类集是否包含了另一个 类集的全部元素，可以调用 containsAll()方法当一个类集是空的时候，可以通过调用 isEmpty() 方法来予以确认。调用 size()方法可以获得类集中当前元素的个数。toArray()方法返回一个数 组，这个数组包含了存储在调用类集中的元素。通过在类集和数组之间提供一条路径，可以 充分利用这两者的优点。一个更加重要的方法是 iterator()，该方法对类集返回一个迭代程序。 当使用一个类集框架时，迭代程序对于成功的编程来说是至关重要的。

Collection：集合层次中的根接口，JDK 没有提供这个接口直接的实现类。

Set：不能包含重复的元素。

SortedSet 是一个按照升序排列元素的 Set。

List：是一个有序的集合，可以包含重复的元素。提供了按索引访问的方式。

Map：包含了 key-value 对。Map 不能包含重复的 key。

SortedMap 是一个按照升序排列 key 的 Map。

4.List

List 接口扩展了 Collection 并声明存储一系列元素的类集的特性。使用一个基于零的下 标，元素可以通过它们在列表中的位置被插入和访问。一个列表可以包含重复元素。除了由 Collection 定义的方法之外，List 还定义了一些它自己的方法。再次注意当类集不能被修改时，

其中的几种方法引发 UnsupportedOperationException 异常。当一个对象与另一个不兼容，例 如当企图将一个不兼容的对象加入一个类集中时，将产生 ClassCastException 异常。对于由 Collection 定义的 add()和 addAll()方法，List 增加了方法 add(int, Object)和 addAll(int, Collection)。 这些方法在指定的下标处插入元素。由 Collection 定义的 add(Object)和 addAll(Collection)的 语义也被 List 改变了，以便它们在列表的尾部增加元素。为了获得在指定位置存储的对象， 可以用对象的下标调用 get()方法。为了给类表中的一个元素赋值，可以调用 set()方法，指 定被改变的对象的下标。调用 indexOf()或 lastIndexOf()可以得到一个对象的下标。通过调用 subList()方法，可以获得列表的一个指定了开始下标和结束下标的子列表。subList()方法使得 列表处理十分方便。

5.Set

集合接口定义了一个集合。它扩展了 Collection 并说明了不允许复制元素的类集的特性。 因此，如果试图将复制元素加到集合中时，add()方法将返回 false。它本身并没有定义任何 附加的方法。

6.ShortSet

SortedSet 接口扩展了 Set 并说明了按升序排列的集合的特性。当没有项包含在调用集合 中时，其中的几种方法引发 NoSuchElementException 异常。当对象与调用集合中的元素不兼 容时，引发 ClassCastException 异常。如果试图使用 null 对象，而集合不允许 null 时，引发 NullPointerException 异常。

SortedSet 定义了几种方法，使得对集合的处理更加方便。调用 first()方法，可以获得集 合中的第一个对象。调用 last()方法，可以获得集合中的最后一个元素。调用 subSet()方法，

可以获得排序集合的一个指定了第一个和最后一个对象的子集合。如果需要得到从集合的第 一个元素开始的一个子集合，可以使用 headSet()方法。如果需要获得集合尾部的一个子集

合，可以使用 tailSet()方法。

现在，你已经熟悉了类集接口，下面开始讨论实现它们的标准类。一些类提供了完整的 可以被使用的工具。另一些类是抽象的，提供主框架工具，作为创建具体类集的起始点。

7.ArrayList

ArrayList：我们可以将其看作是能够自动增长容量的数组。利用 ArrayList 的 toArray()返 回一个数组。Arrays.asList()返回一个列表。迭代器(Iterator) 给我们提供了一种通用的方式来 访问集合中的元素。

ArrayList 类扩展 AbstractList 并实现了 List 接口。ArrayList 支持可随需要而增长的动态数 组。在 Java 中，标准数组是定长的。在数组创建之后，它们不能被加长或缩短，这也就意

味着你必须事先知道数组可以容纳多少元素。但是，你直到运行时才能知道需要多大的数组。

为了解决这个问题，类集框架定义了 ArrayList。本质上，ArrayList 是对象引用的一个变长数 组。也就是说，ArrayList 能够动态地增加或减小其大小。数组列表以一个原始大小被创建。 当超过了它的大小，类集自动增大。当对象被删除后，数组就可以缩小。

•ArrayList 有如下的构造函数

–ArrayList( )

–ArrayList(Collection c)

–ArrayList(int capacity)

–第一个构造函数建立一个空的数组列表。

–第二个构造函数建立一个数组列表，该数组列表由类集 c 中的元素初始化。

–第三个构造函数建立一个数组列表，该数组有指定的初始容量（capacity）。容量是用于存

储元素的基本数组的大小。当元素被追加到数组列表上时，容量会自动增加。 使用由 toString()方法提供的默认的转换显示类集的内容，toString()方法是从

AbstractCollection 继承下来的。尽管它对简短的例子程序来说是足够了，然而很少使用这种 方法去显示实际中的类集的内容。通常编程者会提供自己的输出程序。

尽管当对象被存储在 ArrayList 对象中时，其容量会自动增加。仍可以通过调用

ensureCapacity()方法来人工地增加 ArrayList 的容量。如果事先知道将在当前能够容纳的类集 中存储许许多多的项时，你可能会想这样做。在开始时，通过一次性地增加它的容量，就能

避免后面的再分配。因为再分配是很花时间的，避免不必要的处理可以改善性能。

•ensureCapacity()方法如下所示：

–void ensureCapacity(int cap)

–这里，cap 是新的容量

相反地，如果想要减小在 ArrayList 对象之下的数组的大小，以便它有正好容纳当前项的大 小，可以调用 trimToSize()方法。该方法如下：

–void trimToSize()

当使用 ArrayList 时，有时想要获得一个实际的数组，这个数组包含了列表的内容。可 以通过调用方法 toArray()来实现它。下面是几个为什么可能想将类集转换成为数组的原因， a.对于特定的操作，可以获得更快的处理时间，b.为了给方法传递数组，而方法不必重载去 接收类集，c.为了将新的基于类集的程序与不认识类集的老程序集成。

Arrays.asList()，返回一个受指定数组支持的固定大小的列表。（对返回列表的更改会“直 写”到数组。）此方法同 Collection.toArray 一起，充当了基于数组的 API 与基于 collection 的

API 之间的桥梁。

8.LinkedList

LinkedList 类扩展 AbstractSequentialList 并执行 List 接口。它提供了一个链接列表数据结

构。

它具有如下的两个构造函数，说明如下：

–LinkedList( )

–LinkedList(Collection c)

–第一个构造函数建立一个空的链接列表。

–第二个构造函数建立一个链接列表，该链接列表由类集 c 中的元素初始化 除了它继承的方法之外，LinkedList 类本身还定义了一些有用的方法，这些方法主要用

于操作和访问列表。使用 addFirst()方法可以在列表头增加元素；使用 addLast()方法可以在 列表的尾部增加元素。

它们的形式如下所示：

–void addFirst(Object obj)

–void addLast(Object obj)

–这里，obj 是被增加的项

调用 getFirst()方法可以获得第一个元素。调用 getLast()方法可以得到最后一个元素。

它们的形式如下所示：

–Object getFirst( )

–Object getLast( )

为了删除第一个元素，可以使用 removeFirst()方法；为了删除最后一个元素，可以调用

removeLast()方法。

它们的形式如下所示：

–Object removeFirst( )

–Object removeLast( )

因为 LinkedList 实现 List 接口，调用 add(Object)将项目追加到列表的尾部，如同 addLast() 方法所做的那样。使用 add()方法的 add(int, Object)形式，插入项目到指定的位置，如例子程 序中调用 add（1，“A2”）的举例。注意如何通过调用 get()和 set()方法而使得 LinkedList 中的 第三个元素发生了改变。为了获得一个元素的当前值，通过 get()方法传递存储该元素的下 标值。为了对这个下标位置赋一个新值，通过 set()方法传递下标和对应的新值。

LinkedList 是采用双向循环链表实现的。

利用 LinkedList 实现栈(stack)、队列(queue)、双向队列(double-ended queue )。

9.Date Structure

一般将数据结构分为两大类：线性数据结构和非线性数据结构。线性数据结构有线性表、 栈、队列、串、数组和文件；非线性数据结构有树和图。

9.1.linear list

线性表的逻辑结构是 n 个数据元素的有限序列:(a1, a2,a3,…an)，n 为线性表的长度(n≥

0)，n=0 的表称为空表。 数据元素呈线性关系。必存在唯一的称为“第一个”的数据元素；必存在唯一的称为“最

后一个”的数据元素；除第一个元素外，每个元素都有且只有一个前驱元素；除最后一个元 素外，每个元素都有且只有一个后继元素。所有数据元素在同一个线性表中必须是相同的数 据类型。

线性表按其存储结构可分为顺序表和链表。用顺序存储结构存储的线性表称为顺序表； 用链式存储结构存储的线性表称为链表。

将线性表中的数据元素依次存放在某个存储区域中,所形成的表称为顺序表。一维数组

就是用顺序方式存储的线性表。

9.2.linked list

9.3.Stack

栈(Stack)也是一种特殊的线性表，是一种后进先出(LIFO: last in first out)的结构。栈是限 定仅在表尾进行插入和删除运算的线性表，表尾称为栈顶(top)，表头称为栈底(bottom)。栈 的物理存储可以用顺序存储结构，也可以用链式存储结构。

9.4Queue

队列(Queue)是限定所有的插入只能在表的一端进行，而所有的删除都在表的另一端进 行的线性表。表中允许插入的一端称为队尾(Rear)，允许删除的一端称为队头(Front)。队列 的操作是按先进先出(FIFO:first in first out)的原则进行的。队列的物理存储可以用顺序存储结 构，也可以用链式存储结构。

10.ArrayList VS LinkedList

ArrayList 底层采用数组完成，而 LinkedList 则是以一般的双向链表(double-linked list)完成，

其内每个对象除了数据本身外，还有两个引用，分别指向前一个元素和后一个元素。如果我

们经常在 List 的开始处增加元素，或者在 List 中进行插入和删除操作，我们应该使用 LinkedList ， 否则的话，使用 ArrayList 将更加快速。

11.HashSet

HashSet 扩展 AbstractSet 并且实现 Set 接口。它创建一个类集，该类集使用散列表进行 存储。散列表通过使用称之为散列法的机制来存储信息。在散列（hashing）中，一个关键 字的信息内容被用来确定唯一的一个值，称为散列码（hash code）。而散列码被用来当做 与关键字相连的数据的存储下标。关键字到其散列码的转换是自动执行的——你看不到散列 码本身。你的程序代码也不能直接索引散列表。散列法的优点在于即使对于大的集合，它允 许一些基本操作如 add()，contains()，remove()和 size()方法的运行时间保持不变。

NOTE:

•散列表又称为哈希表。散列表算法的基本思想是： 以结点的关键字为自变量，通过一定的函数关系（散列函数）计算出对应的函数值，以这个

值作为该结点存储在散列表中的地址。

•当散列表中的元素存放太满，就必须进行再散列，将产生一个新的散列表，所有元素存放 到新的散列表中，原先的散列表将被删除。在 Java 语言中，通过负载因子(load factor)来决 定何时对散列表进行再散列。例如：如果负载因子是 0.75，当散列表中已经有 75%的位置已 经放满，那么将进行再散列。

•负载因子越高(越接近 1.0)，内存的使用效率越高，元素的寻找时间越长。负载因子越低(越 接近 0.0)，元素的寻找时间越短，内存浪费越多。

•HashSet 类的缺省负载因子是 0.75。

•下面的构造函数定义为：

–HashSet( )

–HashSet(Collection c)

–HashSet(int capacity)

–HashSet(int capacity, float fillRatio)

•第一种形式构造一个默认的散列集合。

•第二种形式用 c 中的元素初始化散列集合。

•第三种形式用 capacity 初始化散列集合的容量。

•第四种形式用它的参数初始化散列集合的容量和填充比（也称为加载容量）。填充比必须 介于 0.0 与 1.0 之间，它决定在散列集合向上调整大小之前，有多少能被充满。具体的说， 就是当元素的个数大于散列集合容量乘以它的填充比时，散列集合被扩大。对于没有获得填

充比的构造函数，默认使用 0.75。

HashSet 没有定义更多的其他方法。 重要的是，注意散列集合并没有确保其元素的顺序，因为散列法的处理通常不让自己参

与创建排序集合。如果需要排序存储，另一种类集—— TreeSet 将是一个更好的选择。

12.TreeSet

TreeSet 为使用树来进行存储的 Set 接口提供了一个工具，对象按升序存储。访问和检 索是很快的。在存储了大量的需要进行快速检索的排序信息的情况下，TreeSet 是一个很好 的选择。

•下面的构造函数定义为：

–TreeSet( )

–TreeSet(Collection c)

–TreeSet(Comparator comp)

–TreeSet(SortedSet ss)

•第一种形式构造一个空的树集合，该树集合将根据其元素的自然顺序按升序排序。

•第二种形式构造一个包含了 c 的元素的树集合。

•第三种形式构造一个空的树集合，它按照由 comp 指定的比较函数进行排序（比较函数将 在后面介绍）。

•第四种形式构造一个包含了 ss 的元素的树集合。

13.Access Collection by Iterator method

通常希望循环通过类集中的元素。例如，可能会希望显示每一个元素。到目前为止，处 理这个问题的最简单方法是使用 iterator，iterator 是一个或者实现 Iterator 或者实现 ListIterator 接口的对象。Iterator 可以完成循环通过类集，从而获得或删除元素。ListIterator 扩展 Iterator，允许双向遍历列表，并可以修改单元

在通过迭代函数访问类集之前，必须得到一个迭代函数。每一个 Collection 类都提供一 个 iterator()函数，该函数返回一个对类集头的迭代函数。通过使用这个迭代函数对象，可以

访问类集中的每一个元素，一次一个元素。通常，使用迭代函数循环通过类集的内容，步骤 如下：

–1. 通过调用类集的 iterator( )方法获得对类集头的迭代函数。

–2. 建立一个调用 hasNext( )方法的循环，只要 hasNext( )返回 true，就进行循环迭代。

–3. 在循环内部，通过调用 next( )方法来得到每一个元素。

对于执行 List 的类集，也可以通过调用 ListIterator 来获得迭代函数。正如上面解释的那 样，列表迭代函数提供了前向或后向访问类集的能力，并可让你修改元素。否则，ListIterator 如同 Iterator 功能一样。

Iterator 和 ListIterator。它使用 ArrayList 对象，但是总的原则适用于任何类型的类集。 当然，ListIterator 只适用于那些实现 List 接口的类集。

为了简单，前面的例子在类集中存储内置的对象，如 String 或 Integer。当然，类集并没 有被限制为只能存储内置的对象。完全相反的是，类集的能力是它能存储任何类型的对象，

包括你所创建的类的对象。

14.Map

除了类集，Java 2 还在 java.util 中增加了映射。映射（map）是一个存储关键字和值的 关联或者说是关键字/值对的对象。给定一个关键字，可以得到它的值。关键字和值都是对 象。关键字必须是唯一的。但值是可以重复的。有些映射可以接收 null 关键字和 null 值。而 有的则不行。

Map 接口映射唯一关键字到值。关键字（key）是以后用于检索值的对象。给定一个关 键字和一个值，可以存储这个值到一个 Map 对象中。当这个值被存储以后，就可以使用它 的关键字来检索它。当调用的映射中没有项存在时，其中的几种方法会引发一个 NoSuchElementException 异常。而当对象与映射中的元素不兼容时，引发一个 ClassCastException 异常。如果试图使用映射不允许使用的 null 对象时，则引发一个 NullPointerException 异常。当试图改变一个不允许修改的映射时，则引发一个 UnsupportedOperationException 异常。

映射循环使用两个基本操作：get()和 put()。使用 put()方法可以将一个指定了关键字和 值的值加入映射。为了得到值，可以通过将关键字作为参数来调用 get()方法。调用返回该

值。

映射不是类集，但可以获得映射的类集“视图”。为了实现这种功能，可以使用 entrySet() 方法，它返回一个包含了映射中元素的集合（Set）。为了得到关键字的类集“视图”，可以 使用 keySet()方法。为了得到值的类集“视图”，可以使用 values()方法。类集“视图”是将映射 集成到类集框架内的手段。

15.ShortMap

SortedMap 接口扩展了 Map，它确保了各项按关键字升序排序。当调用映射中没有的项 时，其中的几种方法引发一个 NoSuchElementException 异常。当对象与映射中的元素不兼容 时，则引发一个 ClassCastException 异常。当试图使用映射不允许使用的 null 对象时，则引 发一个 NullPointerException 异常。

排序映射允许对子映射（换句话说，就是映射的子集）进行高效的处理。使用 headMap()，

tailMap()或 subMap()方法可以获得子映射。调用 firstKey()方法可以获得集合的第一个关键字。 而调用 lastKey()方法可以获得集合的最后一个关键字。

16.Map.Entry

Map.Entry 接口使得可以操作映射的输入。回想由 Map 接口说明的 entrySet()方法，调 用该方法返回一个包含映射输入的集合（Set）。这些集合元素的每一个都是一个 Map.Entry 对象。

17.HashMap

HashMap 类使用散列表实现 Map 接口。这允许一些基本操作如 get()和 put()的运行时间 保持恒定，即便对大型集合，也是这样的。

•下面的构造函数定义为：

–HashMap( )

–HashMap(Map m)

–HashMap(int capacity)

–HashMap(int capacity, float fillRatio)

•第一种形式构造一个默认的散列映射。

•第二种形式用 m 的元素初始化散列映射。

•第三种形式将散列映射的容量初始化为 capacity。

•第四种形式用它的参数同时初始化散列映射的容量和填充比。容量和填充比的含义与前面 介绍的 HashSet 中的容量和填充比相同。

HashMap 实现 Map 并扩展 AbstractMap。它本身并没有增加任何新的方法。应该注意的 是散列映射并不保证它的元素的顺序。因此，元素加入散列映射的顺序并不一定是它们被迭 代函数读出的顺序。映射的内容通过使用由调用函数 entrySet()而获得的集合“视图”而显示

出来。关键字和值通过调用由 Map.Entry 定义的 getKey()和 getValue()方法而显示。。put()

方法自动用新值替换与指定关键字相关联的原先的值。

18.TreeMap

TreeMap 类通过使用树实现 Map 接口。TreeMap 提供了按排序顺序存储关键字/值对的 有效手段，同时允许快速检索。应该注意的是，不像散列映射，树映射保证它的元素按照关 键字升序排序。

•下面的 TreeMap 构造函数定义为：

–TreeMap( )

–TreeMap(Comparator comp)

–TreeMap(Map m)

–TreeMap(SortedMap sm)

•第一种形式构造一个空树的映射，该映射使用其关键字的自然顺序来排序。

•第二种形式构造一个空的基于树的映射，该映射通过使用 Comparator comp 来排序（比较 函数 Comparators 将在后面进行讨论）。

•第三种形式用从 m 的输入初始化树映射，该映射使用关键字的自然顺序来排序。

•第四种形式用从 sm 的输入来初始化一个树映射，该映射将按与 sm 相同的顺序来排序

TreeMap 实现 SortedMap 并且扩展 AbstractMap。而它本身并没有另外定义其他方法。

19.比较函数

TreeSet 和 TreeMap 都按排序顺序存储元素。然而，精确定义采用何种“排序顺序”的是 比较函数。通常在默认的情况下，这些类通过使用被 Java 称之为“自然顺序”的顺序存储它 们的元素，而这种顺序通常也是你所需要的（A 在 B 的前面，1 在 2 的前面，等等）。如果

需要用不同的方法对元素进行排序，可以在构造集合或映射时，指定一个 Comparator 对象。 这样做为你提供了一种精确控制如何将元素储存到排序类集和映射中的能力。

Comparator 接口定义了两个方法：compare( )和 equals( )。这里给出的 compare( )方法按 顺序比较了两个元素：int compare(Object obj1, Object obj2)，obj1 和 obj2 是被比较的两个对 象。当两个对象相等时，该方法返回 0；当 obj1 大于 obj2 时，返回一个正值；否则，返回

一个负值。如果用于比较的对象的类型不兼容的话，该方法引发一个 ClassCastException 异 常。通过覆盖 compare()，可以改变对象排序的方式。例如，通过创建一个颠倒比较输出的

比较函数，可以实现按逆向排序。这里给出的 equals( )方法，测试一个对象是否与调用比较

函数相等：boolean equals(Object obj)，obj 是被用来进行相等测试的对象。如果 obj 和调用 对象都是 Comparator 的对象并且使用相同的排序。该方法返回 true。否则返回 false。重写 equals( )方法是没有必要的，大多数简单的比较函数都不这样做。

20.类集算法

类集框架定义了几种能用于类集和映射的算法。在 Collections 类中，这些算法被定义为 静态方法。当试图比较不兼容的类型时，其中的一些算法引发一个 ClassCastException 异常； 而当试图改变一个不可改变的类集时，则引发一个 UnsupportedOperationException 异常。注 意其中的几种方法，如 synchronizedList()和 synchronizedSet()被用来获得各种类集的同步（安 全线程）拷贝。没有任何一个标准类集实现是同步的。必须使用同步算法来为其提供同步。 另一种观点：同步类集的迭代函数必须在 synchronized 块内使用。以 unmodifiable 开头的一 组方法返回不能被改变的各种类集“视图”。这些方法当将一些进程对类集设为只读形式时很 有用的 Collections 定义了三个静态变量：EMPTY_SET，EMPTY_LIST 和 EMPTY_MAP。它们都 是不可改变的。EMPTY_MAP 是在 Java 2 的 1.3 版中新增加的。注意 min()和 max()方法是在 列表被混淆之后，对其进行操作的。两者在运行时，都不需要排序的列表。

21.Arrays

Java 2 在 java.util 中新增加了一个叫做 Arrays 的类。这个类提供了各种在进行数组运算 时很有用的方法。尽管这些方法在技术上不属于类集框架，但它们提供了跨越类集和数组的 桥梁。在这一节中，分析由 Arrays 定义的每一种方法。asList()方法返回一个被指定数组支持 的 List。换句话说，列表和数组访问的是同一个单元。它具有如下的形式：

–static List asList(Object[ ] array)

–这里 array 是包含了数据的数组

binarySearch()方法使用二分法搜索寻找指定的值。该方法必须应用于排序数组。它具有 如下的形式：

–static intbinarySearch(byte[ ] array, byte value)

–static intbinarySearch(char[ ] array, char value)

–static intbinarySearch(double[ ] array, double value)

–static intbinarySearch(float[ ] array, float value)

–static intbinarySearch(int[ ] array, intvalue)

–static intbinarySearch(long[ ] array, long value)

–static intbinarySearch(short[ ] array, short value)

–static intbinarySearch(Object[ ] array, Object value)

–static intbinarySearch(Object[ ] array, Object value, Comparator c)

这里，array 是被搜索的数组，而 value 是被查找的值。当 array 中包含的元素是不可比 较的（例如 Double 和 StringBuffer）或者当 value 与 array 中的类型不兼容时，后两种形式引 发一个 ClassCastException 异常。在最后一种形式中，比较函数（Comparator）c 用于确定 array 中的元素的顺序。在所有的形式中，如果 array 中含有 value，则返回该元素的下标。否则， 返回一个负值。

22.以前版本遗留下来的类和接口

java.util 的最初版本中不包括类集框架。取而代之，它定义了几个类和接口提供专门的 方法用于存储对象。随着在 Java 2 中引入类集，有几种最初的类被重新设计成支持类集接口。 因此它们与框架完全兼容。尽管实际上没有类被摈弃，但其中某些仍被认为是过时的。当然， 在那些重复从以前版本遗留下来的类的功能性的地方，通常都愿意用类集编写新的代码程序。 一般地，对从以前版本遗留下来的类的支持是因为仍然存在大量使用它们的基本代码。包括 现在仍在被 Java 2 的应用编程接口（API）使用的程序。另一点，没有一个类集类是同步的。 但是所有的从以前版本遗留下来的类都是同步的。这一区别在有些情况下是很重要的。当然， 通过使用由 Collections 提供的算法也很容易实现类集同步。

22.1.Enumeration

Enumeration 接口定义了可以对一个对象的类集中的元素进行枚举（一次获得一个）的 方法。这个接口尽管没有被摈弃，但已经被 Iterator 所替代。Enumeration 对新程序来说是 过时的。然而它仍被几种从以前版本遗留下来的类（例如 Vector 和 Properties）所定义的方 法使用，被几种其他的 API 类所使用以及被目前广泛使用的应用程序所使用。

•Enumeration 指定下面的两个方法：

–boolean hasMoreElements( )

–Object nextElement( )

–执行后，当仍有更多的元素可提取时，hasMoreElements()方法一定返回 true。当所有元素 都被枚举了，则返回 false。nextElement()方法将枚举中的下一个对象做为一个类属 Object

的引用而返回。也就是每次调用 nextElement()方法获得枚举中的下一个对象。调用例程必须

将那个对象转换为包含在枚举内的对象类型

22.2.Vector

Vector 实现动态数组。这与 ArrayList 相似，但两者不同的是：Vector 是同步的，并且它 包含了许多不属于类集框架的从以前版本遗留下来的方法。随着 Java 2 的公布，Vector 被重 新设计来扩展 AbstractList 和实现 List 接口，因此现在它与类集是完全兼容的

•这里是 Vector 的构造函数：

–Vector( )

–Vector(int size)

–Vector(int size, int incr)

–Vector(Collection c)

•第一种形式创建一个原始大小为 10 的默认矢量。

•第二种形式创建一个其原始容量由 size 指定的矢量。

•第三种形式创建一个其原始容量由 size 指定，并且它的增量由 incr 指定的矢量。增量指定 了矢量每次允许向上改变大小的元素的个数。

•第四种形式创建一个包含了类集 c 中元素的矢量。这个构造函数是在 Java 2 中新增加的。

所有的矢量开始都有一个原始的容量。在这个原始容量达到以后，下一次再试图向矢量 中存储对象时，矢量自动为那个对象分配空间同时为别的对象增加额外的空间。通过分配超

过需要的内存，矢量减小了可能产生的分配的次数。这种次数的减少是很重要的，因为分配 内存是很花时间的。在每次再分配中，分配的额外空间的总数由在创建矢量时指定的增量来 确定。如果没有指定增量，在每个分配周期，矢量的大小增一倍。

•Vector 定义了下面的保护数据成员：

–int capacityIncrement;

–int elementCount;

–Object elementData[ ];

–增量值被存储在 capacityIncrement 中。矢量中的当前元素的个数被存储在 elementCount

中。保存矢量的数组被存储在 elementData 中。

因为 Vector 实现 List，所以可以像使用 ArrayList 的一个实例那样使用矢量。也可以使用 它的从以前版本遗留下来的方法来操作它。例如，在后面实例化 Vector，可以通过调用 addElement()方法而为其增加一个元素。调用 elementAt()方法可以获得指定位置处的元素。 调用 firstElement()方法可以得到矢量的第一个元素。调用 lastElement()方法可以检索到矢量 的最后一个元素。使用 indexOf()和 lastIndexOf()方法可以获得元素的下标。调用 removeElement()或 removeElementAt()方法可以删除元素。

随着 Java 2 的公布，Vector 增加了对迭代函数的支持。现在可以使用迭代函数来替代枚 举去遍历对象。例如，下面的基于迭代函数的程序代码：

// use an iterator to display contentsIterator vItr = v.iterator();System.out.println(" \nElements in vector:");while(vItr.hasNext()) System.out.print(vItr.next() + " ");System.out.println();

因为建议不要使编写枚举新的程序代码，所以通常可以使用迭代函数来对矢量的内容进

行枚举。当然，业已存在的大量的老程序采用了枚举。不过幸运的是，枚举和迭代函数的工 作方式几乎相同。

22.3.Stack

Stack 是 Vector 的一个子类，它实现标准的后进先出堆栈。Stack 仅仅定义了创建空堆栈 的默认构造函数。Stack 包括了由 Vector 定义的所有方法，同时增加了几种它自己定义的方 法。

22.4.Dictionary

字典（Dictionary）是一个表示关键字/值存储库的抽象类，同时它的操作也很像映射

（Map）。给定一个关键字和值，可以将值存储到字典（Dictionary）对象中。一旦这个值被 存储了，就能够用它的关键字来检索它。因此，与映射一样，字典可以被当做关键字/值对

列表来考虑。尽管在 Java 2 中并没有摈弃字典（Dictionary），由于它被映射（Map）所取代， 从而被认为是过时的。然而由于目前 Dictionary 被广泛地使用，因此这里仍对它进行详细的

讨论。

22.5.HashTable

散列表（Hashtable）是原始 java.util 中的一部分同时也是 Dictionary 的一个具体实现。 然而，Java2 重新设计了散列表（Hashtable）以便它也能实现映射（Map）接口。因此现在 Hashtable 也被集成到类集框架中。它与 HashMap 相似，但它是同步的。和 HashMap 一样， Hashtable 将关键字/值对存储到散列表中。使用 Hashtable 时，指定一个对象作为关键字，

同时指定与该关键字相关联的值。接着该关键字被散列，而把得到的散列值作为存储在表中 的值的下标。

散列表仅仅可以存储重载由 Object 定义的 hashCode()和 equals()方法的对象。hashCode() 方法计算和返回对象的散列码。当然，equals()方法比较两个对象。幸运的是，许多 Java 内 置的类已经实现了 hashCode()方法。例如，大多数常见的 Hashtable 类型使用字符串（String）

对象作为关键字。String 实现 hashCode()和 equals()方法。

•Hashtable 的构造函数如下所示：

–Hashtable( )

–Hashtable(int size)

–Hashtable(int size, float fillRatio)

–Hashtable(Map m)

•第一种形式是默认的构造函数。

•第二种形式创建一个散列表，该散列表具有由 size 指定的原始大小。

•第三种形式创建一个散列表，该散列表具有由 size 指定的原始大小和由 fillRatio 指定的填 充比。填充比必须介于 0.0 和 1.0 之间，它决定了在散列表向上调整大小之前散列表的充满 度。具体地说，当元素的个数大于散列表的容量乘以它的填充比时，散列表被扩展。如果没

有指定填充比，默认使用 0.75。最后，

•第四种形式创建一个散列表，该散列表用 m 中的元素初始化。散列表的容量被设为 m 中 元素的个数的两倍。默认的填充因子设为 0.75。第四种构造函数是在 Java 2 中新增加的。

重要的一点是：和映射类一样，Hashtable 不直接支持迭代函数。因此，上面的程序使 用枚举来显示 balance 的内容。然而，我们可以获得允许使用迭代函数的散列表的集合视图。 为了实现它，可以简单地使用由 Map 定义的一个类集“视图”方法，如 entrySet()或 keySet() 方法。例如，可以获得关键字的一个集合“视图”，并遍历这些关键字。

22.6.Properties

属性（Properties）是 Hashtable 的一个子类。它用来保持值的列表，在其中关键字和值 都是字符串（String）。Properties 类被许多其他的 Java 类所使用。例如，当获得系统环境 值时，System.getProperties()返回对象的类型。

Properties 类的一个有用的功能是可以指定一个默认属性，如果没有值与特定的关键字 相关联，则返回这个默认属性。例如，默认值可以与关键字一起在 getProperty()方法中被指

定——如 getProperty(“name”，“default value”)。如果“name”值没有找到，则返回“default value”。

当构造一个 Properties 对象时，可以传递 Properties 的另一个实例做为新实例的默认值。在

这种情况下，如果对一个给定的 Properties 对象调用 getProperty(“foo”)，而“foo”并不存在时， Java 在默认 Properties 对象中寻找“foo”。它允许默认属性的任意层嵌套。Properties 的一个 最有用的方面是可以利用 store()和 load()方法方便地对包含在属性（Properties）对象中的信 息进行存储或从盘中装入信息。在任何时候，都可以将一个属性（Properties）对象写入流 或从中将其读出。这使得属性列表特别方便实现简单的数据库。

类集总结

类集框架为程序员提供了一个功能强大的设计方案以解决编程过程中面临的大多数任 务。下一次当你需要存储和检索信息时，可考虑使用类集。

集合框架在我们今后的程序中将会被大量使用。