Collection

Posted 2020-12-11 zyb-mini

Collection继承关系图

Collection类

Set、List、Map、Queue使用场景梳理

 1 方法摘要 
 2  boolean add(E e) 
 3           确保此 collection 包含指定的元素（可选操作）。 
 4  boolean addAll(Collection<? extends E> c) 
 5           将指定 collection 中的所有元素都添加到此 collection 中（可选操作）。 
 6  void clear() 
 7           移除此 collection 中的所有元素（可选操作）。 
 8  boolean contains(Object o) 
 9           如果此 collection 包含指定的元素，则返回 true。 
10  boolean containsAll(Collection<?> c) 
11           如果此 collection 包含指定 collection 中的所有元素，则返回 true。 
12  boolean equals(Object o) 
13           比较此 collection 与指定对象是否相等。 
14  int hashCode() 
15           返回此 collection 的哈希码值。 
16  boolean isEmpty() 
17           如果此 collection 不包含元素，则返回 true。 
18  Iterator<E> iterator() 
19           返回在此 collection 的元素上进行迭代的迭代器。 
20  boolean remove(Object o) 
21           从此 collection 中移除指定元素的单个实例，如果存在的话（可选操作）。 
22  boolean removeAll(Collection<?> c) 
23           移除此 collection 中那些也包含在指定 collection 中的所有元素（可选操作）。 
24  boolean retainAll(Collection<?> c) 
25           仅保留此 collection 中那些也包含在指定 collection 的元素（可选操作）。 
26  int size() 
27           返回此 collection 中的元素数。 
28  Object[] toArray() 
29           返回包含此 collection 中所有元素的数组。 
30 <T> T[] 
31  toArray(T[] a) 
32           返回包含此 collection 中所有元素的数组；返回数组的运行时类型与指定数组的运行时类型相同。 

 

List

List集合使用场景分析

 1 方法摘要 
 2  boolean add(E e) 
 3           向列表的尾部添加指定的元素（可选操作）。 
 4  void add(int index, E element) 
 5           在列表的指定位置插入指定元素（可选操作）。 
 6  boolean addAll(Collection<? extends E> c) 
 7           添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序（可选操作）。 
 8  boolean addAll(int index, Collection<? extends E> c) 
 9           将指定 collection 中的所有元素都插入到列表中的指定位置（可选操作）。 
10  void clear() 
11           从列表中移除所有元素（可选操作）。 
12  boolean contains(Object o) 
13           如果列表包含指定的元素，则返回 true。 
14  boolean containsAll(Collection<?> c) 
15           如果列表包含指定 collection 的所有元素，则返回 true。 
16  boolean equals(Object o) 
17           比较指定的对象与列表是否相等。 
18  E get(int index) 
19           返回列表中指定位置的元素。 
20  int hashCode() 
21           返回列表的哈希码值。 
22  int indexOf(Object o) 
23           返回此列表中第一次出现的指定元素的索引；如果此列表不包含该元素，则返回 -1。 
24  boolean isEmpty() 
25           如果列表不包含元素，则返回 true。 
26  Iterator<E> iterator() 
27           返回按适当顺序在列表的元素上进行迭代的迭代器。 
28  int lastIndexOf(Object o) 
29           返回此列表中最后出现的指定元素的索引；如果列表不包含此元素，则返回 -1。 
30  ListIterator<E> listIterator() 
31           返回此列表元素的列表迭代器（按适当顺序）。 
32  ListIterator<E> listIterator(int index) 
33           返回列表中元素的列表迭代器（按适当顺序），从列表的指定位置开始。 
34  E remove(int index) 
35           移除列表中指定位置的元素（可选操作）。 
36  boolean remove(Object o) 
37           从此列表中移除第一次出现的指定元素（如果存在）（可选操作）。 
38  boolean removeAll(Collection<?> c) 
39           从列表中移除指定 collection 中包含的其所有元素（可选操作）。 
40  boolean retainAll(Collection<?> c) 
41           仅在列表中保留指定 collection 中所包含的元素（可选操作）。 
42  E set(int index, E element) 
43           用指定元素替换列表中指定位置的元素（可选操作）。 
44  int size() 
45           返回列表中的元素数。 
46  List<E> subList(int fromIndex, int toIndex) 
47           返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之间的部分视图。 
48  Object[] toArray() 
49           返回按适当顺序包含列表中的所有元素的数组（从第一个元素到最后一个元素）。 
50 <T> T[] 
51  toArray(T[] a) 
52           返回按适当顺序（从第一个元素到最后一个元素）包含列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。 

 

*ArrayList

　　ArrayList是基于数组的，在初始化ArrayList时，会构建空数组（Object[] elementData={}）。ArrayList是一个无序的，它是按照添加的先后顺序排列，当然，他也提供了sort方法，如果需要对ArrayList进行排序，只需要调用这个方法，提供Comparator比较器即可

add操作：

　　1）如果是第一次添加元素，数组的长度被扩容到默认的capacity，也就是10.

　　2) 当发觉同时添加一个或者是多个元素，数组长度不够时，就扩容，这里有两种情况：

　　只添加一个元素，例如：原来数组的capacity为10，size已经为10，不能再添加了。需要扩容，新的capacity=old capacity+old capacity>>1=10+10/2=15.即新的容量为15。

　　当同时添加多个元素时，原来数组的capacity为10，size为10，当同时添加6个元素时。它需要的min capacity为16，而按照capacity=old capacity+old capacity>>1=10+10/2=15。new capacity小于min capacity，则取min capacity。

　　对于添加，如果不指定下标，就直接添加到数组后面，不涉及元素的移动，如果要添加到某个特定的位置，那需要将这个位置开始的元素往后挪一个位置，然后再对这个位置设置。

Remove操作：

　Remove提供两种，按照下标和value。

　　1）remove(int index)：首先需要检查Index是否在合理的范围内。其次再调用System.arraycopy将index之后的元素向前移动。

　　2）remove(Object o)：首先遍历数组，获取第一个相同的元素，获取该元素的下标。其次再调用System.arraycopy将index之后的元素向前移动。

 

如果一开始就知道ArrayList集合需要保存多少元素，则可以在创建它们时就指定initialCapacity大小，这样可以减少重新分配的次数，提供性能，ArrayList还提供了如下方法来重新分配Object[]数组

1) ensureCapacity(int minCapacity): 将ArrayList集合的Object[]数组长度增加minCapacity
2) trimToSize(): 调整ArrayList集合的Object[]数组长度为当前元素的个数。程序可以通过此方法来减少ArrayList集合对象占用的内存空间

 1 构造方法摘要 
 2 ArrayList() 
 3 构造一个初始容量为 10 的空列表。 
 4 ArrayList(Collection<? extends E> c) 
 5 构造一个包含指定 collection 的元素的列表，这些元素是按照该 collection 的迭代器返回它们的顺序排列的。 
 6 ArrayList(int initialCapacity) 
 7 构造一个具有指定初始容量的空列表。
 8 
 9 
10 方法摘要 
11 boolean add(E e) 
12 将指定的元素添加到此列表的尾部。 
13 void add(int index, E element) 
14 将指定的元素插入此列表中的指定位置。 
15 boolean addAll(Collection<? extends E> c) 
16 按照指定 collection 的迭代器所返回的元素顺序，将该 collection 中的所有元素添加到此列表的尾部。 
17 boolean addAll(int index, Collection<? extends E> c) 
18 从指定的位置开始，将指定 collection 中的所有元素插入到此列表中。 
19 void clear() 
20 移除此列表中的所有元素。 
21 Object clone() 
22 返回此 ArrayList 实例的浅表副本。 
23 boolean contains(Object o) 
24 如果此列表中包含指定的元素，则返回 true。 
25 void ensureCapacity(int minCapacity) 
26 如有必要，增加此 ArrayList 实例的容量，以确保它至少能够容纳最小容量参数所指定的元素数。 
27 E get(int index) 
28 返回此列表中指定位置上的元素。 
29 int indexOf(Object o) 
30 返回此列表中首次出现的指定元素的索引，或如果此列表不包含元素，则返回 -1。 
31 boolean isEmpty() 
32 如果此列表中没有元素，则返回 true 
33 int lastIndexOf(Object o) 
34 返回此列表中最后一次出现的指定元素的索引，或如果此列表不包含索引，则返回 -1。 
35 E remove(int index) 
36 移除此列表中指定位置上的元素。 
37 boolean remove(Object o) 
38 移除此列表中首次出现的指定元素（如果存在）。 
39 protected void removeRange(int fromIndex, int toIndex) 
40 移除列表中索引在 fromIndex（包括）和 toIndex（不包括）之间的所有元素。 
41 E set(int index, E element) 
42 用指定的元素替代此列表中指定位置上的元素。 
43 int size() 
44 返回此列表中的元素数。 
45 Object[] toArray() 
46 按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组。 
47 <T> T[] 
48 toArray(T[] a) 
49 按适当顺序（从第一个到最后一个元素）返回包含此列表中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。 
50 void trimToSize() 
51 将此 ArrayList 实例的容量调整为列表的当前大小。

 

*LinkedList

List 接口的链接列表实现。实现所有可选的列表操作，并且允许所有元素（包括 null）。除了实现 List 接口外，LinkedList 类还为在列表的开头及结尾 get、remove 和 insert 元素提供了统一的命名方法。这些操作允许将链接列表用作堆栈、队列或双端队列。

此类实现 Deque 接口，为 add、poll 提供先进先出队列操作，以及其他堆栈和双端队列操作。

所有操作都是按照双重链接列表的需要执行的。在列表中编索引的操作将从开头或结尾遍历列表（从靠近指定索引的一端）。

 

注意，此实现不是同步的。如果多个线程同时访问一个链接列表，而其中至少一个线程从结构上修改了该列表，则它必须 保持外部同步。（结构修改指添加或删除一个或多个元素的任何操作；仅设置元素的值不是结构修改。）这一般通过对自然封装该列表的对象进行同步操作来完成。如果不存在这样的对象，则应该使用 Collections.synchronizedList 方法来“包装”该列表。最好在创建时完成这一操作，以防止对列表进行意外的不同步访问，如下所示：

   List list = Collections.synchronizedList(new LinkedList(...));

此类的 iterator 和 listIterator 方法返回的迭代器是快速失败 的：在迭代器创建之后，如果从结构上对列表进行修改，除非通过迭代器自身的 remove 或 add 方法，其他任何时间任何方式的修改，迭代器都将抛出 ConcurrentModificationException。

 1 构造方法摘要 
 2 LinkedList() 
 3           构造一个空列表。 
 4 LinkedList(Collection<? extends E> c) 
 5           构造一个包含指定 collection 中的元素的列表，这些元素按其 collection 的迭代器返回的顺序排列。 
 6 
 7 
 8 方法摘要 
 9  boolean add(E e) 
10           将指定元素添加到此列表的结尾。 
11  void add(int index, E element) 
12           在此列表中指定的位置插入指定的元素。 
13  boolean addAll(Collection<? extends E> c) 
14           添加指定 collection 中的所有元素到此列表的结尾，顺序是指定 collection 的迭代器返回这些元素的顺序。 
15  boolean addAll(int index, Collection<? extends E> c) 
16           将指定 collection 中的所有元素从指定位置开始插入此列表。 
17  void addFirst(E e) 
18           将指定元素插入此列表的开头。 
19  void addLast(E e) 
20           将指定元素添加到此列表的结尾。 
21  void clear() 
22           从此列表中移除所有元素。 
23  Object clone() 
24           返回此 LinkedList 的浅表副本。 
25  boolean contains(Object o) 
26           如果此列表包含指定元素，则返回 true。 
27  Iterator<E> descendingIterator() 
28           返回以逆向顺序在此双端队列的元素上进行迭代的迭代器。 
29  E element() 
30           获取但不移除此列表的头（第一个元素）。 
31  E get(int index) 
32           返回此列表中指定位置处的元素。 
33  E getFirst() 
34           返回此列表的第一个元素。 
35  E getLast() 
36           返回此列表的最后一个元素。 
37  int indexOf(Object o) 
38           返回此列表中首次出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。 
39  int lastIndexOf(Object o) 
40           返回此列表中最后出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。 
41  ListIterator<E> listIterator(int index) 
42           返回此列表中的元素的列表迭代器（按适当顺序），从列表中指定位置开始。 
43  boolean offer(E e) 
44           将指定元素添加到此列表的末尾（最后一个元素）。 
45  boolean offerFirst(E e) 
46           在此列表的开头插入指定的元素。 
47  boolean offerLast(E e) 
48           在此列表末尾插入指定的元素。 
49  E peek() 
50           获取但不移除此列表的头（第一个元素）。 
51  E peekFirst() 
52           获取但不移除此列表的第一个元素；如果此列表为空，则返回 null。 
53  E peekLast() 
54           获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。 
55  E poll() 
56           获取并移除此列表的头（第一个元素） 
57  E pollFirst() 
58           获取并移除此列表的第一个元素；如果此列表为空，则返回 null。 
59  E pollLast() 
60           获取并移除此列表的最后一个元素；如果此列表为空，则返回 null。 
61  E pop() 
62           从此列表所表示的堆栈处弹出一个元素。 
63  void push(E e) 
64           将元素推入此列表所表示的堆栈。 
65  E remove() 
66           获取并移除此列表的头（第一个元素）。 
67  E remove(int index) 
68           移除此列表中指定位置处的元素。 
69  boolean remove(Object o) 
70           从此列表中移除首次出现的指定元素（如果存在）。 
71  E removeFirst() 
72           移除并返回此列表的第一个元素。 
73  boolean removeFirstOccurrence(Object o) 
74           从此列表中移除第一次出现的指定元素（从头部到尾部遍历列表时）。 
75  E removeLast() 
76           移除并返回此列表的最后一个元素。 
77  boolean removeLastOccurrence(Object o) 
78           从此列表中移除最后一次出现的指定元素（从头部到尾部遍历列表时）。 
79  E set(int index, E element) 
80           将此列表中指定位置的元素替换为指定的元素。 
81  int size() 
82           返回此列表的元素数。 
83  Object[] toArray() 
84           返回以适当顺序（从第一个元素到最后一个元素）包含此列表中所有元素的数组。 
85 <T> T[] 
86  toArray(T[] a) 
87           返回以适当顺序（从第一个元素到最后一个元素）包含此列表中所有元素的数组；返回数组的运行时类型为指定数组的类型。 

 

Vector

Vector 的数据结构和使用方法与ArrayList差不多。最大的不同就是Vector是线程安全的。从下面的源码可以看出，几乎所有的对数据操作的方法都被synchronized关键字修饰。synchronized是线程同步的，当一个线程已经获得Vector对象的锁时，其他线程必须等待直到该锁被释放。从这里就可以得知Vector的性能要比ArrayList低。
若想要一个高性能，又是线程安全的ArrayList，可以使用Collections.synchronizedList(list);方法或者使用CopyOnWriteArrayList集合

Stack

Stack 类表示后进先出（LIFO）的对象堆栈。它通过五个操作对类 Vector 进行了扩展 ，允许将向量视为堆栈。它提供了通常的 push 和 pop 操作，以及取堆栈顶点的 peek 方法、测试堆栈是否为空的 empty 方法、在堆栈中查找项并确定到堆栈顶距离的 search 方法。

首次创建堆栈时，它不包含项。

Deque 接口及其实现提供了 LIFO 堆栈操作的更完整和更一致的 set，应该优先使用此 set，而非此类。例如：

   Deque<Integer> stack = new ArrayDeque<Integer>();

 1 方法摘要 
 2  boolean empty() 
 3           测试堆栈是否为空。 
 4  E peek() 
 5           查看堆栈顶部的对象，但不从堆栈中移除它。 
 6  E pop() 
 7           移除堆栈顶部的对象，并作为此函数的值返回该对象。 
 8  E push(E item) 
 9           把项压入堆栈顶部。 
10  int search(Object o) 
11           返回对象在堆栈中的位置，以 1 为基数。 

 

Deque

Deque extends Queue<E>一个线性 collection，支持在两端插入和移除元素。名称 deque 是“double ended queue（双端队列）”的缩写，通常读为“deck”。大多数 Deque 实现对于它们能够包含的元素数没有固定限制，但此接口既支持有容量限制的双端队列，也支持没有固定大小限制的双端队列。

此接口定义在双端队列两端访问元素的方法。提供插入、移除和检查元素的方法。每种方法都存在两种形式：一种形式在操作失败时抛出异常，另一种形式返回一个特殊值（null 或 false，具体取决于操作）。插入操作的后一种形式是专为使用有容量限制的 Deque 实现设计的；在大多数实现中，插入操作不能失败。 

下表总结了上述 12 种方法：

此接口扩展了 Queue 接口。在将双端队列用作队列时，将得到 FIFO（先进先出）行为。将元素添加到双端队列的末尾，从双端队列的开头移除元素。从 Queue 接口继承的方法完全等效于 Deque 方法，如下表所示： 

双端队列也可用作 LIFO（后进先出）堆栈。应优先使用此接口而不是遗留 Stack 类。在将双端队列用作堆栈时，元素被推入双端队列的开头并从双端队列开头弹出。堆栈方法完全等效于 Deque 方法，如下表所示： 

注意，在将双端队列用作队列或堆栈时，peek 方法同样正常工作；无论哪种情况下，都从双端队列的开头抽取元素。

 

*ArrayDeque

Deque 接口的大小可变数组的实现。数组双端队列没有容量限制；它们可根据需要增加以支持使用。它们不是线程安全的；在没有外部同步时，它们不支持多个线程的并发访问。禁止 null 元素。此类很可能在用作堆栈时快于 Stack，在用作队列时快于 LinkedList。

大多数 ArrayDeque 操作以摊销的固定时间运行。异常包括 remove、removeFirstOccurrence、removeLastOccurrence、contains、iterator.remove() 以及批量操作，它们均以线性时间运行。

此类的 iterator 方法返回的迭代器是快速失败 的：如果在创建迭代器后的任意时间通过除迭代器本身的 remove 方法之外的任何其他方式修改了双端队列，则迭代器通常将抛出 ConcurrentModificationException。

 1 构造方法摘要 
 2 ArrayDeque() 
 3           构造一个初始容量能够容纳 16 个元素的空数组双端队列。 
 4 ArrayDeque(Collection<? extends E> c) 
 5           构造一个包含指定 collection 的元素的双端队列，这些元素按 collection 的迭代器返回的顺序排列。 
 6 ArrayDeque(int numElements) 
 7           构造一个初始容量能够容纳指定数量的元素的空数组双端队列。 
 8 
 9 
10 方法摘要 
11  boolean add(E e) 
12           将指定元素插入此双端队列的末尾。 
13  void addFirst(E e) 
14           将指定元素插入此双端队列的开头。 
15  void addLast(E e) 
16           将指定元素插入此双端队列的末尾。 
17  void clear() 
18           从此双端队列中移除所有元素。 
19  ArrayDeque<E> clone() 
20           返回此双端队列的副本。 
21  boolean contains(Object o) 
22           如果此双端队列包含指定元素，则返回 true。 
23  Iterator<E> descendingIterator() 
24           返回以逆向顺序在此双端队列的元素上进行迭代的迭代器。 
25  E element() 
26           获取，但不移除此双端队列所表示的队列的头。 
27  E getFirst() 
28           获取，但不移除此双端队列的第一个元素。 
29  E getLast() 
30           获取，但不移除此双端队列的最后一个元素。 
31  boolean isEmpty() 
32           如果此双端队列未包含任何元素，则返回 true。 
33  Iterator<E> iterator() 
34           返回在此双端队列的元素上进行迭代的迭代器。 
35  boolean offer(E e) 
36           将指定元素插入此双端队列的末尾。 
37  boolean offerFirst(E e) 
38           将指定元素插入此双端队列的开头。 
39  boolean offerLast(E e) 
40           将指定元素插入此双端队列的末尾。 
41  E peek() 
42           获取，但不移除此双端队列所表示的队列的头；如果此双端队列为空，则返回 null。 
43  E peekFirst() 
44           获取，但不移除此双端队列的第一个元素；如果此双端队列为空，则返回 null。 
45  E peekLast() 
46           获取，但不移除此双端队列的最后一个元素；如果此双端队列为空，则返回 null。 
47  E poll() 
48           获取并移除此双端队列所表示的队列的头（换句话说，此双端队列的第一个元素）；如果此双端队列为空，则返回 null。 
49  E pollFirst() 
50           获取并移除此双端队列的第一个元素；如果此双端队列为空，则返回 null。 
51  E pollLast() 
52           获取并移除此双端队列的最后一个元素；如果此双端队列为空，则返回 null。 
53  E pop() 
54           从此双端队列所表示的堆栈中弹出一个元素。 
55  void push(E e) 
56           将元素推入此双端队列所表示的堆栈。 
57  E remove() 
58           获取并移除此双端队列所表示的队列的头。 
59  boolean remove(Object o) 
60           从此双端队列中移除指定元素的单个实例。 
61  E removeFirst() 
62           获取并移除此双端队列第一个元素。 
63  boolean removeFirstOccurrence(Object o) 
64           移除此双端队列中第一次出现的指定元素（当从头部到尾部遍历双端队列时）。 
65  E removeLast() 
66           获取并移除此双端队列的最后一个元素。 
67  boolean removeLastOccurrence(Object o) 
68           移除此双端队列中最后一次出现的指定元素（当从头部到尾部遍历双端队列时）。 
69  int size() 
70           返回此双端队列中的元素数。 
71  Object[] toArray() 
72           返回一个以恰当顺序包含此双端队列所有元素的数组（从第一个元素到最后一个元素）。 
73 <T> T[] 
74  toArray(T[] a) 
75           返回一个以恰当顺序包含此双端队列所有元素的数组（从第一个元素到最后一个元素）；返回数组的运行时类型是指定数组的运行时类型。 

 

Set

一个不包含重复元素的 collection。更确切地讲，set 不包含满足 e1.equals(e2) 的元素对 e1 和 e2，并且最多包含一个 null 元素。正如其名称所暗示的，此接口模仿了数学上的 set 抽象。

在所有构造方法以及 add、equals 和 hashCode 方法的协定上，Set 接口还加入了其他规定，这些规定超出了从 Collection 接口所继承的内容。出于方便考虑，它还包括了其他继承方法的声明（这些声明的规范已经专门针对 Set 接口进行了修改，但是没有包含任何其他的规定）。

对这些构造方法的其他规定是（不要奇怪），所有构造方法必须创建一个不包含重复元素的 set（正如上面所定义的）。

注：如果将可变对象用作 set 元素，那么必须极其小心。如果对象是 set 中某个元素，以一种影响 equals 比较的方式改变对象的值，那么 set 的行为就是不确定的。此项禁止的一个特殊情况是不允许某个 set 包含其自身作为元素。

某些 set 实现对其所包含的元素有所限制。例如，某些实现禁止 null 元素，而某些则对其元素的类型所有限制。试图添加不合格的元素会抛出未经检查的异常，通常是 NullPointerException 或 ClassCastException。

 1 方法摘要 
 2  boolean add(E e) 
 3           如果 set 中尚未存在指定的元素，则添加此元素（可选操作）。 
 4  boolean addAll(Collection<? extends E> c) 
 5           如果 set 中没有指定 collection 中的所有元素，则将其添加到此 set 中（可选操作）。 
 6  void clear() 
 7           移除此 set 中的所有元素（可选操作）。 
 8  boolean contains(Object o) 
 9           如果 set 包含指定的元素，则返回 true。 
10  boolean containsAll(Collection<?> c) 
11           如果此 set 包含指定 collection 的所有元素，则返回 true。 
12  boolean equals(Object o) 
13           比较指定对象与此 set 的相等性。 
14  int hashCode() 
15           返回 set 的哈希码值。 
16  boolean isEmpty() 
17           如果 set 不包含元素，则返回 true。 
18  Iterator<E> iterator() 
19           返回在此 set 中的元素上进行迭代的迭代器。 
20  boolean remove(Object o) 
21           如果 set 中存在指定的元素，则将其移除（可选操作）。 
22  boolean removeAll(Collection<?> c) 
23           移除 set 中那些包含在指定 collection 中的元素（可选操作）。 
24  boolean retainAll(Collection<?> c) 
25           仅保留 set 中那些包含在指定 collection 中的元素（可选操作）。 
26  int size() 
27           返回 set 中的元素数（其容量）。 
28  Object[] toArray() 
29           返回一个包含 set 中所有元素的数组。 
30 <T> T[] 
31  toArray(T[] a) 
32           返回一个包含此 set 中所有元素的数组；返回数组的运行时类型是指定数组的类型。 

 

HashSet

此类实现 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。

 1 构造方法摘要 
 2 HashSet() 
 3           构造一个新的空 set，其底层 HashMap 实例的默认初始容量是 16，加载因子是 0.75。 
 4 HashSet(Collection<? extends E> c) 
 5           构造一个包含指定 collection 中的元素的新 set。 
 6 HashSet(int initialCapacity) 
 7           构造一个新的空 set，其底层 HashMap 实例具有指定的初始容量和默认的加载因子（0.75）。 
 8 HashSet(int initialCapacity, float loadFactor) 
 9           构造一个新的空 set，其底层 HashMap 实例具有指定的初始容量和指定的加载因子。 
10 
11 
12 方法摘要 
13  boolean add(E e) 
14           如果此 set 中尚未包含指定元素，则添加指定元素。 
15  void clear() 
16           从此 set 中移除所有元素。 
17  Object clone() 
18           返回此 HashSet 实例的浅表副本：并没有复制这些元素本身。 
19  boolean contains(Object o) 
20           如果此 set 包含指定元素，则返回 true。 
21  boolean isEmpty() 
22           如果此 set 不包含任何元素，则返回 true。 
23  Iterator<E> iterator() 
24           返回对此 set 中元素进行迭代的迭代器。 
25  boolean remove(Object o) 
26           如果指定元素存在于此 set 中，则将其移除。 
27  int size() 
28           返回此 set 中的元素的数量（set 的容量）。

 

TreeSet

 1 构造方法摘要 
 2 TreeSet() 
 3           构造一个新的空 set，该 set 根据其元素的自然顺序进行排序。 
 4 TreeSet(Collection<? extends E> c) 
 5           构造一个包含指定 collection 元素的新 TreeSet，它按照其元素的自然顺序进行排序。 
 6 TreeSet(Comparator<? super E> comparator) 
 7           构造一个新的空 TreeSet，它根据指定比较器进行排序。 
 8 TreeSet(SortedSet<E> s) 
 9           构造一个与指定有序 set 具有相同映射关系和相同排序的新 TreeSet。 
10 
11 
12 方法摘要 
13  boolean add(E e) 
14           将指定的元素添加到此 set（如果该元素尚未存在于 set 中）。 
15  boolean addAll(Collection<? extends E> c) 
16           将指定 collection 中的所有元素添加到此 set 中。 
17  E ceiling(E e) 
18           返回此 set 中大于等于给定元素的最小元素；如果不存在这样的元素，则返回 null。 
19  void clear() 
20           移除此 set 中的所有元素。 
21  Object clone() 
22           返回 TreeSet 实例的浅表副本。 
23  Comparator<? super E> comparator() 
24           返回对此 set 中的元素进行排序的比较器；如果此 set 使用其元素的自然顺序，则返回 null。 
25  boolean contains(Object o) 
26           如果此 set 包含指定的元素，则返回 true。 
27  Iterator<E> descendingIterator() 
28           返回在此 set 元素上按降序进行迭代的迭代器。 
29  NavigableSet<E> descendingSet() 
30           返回此 set 中所包含元素的逆序视图。 
31  E first() 
32           返回此 set 中当前第一个（最低）元素。 
33  E floor(E e) 
34           返回此 set 中小于等于给定元素的最大元素；如果不存在这样的元素，则返回 null。 
35  SortedSet<E> headSet(E toElement) 
36           返回此 set 的部分视图，其元素严格小于 toElement。 
37  NavigableSet<E> headSet(E toElement, boolean inclusive) 
38           返回此 set 的部分视图，其元素小于（或等于，如果 inclusive 为 true）toElement。 
39  E higher(E e) 
40           返回此 set 中严格大于给定元素的最小元素；如果不存在这样的元素，则返回 null。 
41  boolean isEmpty() 
42           如果此 set 不包含任何元素，则返回 true。 
43  Iterator<E> iterator() 
44           返回在此 set 中的元素上按升序进行迭代的迭代器。 
45  E last() 
46           返回此 set 中当前最后一个（最高）元素。 
47  E lower(E e) 
48           返回此 set 中严格小于给定元素的最大元素；如果不存在这样的元素，则返回 null。 
49  E pollFirst() 
50           获取并移除第一个（最低）元素；如果此 set 为空，则返回 null。 
51  E pollLast() 
52           获取并移除最后一个（最高）元素；如果此 set 为空，则返回 null。 
53  boolean remove(Object o) 
54           将指定的元素从 set 中移除（如果该元素存在于此 set 中）。 
55  int size() 
56           返回 set 中的元素数（set 的容量）。 
57  NavigableSet<E> subSet(E fromElement, boolean fromInclusive, E toElement, boolean toInclusive) 
58           返回此 set 的部分视图，其元素范围从 fromElement 到 toElement。 
59  SortedSet<E> subSet(E fromElement, E toElement) 
60           返回此 set 的部分视图，其元素从 fromElement（包括）到 toElement（不包括）。 
61  SortedSet<E> tailSet(E fromElement) 
62           返回此 set 的部分视图，其元素大于等于 fromElement。 
63  NavigableSet<E> tailSet(E fromElement, boolean inclusive) 
64           返回此 set 的部分视图，其元素大于（或等于，如果 inclusive 为 true）fromElement。 
65