黑马程序员_java类集框架

------- android培训 、 java培训 、期待与您交流！ ----------

类集框架可以使程序处理数组对象的方法标准化，类集框架拥

有的几个特性：
1.这种框架是高性能的
2.框架允许不同类型的类集以相同方式和高度互操作方式工作
3.类集必须是容易扩展和修改的
关于Collection：
public interface Collection<E>extends Iterable<E>
Collection 层次结构 中的根接口。Collection 表示一组对象

，这些对象也称为 collection 的元素。一些 collection 允

许有重复的元素，而另一些则不允许。一些 collection 是有

序的，而另一些则是无序的。JDK 不提供此接口的任何直接 实

现：它提供更具体的子接口（如 Set 和 List）实现。此接口

通常用来传递 collection，并在需要最大普遍性的地方操作这

些 collection。

包 (bag) 或多集合 (multiset)（可能包含重复元素的无序

collection）应该直接实现此接口。

所有通用的 Collection 实现类（通常通过它的一个子接口间

接实现 Collection）应该提供两个“标准”构造方法：一个是

void（无参数）构造方法，用于创建空 collection；另一个是

带有 Collection 类型单参数的构造方法，用于创建一个具有

与其参数相同元素新的 collection。实际上，后者允许用户复

制任何 collection，以生成所需实现类型的一个等效

collection。尽管无法强制执行此约定（因为接口不能包含构

造方法），但是 Java 平台库中所有通用的 Collection 实现

都遵从它。

此接口中包含的“破坏性”方法，是指可修改其所操作的

collection 的那些方法，如果此 collection 不支持该操作，

则指定这些方法抛出 UnsupportedOperationException。如果

是这样，那么在调用对该 collection 无效时，这些方法可能

，但并不一定抛出 UnsupportedOperationException。例如，

如果要添加的 collection 为空且不可修改，则对该

collection 调用 addAll(Collection) 方法时，可能但并不一

定抛出异常。

一些 collection 实现对它们可能包含的元素有所限制。例如

，某些实现禁止 null 元素，而某些实现则对元素的类型有限

制。试图添加不合格的元素将抛出一个未经检查的异常，通常

是 NullPointerException 或 ClassCastException。试图查询

是否存在不合格的元素可能抛出一个异常，或者只是简单地返

回 false；某些实现将表现出前一种行为，而某些实现则表现

后一种。较为常见的是，试图对某个不合格的元素执行操作且

该操作的完成不会导致将不合格的元素插入 collection 中，

将可能抛出一个异常，也可能操作成功，这取决于实现本身。

这样的异常在此接口的规范中标记为“可选”。

由每个 collection 来确定其自身的同步策略。在没有实现的

强烈保证的情况下，调用由另一进程正在更改的 collection

的方法可能会出现不确定行为；这包括直接调用，将

collection 传递给可能执行调用的方法，以及使用现有迭代器

检查 collection。

Collections Framework 接口中的很多方法是根据 equals 方

法定义的。例如，contains(Object o) 方法的规范声明：“当

且仅当此 collection 包含至少一个满足 (o==null ? e==null

:o.equals(e)) 的元素 e 时，返回 true。”不 应将此规范理

解为它暗指调用具有非空参数 o 的 Collection.contains 方

法会导致为任意的 e 元素调用 o.equals(e) 方法。可随意对

各种实现执行优化，只要避免调用 equals 即可，例如，通过

首先比较两个元素的哈希码。（Object.hashCode() 规范保证

哈希码不相等的两个对象不会相等）。较为常见的是，各种

Collections Framework 接口的实现可随意利用底层 Object

方法的指定行为，而不管实现程序认为它是否合适。

Collection的实现类及子类接口：
所有已知子接口：
BeanContext, BeanContextServices, BlockingDeque<E>,

BlockingQueue<E>, Deque<E>, List<E>, NavigableSet<E>,

Queue<E>, Set<E>, SortedSet<E>
所有已知实现类：
AbstractCollection, AbstractList, AbstractQueue,

AbstractSequentialList, AbstractSet,

ArrayBlockingQueue, ArrayDeque, ArrayList,

AttributeList, BeanContextServicesSupport,

BeanContextSupport, ConcurrentLinkedQueue,

ConcurrentSkipListSet, CopyOnWriteArrayList,

CopyOnWriteArraySet, DelayQueue, EnumSet, HashSet,

JobStateReasons, LinkedBlockingDeque,

LinkedBlockingQueue, LinkedHashSet, LinkedList,

PriorityBlockingQueue, PriorityQueue, RoleList,

RoleUnresolvedList, Stack, SynchronousQueue, TreeSet,

Vector
关于其用法可以查看API，下面介绍几个常用的：
public class Vector<E>extends AbstractList<E>implements

List<E>, RandomAccess, Cloneable, SerializableVector 类

可以实现可增长的对象数组。与数组一样，它包含可以使用整

数索引进行访问的组件。但是，Vector 的大小可以根据需要增

大或缩小，以适应创建 Vector 后进行添加或移除项的操作。

每个向量会试图通过维护 capacity 和 capacityIncrement 来

优化存储管理。capacity 始终至少应与向量的大小相等；这个

值通常比后者大些，因为随着将组件添加到向量中，其存储将

按 capacityIncrement 的大小增加存储块。应用程序可以在插

入大量组件前增加向量的容量；这样就减少了增加的重分配的

量。

由 Vector 的 iterator 和 listIterator 方法所返回的迭代

器是快速失败的：如果在迭代器创建后的任意时间从结构上修

改了向量（通过迭代器自身的 remove 或 add 方法之外的任何

其他方式），则迭代器将抛出

ConcurrentModificationException。因此，面对并发的修改，

迭代器很快就完全失败，而不是冒着在将来不确定的时间任意

发生不确定行为的风险。Vector 的 elements 方法返回的

Enumeration 不是 快速失败的。

注意，迭代器的快速失败行为不能得到保证，一般来说，存在

不同步的并发修改时，不可能作出任何坚决的保证。快速失败

迭代器尽最大努力抛出 ConcurrentModificationException。

因此，编写依赖于此异常的程序的方式是错误的，正确做法是

：迭代器的快速失败行为应该仅用于检测 bug。

从 Java 2 平台 v1.2 开始，此类改进为可以实现 List 接口

，使它成为 Java Collections Framework 的成员。与新

collection 实现不同，Vector 是同步的。
public class TreeSet<E>extends AbstractSet<E>implements

NavigableSet<E>, Cloneable, Serializable基于 TreeMap 的

NavigableSet 实现。使用元素的自然顺序对元素进行排序，或

者根据创建 set 时提供的 Comparator 进行排序，具体取决于

使用的构造方法。

此实现为基本操作（add、remove 和 contains）提供受保证的

log(n) 时间开销。

注意，如果要正确实现 Set 接口，则 set 维护的顺序（无论

是否提供了显式比较器）必须与 equals 一致。（关于与

equals 一致 的精确定义，请参阅 Comparable 或 Comparator

。）这是因为 Set 接口是按照 equals 操作定义的，但

TreeSet 实例使用它的 compareTo（或 compare）方法对所有

元素进行比较，因此从 set 的观点来看，此方法认为相等的两

个元素就是相等的。即使 set 的顺序与 equals 不一致，其行

为也是 定义良好的；它只是违背了 Set 接口的常规协定。

注意，此实现不是同步的。如果多个线程同时访问一个

TreeSet，而其中至少一个线程修改了该 set，那么它必须 外

部同步。这一般是通过对自然封装该 set 的对象执行同步操作

来完成的。如果不存在这样的对象，则应该使用

Collections.synchronizedSortedSet 方法来“包装”该 set

。此操作最好在创建时进行，以防止对 set 的意外非同步访问

：

   SortedSet s = Collections.synchronizedSortedSet(new

TreeSet(...));此类的 iterator 方法返回的迭代器是快速失

败 的：在创建迭代器之后，如果从结构上对 set 进行修改，

除非通过迭代器自身的 remove 方法，否则在其他任何时间以

任何方式进行修改都将导致迭代器抛出

ConcurrentModificationException。因此，对于并发的修改，

迭代器很快就完全失败，而不会冒着在将来不确定的时间发生

不确定行为的风险。

注意，迭代器的快速失败行为无法得到保证，一般来说，存在

不同步的并发修改时，不可能作出任何肯定的保证。快速失败

迭代器尽最大努力抛出 ConcurrentModificationException。

因此，编写依赖于此异常的程序的做法是错误的，正确做法是

：迭代器的快速失败行为应该仅用于检测 bug。
public class HashSet<E>extends AbstractSet<E>implements

Set<E>, Cloneable, Serializable此类实现 Set 接口，由哈

希表（实际上是一个 HashMap 实例）支持。它不保证 set 的

迭代顺序；特别是它不保证该顺序恒久不变。此类允许使用

null 元素。

此类为基本操作提供了稳定性能，这些基本操作包括 add、

remove、contains 和 size，假定哈希函数将这些元素正确地

分布在桶中。对此 set 进行迭代所需的时间与 HashSet 实例

的大小（元素的数量）和底层 HashMap 实例（桶的数量）的“

容量”的和成比例。因此，如果迭代性能很重要，则不要将初

始容量设置得太高（或将加载因子设置得太低）。

注意，此实现不是同步的。如果多个线程同时访问一个哈希

set，而其中至少一个线程修改了该 set，那么它必须 保持外

部同步。这通常是通过对自然封装该 set 的对象执行同步操作

来完成的。如果不存在这样的对象，则应该使用

Collections.synchronizedSet 方法来“包装” set。最好在

创建时完成这一操作，以防止对该 set 进行意外的不同步访问

：

   Set s = Collections.synchronizedSet(new HashSet

(...));此类的 iterator 方法返回的迭代器是快速失败 的：

在创建迭代器之后，如果对 set 进行修改，除非通过迭代器自

身的 remove 方法，否则在任何时间以任何方式对其进行修改

，Iterator 都将抛出 ConcurrentModificationException。因

此，面对并发的修改，迭代器很快就会完全失败，而不冒将来

在某个不确定时间发生任意不确定行为的风险。

注意，迭代器的快速失败行为无法得到保证，因为一般来说，

不可能对是否出现不同步并发修改做出任何硬性保证。快速失

败迭代器在尽最大努力抛出

ConcurrentModificationException。因此，为提高这类迭代器

的正确性而编写一个依赖于此异常的程序是错误做法：迭代器

的快速失败行为应该仅用于检测 bug。
public class LinkedList<E>extends

AbstractSequentialList<E>implements List<E>, Deque<E>,

Cloneable, SerializableList 接口的链接列表实现。实现所

有可选的列表操作，并且允许所有元素（包括 null）。除了实

现 List 接口外，LinkedList 类还为在列表的开头及结尾 get

、remove 和 insert 元素提供了统一的命名方法。这些操作允

许将链接列表用作堆栈、队列或双端队列。

此类实现 Deque 接口，为 add、poll 提供先进先出队列操作

，以及其他堆栈和双端队列操作。

所有操作都是按照双重链接列表的需要执行的。在列表中编索

引的操作将从开头或结尾遍历列表（从靠近指定索引的一端）

。

注意，此实现不是同步的。如果多个线程同时访问一个链接列

表，而其中至少一个线程从结构上修改了该列表，则它必须 保

持外部同步。（结构修改指添加或删除一个或多个元素的任何

操作；仅设置元素的值不是结构修改。）这一般通过对自然封

装该列表的对象进行同步操作来完成。如果不存在这样的对象

，则应该使用 Collections.synchronizedList 方法来“包装

”该列表。最好在创建时完成这一操作，以防止对列表进行意

外的不同步访问，如下所示：

   List list = Collections.synchronizedList(new

LinkedList(...));此类的 iterator 和 listIterator 方法返

回的迭代器是快速失败 的：在迭代器创建之后，如果从结构上

对列表进行修改，除非通过迭代器自身的 remove 或 add 方法

，其他任何时间任何方式的修改，迭代器都将抛出

ConcurrentModificationException。因此，面对并发的修改，

迭代器很快就会完全失败，而不冒将来不确定的时间任意发生

不确定行为的风险。

注意，迭代器的快速失败行为不能得到保证，一般来说，存在

不同步的并发修改时，不可能作出任何硬性保证。快速失败迭

代器尽最大努力抛出 ConcurrentModificationException。因

此，编写依赖于此异常的程序的方式是错误的，正确做法是：

迭代器的快速失败行为应该仅用于检测程序错误。
public class ArrayList<E>extends

AbstractList<E>implements List<E>, RandomAccess,

Cloneable, SerializableList 接口的大小可变数组的实现。

实现了所有可选列表操作，并允许包括 null 在内的所有元素

。除了实现 List 接口外，此类还提供一些方法来操作内部用

来存储列表的数组的大小。（此类大致上等同于 Vector 类，

除了此类是不同步的。）

size、isEmpty、get、set、iterator 和 listIterator 操作

都以固定时间运行。add 操作以分摊的固定时间 运行，也就是

说，添加 n 个元素需要 O(n) 时间。其他所有操作都以线性时

间运行（大体上讲）。与用于 LinkedList 实现的常数因子相

比，此实现的常数因子较低。

每个 ArrayList 实例都有一个容量。该容量是指用来存储列表

元素的数组的大小。它总是至少等于列表的大小。随着向

ArrayList 中不断添加元素，其容量也自动增长。并未指定增

长策略的细节，因为这不只是添加元素会带来分摊固定时间开

销那样简单。

在添加大量元素前，应用程序可以使用 ensureCapacity 操作

来增加 ArrayList 实例的容量。这可以减少递增式再分配的数

量。

注意，此实现不是同步的。如果多个线程同时访问一个

ArrayList 实例，而其中至少一个线程从结构上修改了列表，

那么它必须 保持外部同步。（结构上的修改是指任何添加或删

除一个或多个元素的操作，或者显式调整底层数组的大小；仅

仅设置元素的值不是结构上的修改。）这一般通过对自然封装

该列表的对象进行同步操作来完成。如果不存在这样的对象，

则应该使用 Collections.synchronizedList 方法将该列表“

包装”起来。这最好在创建时完成，以防止意外对列表进行不

同步的访问：

        List list = Collections.synchronizedList(new

ArrayList(...)); 此类的 iterator 和 listIterator 方法返

回的迭代器是快速失败的：在创建迭代器之后，除非通过迭代

器自身的 remove 或 add 方法从结构上对列表进行修改，否则

在任何时间以任何方式对列表进行修改，迭代器都会抛出

ConcurrentModificationException。因此，面对并发的修改，

迭代器很快就会完全失败，而不是冒着在将来某个不确定时间

发生任意不确定行为的风险。

注意，迭代器的快速失败行为无法得到保证，因为一般来说，

不可能对是否出现不同步并发修改做出任何硬性保证。快速失

败迭代器会尽最大努力抛出

ConcurrentModificationException。因此，为提高这类迭代器

的正确性而编写一个依赖于此异常的程序是错误的做法：迭代

器的快速失败行为应该仅用于检测 bug。

 

 

------- android培训 、 java培训 、期待与您交流！ ----------