Collection

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