摘要：如果此對其迭代器返回的元素順序做出了某些保證，那么此方法必須以相同的順序返回這些元素。返回如果迭代器仍具有多個元素，則返回。方法功能從迭代器指向的中移除迭代器返回的最后一個元素可選操作。

Java是一門面向對象的語言，就免不了處理對象

為了方便操作多個對象，那么我們就得把這多個對象存儲起來

想要存儲多個對象(變量),很容易就能想到一個容器

常用的容器我們知道有StringBuffered,數組(雖然有對象數組，但是數組的長度是不可變的)

所以，Java就為我們提供了集合(Collection)

數組的長度是固定的
集合的長度是可變的

數組可以存儲基本數據類型，也可以存儲引用數據類型
集合只能存儲引用數據類型，存儲基本數據類型會自動裝箱

數組里面只能存儲同一數據類型的數據
集合可以存儲不同數據類型的數據

public interface Collection extends Iterable

Collection是層次結構的根接口。

Collection是單列集合。

Collection表示一組對象，這些對象也稱為collection的元素。

一些collection允許有重復的元素，而另一些則不允許。

一些collection是有序的，而另一些則是無序的。

JDK不提供此接口的任何直接實現，但是它提供更具體的子接口，如Set和List等等。

方法：
    * boolean add(E e)
簡述：
    * 添加一個元素。
功能：
    * 確保此collection包含指定的元素（可選操作）。
    * 如果此collection由于調用而發生更改，則返回true。
      如果此collection不允許有重復元素，并且已經包含了指定的元素，則返回false。
    * 支持此操作的collection可以限制哪些元素能添加到此collection中來。
      需要特別指出的是，一些collection拒絕添加null元素，其他一些collection將對可以添加的元素類型強加限制。Collection類在其文檔中清楚地指定了其添加元素方面的限制。
    * 如果collection由于某些原因（已經包含該元素的原因除外）拒絕添加特定的元素，那么它必須拋出一個異常而不是返回false。這確保了在此調用返回后，collection總是包含指定的元素。 
參數：
    * e-確定此collection中是否存在的元素。 
返回：
    * 如果此collection由于調用而發生更改，則返回true
拋出： 
    * UnsupportedOperationException-如果此collection不支持add操作 
    * ClassCastException-如果指定元素的類不允許它添加到此collection中 
    * NullPointerException-如果指定的元素為null，并且此collection不允許null元素 
    * IllegalArgumentException-如果元素的某屬性不允許它添加到此collection中 
    * IllegalStateException-如果由于插入限制，元素不能在此時間添加

方法:
    * boolean addAll(Collection c)
簡述：
    * 添加一個集合的元素
功能：   
    * 將指定collection中的所有元素都添加到此collection中（可選操作）。
    * 如果在進行此操作的同時修改指定的collection，那么此操作行為是不確定的。
      這意味著如果指定的collection是此collection，并且此collection為非空，那么此調用的行為是不確定的
參數：
    * c-包含要添加到此collection的collection 
返回：
    * 如果此collection由于調用而發生更改，則返回true 
拋出： 
    * UnsupportedOperationException-如果此collection不支持addAll方法 
    * ClassCastException-如果指定collection中某個元素的類不允許它添加到此collection中 
    * NullPointerException-如果指定collection包含null元素，
                           并且此collection不支持null元素，或者指定的collection為null 
    * IllegalArgumentException-如果指定collection的元素的某屬性不允許它添加到此collection中 
    * IllegalStateException-如果由于插入限制，不是所有的元素都能在此時間添加

方法：
    * void clear()
簡述：
    * 移除所有元素
功能：
    * 移除此collection中的所有元素（可選操作）。
    * 此方法無返回，但可拋出一個異常。 
拋出： 
    * UnsupportedOperationException-如果此collection不支持clear操作

方法：
    * boolean contains(Object o)
簡述：
    * 判斷集合是否包含該元素
功能：
    * 如果此collection包含指定的元素，則返回true。
    * 即當且僅當此collection至少包含一個滿足(o==null ? e==null : o.equals(e))的元素e時才返回true
    * 底層使用的是equals方法，需要看情況重寫equals方法。
參數：
    * o-測試在此collection中是否存在的元素。 
返回：
    * 如果此collection包含指定的元素，則返回true 
拋出： 
    * ClassCastException-如果指定元素的類型與此collection不兼容（可選）。 
    * NullPointerException-如果指定的元素為null，并且此collection不允許null元素（可選）。

方法：
    * boolean containsAll(Collection c)
簡述：
    * 判斷集合中是否包含指定的集合元素，只有包含所有的元素，才叫包含
功能：
    * 如果此collection包含指定collection中的所有元素，則返回true。
參數：
    * c-將檢查是否包含在此collection中的collection 
返回：
    * 如果此collection包含指定collection中的所有元素，則返回true。
拋出： 
    * ClassCastException-如果指定collection中有一個或多個元素的類型與此collection不兼容（可選） 
    * NullPointerException-如果指定collection包含一個或多個null元素，并且此collection不允許null 元素（可選），或者指定的collection為null。

方法：
    * boolean equals(Object o)
功能：
    * 比較此collection與指定對象是否相等。 
覆蓋：
    * 類Object中的equals()
參數：
    * o-要與此collection進行相等性比較的對象。 
返回：
    * 如果指定對象與此collection相等，則返回true。

方法：
    * int hashCode()
功能：
    * 返回此collection的哈希碼值。
覆蓋：
    * 類Object中的hashCode()
返回：
    * 此collection的哈希碼值。

方法：
    * boolean isEmpty()
功能：
    * 如果此collection不包含元素，則返回true。 
返回：
    * 如果此collection不包含元素，則返回true

方法：
    * Iterator iterator()
功能：
    * 返回在此collection的元素上進行迭代的迭代器。
    * 關于元素返回的順序沒有任何保證（除非此collection是某個能提供保證順序的類實例）。 
來源：
    * 接口Iterable中的iterator方法。
返回：
    * 在此collection的元素上進行迭代的Iterator

方法：
    * boolean remove(Object o)
功能：
    * 從此collection中移除指定元素的單個實例，如果存在的話（可選操作），即移除一個元素。
    * 即如果此collection包含一個或多個滿足(o==null ? e==null : o.equals(e))的元素e，
      則移除這樣的元素。
    * 如果此collection包含指定的元素（或者此collection由于調用而發生更改），則返回true。 
    * 底層使用的是equals方法，需要看情況重寫equals方法。
參數：
    * o-要從此 collection中移除的元素（如果存在）。 
返回：
    * 如果此調用將移除一個元素，則返回true 
拋出： 
    * ClassCastException-如果指定元素的類型與此collection不兼容（可選） 
    * NullPointerException-如果指定的元素為null，并且此collection不允許null元素（可選）。 
    * UnsupportedOperationException-如果此collection不支持remove操作

方法：
    * boolean removeAll(Collection c)
簡述：
    * 即移除一個集合的元素，只要有一個元素移除了，就返回true
功能：
    * 移除此collection中那些也包含在指定collection中的所有元素（可選操作）
      此調用返回后，collection中將不包含任何與指定collection相同的元素。 
參數：
    * c-要從此collection移除的元素的collection 
返回：
    * 如果此collection由于調用而發生更改，則返回true 
拋出： 
    * UnsupportedOperationException-如果此collection不支持removeAll方法 
    * ClassCastException-如果此collection中一個或多個元素的類型與指定collection不兼容（可選） 
    * NullPointerException-如果此collection包含一個或多個null元素，并且指定的collection不支持null元素（可選），或者指定的collection為null

方法：
    * boolean retainAll(Collection c)
簡述
    * 移除此collection中未包含在指定collection中的所有元素，集合A和集合B做交集，最終的結果保存在集合A，返回值表示的是A是否發生過變化。
功能：
    * 僅保留此collection中那些也包含在指定collection的元素（可選操作）
      即移除此collection中未包含在指定collection中的所有元素。 
參數：
    * c-包含保留在此 collection 中的元素的 collection 
返回：
    * 如果此 collection 由于調用而發生更改，則返回 true 
拋出： 
    * UnsupportedOperationException-如果此collection不支持 retainAll 操作 
    * ClassCastException-如果此collection 中一個或多個元素的類型與指定 collection 不兼容（可選） 
    * NullPointerException-如果此collection包含一個或多個null元素，并且指定的collection不允許null元素（可選），或者指定的collection為null

方法：
    * int size()
功能：
    * 返回此collection中的元素數。
    * 如果此collection包含的元素大于Integer.MAX_VALUE，則返回Integer.MAX_VALUE。 
返回：
    * 此collection中的元素數。

方法：
    * Object[] toArray()
功能：
    * 返回包含此collection中所有元素的數組。
    * 如果collection對其迭代器返回的元素順序做出了某些保證，那么此方法必須以相同的順序返回這些元素。 
    * 返回的數組將是“安全的”，因為此collection并不維護對返回數組的任何引用。
      換句話說，即使 collection 受到數組的支持，此方法也必須分配一個新的數組。
      因此，調用者可以隨意修改返回的數組。 
    * 此方法充當了基于數組的 API 與基于 collection 的 API 之間的橋梁。 
返回：
    * 包含此 collection 中所有元素的數組

方法：
    *  T[] toArray(T[] a)
功能：
    * 返回包含此collection中所有元素的數組。
    * 返回數組的運行時類型與指定數組的運行時類型相同。
    * 如果指定的數組能容納該collection，則返回包含此collection元素的數組。否則，將分配一個具有指定數組的運行時類型和此collection大小的新數組。 
    * 如果指定的數組能容納collection，并有剩余空間（即數組的元素比collection的元素多），那么會將數組中緊接collection尾部的元素設置為null。（調用者只有在知道此collection沒有包含任何null元素時才能用此方法確定collection的長度。） 
    * 如果此collection對其迭代器返回的元素順序做出了某些保證，那么此方法必須以相同的順序返回這些元素。 
    * 像toArray()方法一樣，此方法充當基于數組的API與基于collection的API之間的橋梁。更進一步說，此方法允許對輸出數組的運行時類型進行精確控制，并且在某些情況下，可以用來節省分配開銷。 
    * 假定x是只包含字符串的一個已知collection。
      以下代碼用來將collection轉儲到一個新分配的String數組： 
      String[] y = x.toArray(new String[0]); 
      注意，toArray(new Object[0])和toArray()在功能上是相同的。 
參數：
    * a-存儲此collection元素的數組（如果其足夠大）；否則，將為此分配一個具有相同運行時類型的新數組。 
返回：
    * 包含此 collection 中所有元素的數組 
拋出： 
    * ArrayStoreException-如果指定數組的運行時類型不是此collection每個元素運行時類型的超類型 
    * NullPointerException-如果指定的數組為null

public interface Iterator

對collection進行迭代的迭代器

依賴于集合而存在

具體實現是以內部類的方式實現的

方法：
    * boolean hasNext()
功能：
    * 如果仍有元素可以迭代，則返回true。
      換句話說，如果next返回了元素而不是拋出異常，則返回true。 
返回：
    * 如果迭代器仍具有多個元素，則返回true。

方法：
    * E next()
功能：
    * 返回迭代的下一個元素。 
返回：
    * 迭代的下一個元素。 
拋出： 
    * NoSuchElementException-沒有元素可以迭代。

方法：
    * void remove()
功能：
    * 從迭代器指向的collection中移除迭代器返回的最后一個元素（可選操作）。
    * 每次調用next只能調用一次此方法。
    * 如果進行迭代時用調用此方法之外的其他方式修改了該迭代器所指向的collection，則迭代器的行為是不確定的
拋出： 
    * UnsupportedOperationException-如果迭代器不支持remove操作。 
    * IllegalStateException-如果尚未調用next方法，或者在上一次調用next方法之后已經調用了remove方法

public interface List extends Collection

有序的collection（也稱為序列）。

此接口的用戶可以對列表中每個元素的插入位置進行精確地控制。

用戶可以根據元素的整數索引（在列表中的位置）訪問元素，并搜索列表中的元素。

與set不同，列表通常允許重復的元素

void add(int index,E element)在列表的指定位置插入指定元素（可選操作）。將當前處于該位置的元素（如果有的話）和所有后續元素向右移動（在其索引中加 1）。 

參數：
index - 要在其中插入指定元素處的索引
element - 要插入的元素 
拋出： 
UnsupportedOperationException - 如果列表不支持 add 操作 
ClassCastException - 如果指定元素的類不允許它添加到此列表 
NullPointerException - 如果指定的元素為 null，并且此列表不允許 null 元素 
IllegalArgumentException - 如果指定元素的某些屬性不允許它添加到此列表 
IndexOutOfBoundsException - 如果索引超出范圍 (index < 0 || index > size())

boolean addAll(Collection c)添加指定 collection 中的所有元素到此列表的結尾，順序是指定 collection 的迭代器返回這些元素的順序（可選操作）。如果在操作正在進行中修改了指定的 collection，那么此操作的行為是不確定的（注意，如果指定的 collection 是此列表，并且它是非空的，則會發生這種情況。） 

指定者：
接口 Collection 中的 addAll
參數：
c - 包含要添加到此列表的元素的 collection 
返回：
如果此列表由于調用而發生更改，則返回 true 
拋出： 
UnsupportedOperationException - 如果列表不支持 addAll 操作 
ClassCastException - 如果指定 collection 的元素的類不允許它添加到此列表 
NullPointerException - 如果指定的 collection 包含一個或多個 null 元素，并且該列表不允許 null 元素，或者指定的 collection 為 null 
IllegalArgumentException - 如果指定 collection 的元素的某些屬性不允許它添加此列表

方法：
    * boolean addAll(int index,Collection c)
功能：
    * 將指定collection中的所有元素都插入到列表中的指定位置（可選操作）。
    * 過程為：將當前處于該位置的元素（如果有的話）和所有后續元素向右移動（增加其索引）。
    * 新元素將按照它們通過指定collection的迭代器所返回的順序出現在此列表中。
    * 如果在操作正在進行中修改了指定的collection，那么該操作的行為是不確定的
      注意，如果指定的collection是此列表，并且它是非空的，則會發生這種情況。
參數：
    * index-將指定collection的第一個元素所插入位置的索引
    * c-包含要添加到此列表的元素的 collection 
返回：
    * 如果此列表由于調用而發生更改，則返回true 
拋出： 
    * UnsupportedOperationException-如果列表不支持addAll操作 
    * ClassCastException-如果指定collection中某個元素的類不允許它添加到此列表 
    * NullPointerException-如果指定的collection包含一個或多個null元素，并且該列表不允許null元素，或者指定的collection為null 
    * IllegalArgumentException-如果指定 collection 的元素的某些屬性不允許它添加到此列表 
    * IndexOutOfBoundsException-如果索引超出范圍 (index < 0 || index > size())

E remove(int index)移除列表中指定位置的元素（可選操作）。將所有的后續元素向左移動（將其索引減 1）。返回從列表中移除的元素。 

參數：
index - 要移除的元素的索引 
返回：
以前在指定位置的元素 
拋出： 
UnsupportedOperationException - 如果列表不支持 remove 操作 
IndexOutOfBoundsException - 如果索引超出范圍 (index < 0 || index >= size())

方法：
    * boolean remove(Object o)
功能：
    * 從此列表中移除第一次出現的指定元素（如果存在）（可選操作）。
    * 如果列表不包含元素，則不更改列表。
    * 即移除滿足(o==null ? get(i)==null : o.equals(get(i)))的最低索引i的元素
     （如果存在這樣的元素）。
    * 如果此列表已包含指定元素（或者此列表由于調用而發生更改），則返回true。 
指定者：
    * Collection接口中的remove方法。
參數：
    * o 要從該列表中移除的元素，如果存在的話 
返回：
    * 如果列表包含指定的元素，則返回true 
拋出： 
    * ClassCastException-如果指定元素的類型和此列表不兼容（可選） 
    * NullPointerException-如果指定的元素是null，并且此列表不允許null元素（可選） 
    * UnsupportedOperationException-如果列表不支持remove 操作

E set(int index,
      E element)用指定元素替換列表中指定位置的元素（可選操作）。 

參數：
index - 要替換的元素的索引
element - 要在指定位置存儲的元素 
返回：
以前在指定位置的元素 
拋出： 
UnsupportedOperationException - 如果列表不支持 set 操作 
ClassCastException - 如果指定元素的類不允許它添加到此列表 
NullPointerException - 如果指定的元素為 null，并且此列表不允許 null 元素 
IllegalArgumentException - 如果指定元素的某些屬性不允許它添加到此列表 
IndexOutOfBoundsException - 如果索引超出范圍 (index < 0 || index >= size())

E get(int index)返回列表中指定位置的元素。 

參數：
index - 要返回的元素的索引 
返回：
列表中指定位置的元素 
拋出： 
IndexOutOfBoundsException - 如果索引超出范圍 (index < 0 || index >= size())

int indexOf(Object o)返回此列表中第一次出現的指定元素的索引；如果此列表不包含該元素，則返回 -1。更確切地講，返回滿足 (o==null ? get(i)==null : o.equals(get(i))) 的最低索引 i；如果沒有這樣的索引，則返回 -1。 

參數：
o - 要搜索的元素 
返回：
此列表中第一次出現的指定元素的索引，如果列表不包含該元素，則返回 -1 
拋出： 
ClassCastException - 如果指定元素的類型和此列表不兼容（可選） 
NullPointerException - 如果指定的元素是 null，并且此列表不允許 null 元素（可選）

int lastIndexOf(Object o)返回此列表中最后出現的指定元素的索引；如果列表不包含此元素，則返回 -1。更確切地講，返回滿足 (o==null ? get(i)==null : o.equals(get(i))) 的最高索引 i；如果沒有這樣的索引，則返回 -1。 

參數：
o - 要搜索的元素 
返回：
列表中最后出現的指定元素的索引；如果列表不包含此元素，則返回 -1 
拋出： 
ClassCastException - 如果指定元素的類型和此列表不兼容（可選） 
NullPointerException - 如果指定的元素是 null，并且此列表不允許 null 元素（可選）

List subList(int fromIndex,
                int toIndex)返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之間的部分視圖。（如果 fromIndex 和 toIndex 相等，則返回的列表為空）。返回的列表由此列表支持，因此返回列表中的非結構性更改將反映在此列表中，反之亦然。返回的列表支持此列表支持的所有可選列表操作。
此方法省去了顯式范圍操作（此操作通常針對數組存在）。通過傳遞 subList 視圖而非整個列表，期望列表的任何操作可用作范圍操作。例如，下面的語句從列表中移除了元素的范圍： 

            list.subList(from, to).clear();
 可以對 indexOf 和 lastIndexOf 構造類似的語句，而且 Collections 類中的所有算法都可以應用于 subList。
如果支持列表（即此列表）通過任何其他方式（而不是通過返回的列表）從結構上修改，則此方法返回的列表語義將變為未定義（從結構上修改是指更改列表的大小，或者以其他方式打亂列表，使正在進行的迭代產生錯誤的結果）。 


參數：
fromIndex - subList 的低端（包括）
toIndex - subList 的高端（不包括） 
返回：
列表中指定范圍的視圖 
拋出： 
IndexOutOfBoundsException - 非法的端點值 (fromIndex < 0 || toIndex > size || fromIndex > toIndex)

ListIterator listIterator()返回此列表元素的列表迭代器（按適當順序）。 

返回：
此列表元素的列表迭代器（按適當順序）

ListIterator listIterator(int index)返回列表中元素的列表迭代器（按適當順序），從列表的指定位置開始。指定的索引表示 next 的初始調用所返回的第一個元素。previous 方法的初始調用將返回索引比指定索引少 1 的元素。 

參數：
index - 從列表迭代器返回的第一個元素的索引（通過調用 next 方法） 
返回：
此列表中元素的列表迭代器（按適當順序），從列表中的指定位置開始 
拋出： 
IndexOutOfBoundsException - 如果索引超出范圍 (index < 0 || index > size())

public interface ListIterator extends Iterator

繼承了Iterator接口，是List特有的Iterator接口，擁有獨特的成員方法。

List專有的迭代器，允許程序員按任一方向遍歷列表、迭代期間修改列表，并獲得迭代器在列表中的當前位置——避免ConcurrentModificationException-并發修改異常。

void add(E e)將指定的元素插入列表（可選操作）。該元素直接插入到 next 返回的下一個元素的前面（如果有），或者 previous 返回的下一個元素之后（如果有）；如果列表沒有元素，那么新元素就成為列表中的唯一元素。新元素被插入到隱式光標前：不影響對 next 的后續調用，并且對 previous 的后續調用會返回此新元素（此調用把調用 nextIndex 或 previousIndex 所返回的值增加 1）。 

參數：
e - 要插入的元素。 
拋出： 
UnsupportedOperationException - 如果列表迭代器不支持 add 操作。 
ClassCastException - 如果指定元素的類不允許該元素添加到此列表。 
IllegalArgumentException - 如果此元素的某個方面不允許該元素添加到此列表。

boolean hasNext()以正向遍歷列表時，如果列表迭代器有多個元素，則返回 true（換句話說，如果 next 返回一個元素而不是拋出異常，則返回 true）。 

指定者：
接口 Iterator 中的 hasNext
返回：
如果以正向遍歷列表，列表迭代器有多個元素，則返回 true。

boolean hasPrevious()如果以逆向遍歷列表，列表迭代器有多個元素，則返回 true。（換句話說，如果 previous 返回一個元素而不是拋出異常，則返回 true）。 

返回：
如果以逆向遍歷列表，列表迭代器有多個元素，則返回 true。

E next()返回列表中的下一個元素。可以重復調用此方法來迭代此列表，或混合調用 previous 來前后移動（注意交替調用 next 和 previous 將重復返回相同的元素）。 

指定者：
接口 Iterator 中的 next
返回：
列表中的下一個元素。 
拋出： 
NoSuchElementException - 如果沒有可迭代的下一個元素。

int nextIndex()返回對 next 的后續調用所返回元素的索引。（如果列表迭代器在列表的結尾，則返回列表的大?。?。 

返回：
對 next 的后續調用所返回元素的索引，如果列表迭代器在列表的結尾，則返回列表大小。

E previous()返回列表中的前一個元素?？梢灾貜驼{用此方法來迭代列表，或混合調用 next 來前后移動（注意交替調用 next 和 previous 將重復返回相同的元素）。 

返回：
列表中的上一個元素。 
拋出： 
NoSuchElementException - 如果沒有可迭代的上一個元素。

int previousIndex()返回對 previous 的后續調用所返回元素的索引。（如果列表迭代器在列表的開始，則返回 -1）。 

返回：
對 previous 的后續調用所返回元素的索引，如果列表迭代器在列表的開始，則返回 -1。

void remove()從列表中移除由 next 或 previous 返回的最后一個元素（可選操作）。對于每個 next 或 previous 調用，只能執行一次此調用。只有在最后一次調用 next 或 previous 之后，尚未調用 ListIterator.add 時才可以執行該調用。 

指定者：
接口 Iterator 中的 remove
拋出： 
UnsupportedOperationException - 如果列表迭代器不支持 remove 操作。 
IllegalStateException - 既沒有調用 next 也沒有調用 previous，或者在最后一次調用 next 或 previous 后調用了 remove 或 add。

void set(E e)用指定元素替換 next 或 previous 返回的最后一個元素（可選操作）。只有在最后一次調用 next 或 previous 后既沒有調用 ListIterator.remove 也沒有調用 ListIterator.add 時才可以進行該調用。 

參數：
e - 用于替換 next 或 previous 返回的最后一個元素的元素。 
拋出： 
UnsupportedOperationException - 如果列表迭代器不支持 set 操作。 
ClassCastException - 如果指定元素的類不允許該元素添加到此列表。 
IllegalArgumentException - 如果指定元素的某個方面不允許該元素添加到此列表。 
IllegalStateException - 如果既沒有調用 next 也沒有調用 previous，或者在最后一次調用 next 或 previous 后調用了 remove 或 add。

public class ArrayList extends AbstractList
implements List, RandomAccess, Cloneable, Serializable

底層數據結構是數組，查詢快，增刪慢

線程不安全，效率高

使用ArrayList類的contains方法判斷是否包含，底層調用的是equals方法，需要考慮是否重寫equals方法。

使用ArrayList類的remove方法刪除元素，底層調用的是equals方法，需要考慮是否重寫equals方法。

方法：
    * public ArrayList()
功能：
    * 構造一個初始容量為10的空列表。 

方法：
    * public ArrayList(Collection c)
功能：
    * 構造一個包含指定collection的元素的列表，這些元素是按照該collection的迭代器返回它們的順序排列的。 
參數：
    * c-其元素將放置在此列表中的collection 
拋出： 
    * NullPointerException-如果指定的collection為null

方法：
    * public ArrayList(int initialCapacity)
功能：
    * 構造一個具有指定初始容量的空列表。 
參數：
    * initialCapacity-列表的初始容量 
拋出： 
    * IllegalArgumentException-如果指定的初始容量為負

方法：
    * public Object clone()
功能：
    * 返回此ArrayList實例的淺表副本。（不復制這些元素本身。） 
覆蓋：
    * Object類中的clone方法
返回：
    * 此ArrayList實例的一個副本

方法：
    * public void ensureCapacity(int minCapacity)
功能：
    * 如有必要，增加此ArrayList實例的容量，以確保它至少能夠容納最小容量參數所指定的元素數。 
參數：
    * minCapacity-所需的最小容量

方法：
    * protected void removeRange(int fromIndex,int toIndex)
方法：
    * 移除列表中索引在fromIndex（包括）和toIndex（不包括）之間的所有元素。
    * 過程：向左移動所有后續元素（減小其索引）。
    * 此調用將列表縮短了 (toIndex - fromIndex) 個元素。（如果 toIndex==fromIndex，則此操作無效。） 
覆蓋：
    * AbstractList類中的removeRange方法
參數：
    * fromIndex-要移除的首個元素的索引。
    * toIndex-最后一個要移除的元素后面那個元素的索引。
拋出： 
    * IndexOutOfBoundsException-如果fromIndex或toIndex超出范圍 
      (fromIndex < 0 || fromIndex >= size() || toIndex > size() || toIndex < fromIndex)

方法：
    * public void trimToSize()
功能：
    * 將此ArrayList實例的容量調整為列表的當前大小。
    * 應用程序可以使用此操作來最小化ArrayList實例的存儲量。 

public class LinkedList extends AbstractSequentialList
implements List, Deque, Cloneable, Serializable

在JDK中是以雙向鏈表實現的。

底層數據結構是鏈表，查詢慢，增刪快

線程不安全，效率高

LinkedList實現了Deque接口，因此，可以操作LinkedList像操作隊列和棧一樣

方法：
    * public LinkedList()
功能：
    * 構造一個空列表。 

方法：
    * public LinkedList(Collection c)
功能：
    * 構造一個包含指定collection中的元素的列表，這些元素按其collection的迭代器返回的順序排列。 
參數：
    * c-要將其元素放入此列表的collection 
拋出： 
    * NullPointerException-如果指定的collection為null

方法：
    * public E getFirst()
功能：
    * 返回此列表的第一個元素。 
指定者：
    * 接口 Deque 中的 getFirst
返回：
    * 此列表的第一個元素 
拋出： 
    * NoSuchElementException - 如果此列表為空

方法：
    * public E getLast()
功能：
    * 返回此列表的最后一個元素。 
指定者：
    * 接口 Deque 中的 getLast
返回：
    * 此列表的最后一個元素 
拋出： 
    * NoSuchElementException - 如果此列表為空

方法：
    * public Object clone()
功能：
    * 返回此LinkedList的淺表副本。（這些元素本身沒有復制。） 
覆蓋：
    * 類Object中的clone。
返回：
    * 此LinkedList實例的淺表副本。

方法：
    * public E getFirst()
功能：
    * 返回此列表的第一個元素。 
指定者：
    * Deque接口中的getFirst方法
返回：
    * 此列表的第一個元素 
拋出： 
    * NoSuchElementException - 如果此列表為空

方法：
    * public E getLast()
功能：
    * 返回此列表的最后一個元素。 
指定者：
    * 接口 Deque 中的 getLast
返回：
    * 此列表的最后一個元素 
拋出： 
    * NoSuchElementException - 如果此列表為空

public E remove()獲取并移除此列表的頭（第一個元素）。 

指定者：
接口 Deque 中的 remove
指定者：
接口 Queue 中的 remove
返回：
列表的頭 
拋出： 
NoSuchElementException - 如果此列表為空

方法：
    * public E removeFirst()
功能：
    * 移除并返回此列表的第一個元素。 
指定者：
    * 接口 Deque 中的 removeFirst
返回：
    * 此列表的第一個元素 
拋出： 
    * NoSuchElementException - 如果此列表為空

方法：
    * public E removeLast()
功能：
    * 移除并返回此列表的最后一個元素。 
指定者：
    * Deque接口中的removeLast方法
返回：
    * 此列表的最后一個元素 
拋出： 
    * NoSuchElementException - 如果此列表為空

public boolean removeFirstOccurrence(Object o)從此列表中移除第一次出現的指定元素（從頭部到尾部遍歷列表時）。如果列表不包含該元素，則不作更改。 

指定者：
接口 Deque 中的 removeFirstOccurrence
參數：
o - 要從此列表中移除的元素（如果存在） 
返回：
如果該列表已包含指定元素，則返回 true

public boolean removeLastOccurrence(Object o)從此列表中移除最后一次出現的指定元素（從頭部到尾部遍歷列表時）。如果列表不包含該元素，則不作更改。 

指定者：
接口 Deque 中的 removeLastOccurrence
參數：
o - 要從此列表中移除的元素（如果存在） 
返回：
如果該列表已包含指定元素，則返回 true

public Iterator descendingIterator()從接口 Deque 復制的描述 
返回以逆向順序在此雙端隊列的元素上進行迭代的迭代器。元素將按從最后一個（尾部）到第一個（頭部）的順序返回。 

指定者：
接口 Deque 中的 descendingIterator
返回：
以逆向順序在此雙端隊列中的元素上進行迭代的迭代器

public E element()獲取但不移除此列表的頭（第一個元素）。 

指定者：
接口 Deque 中的 element
指定者：
接口 Queue 中的 element
返回：
列表的頭 
拋出： 
NoSuchElementException - 如果此列表為空

public boolean offer(E e)將指定元素添加到此列表的末尾（最后一個元素）。 

指定者：
接口 Deque 中的 offer
指定者：
接口 Queue 中的 offer
參數：
e - 要添加的元素 
返回：
true（根據 Queue.offer(E) 的規定）

public boolean offerFirst(E e)在此列表的開頭插入指定的元素。 

指定者：
接口 Deque 中的 offerFirst
參數：
e - 要插入的元素 
返回：
true（根據 Deque.offerFirst(E) 的規定）

public boolean offerLast(E e)在此列表末尾插入指定的元素。 

指定者：
接口 Deque 中的 offerLast
參數：
e - 要插入的元素 
返回：
true（根據 Deque.offerLast(E) 的規定）

public E peek()獲取但不移除此列表的頭（第一個元素）。 

指定者：
接口 Deque 中的 peek
指定者：
接口 Queue 中的 peek
返回：
此列表的頭，如果此列表為空，則返回 null

public E peekFirst()獲取但不移除此列表的第一個元素；如果此列表為空，則返回 null。 

指定者：
接口 Deque 中的 peekFirst
返回：
此列表的第一個元素；如果此列表為空，則返回 null

public E peekLast()獲取但不移除此列表的最后一個元素；如果此列表為空，則返回 null。 

指定者：
接口 Deque 中的 peekLast
返回：
此列表的最后一個元素；如果此列表為空，則返回 null

public E poll()獲取并移除此列表的頭（第一個元素） 

指定者：
接口 Deque 中的 poll
指定者：
接口 Queue 中的 poll
返回：
此列表的頭，如果此列表為空，則返回 null

public E pollFirst()獲取并移除此列表的第一個元素；如果此列表為空，則返回 null。 

指定者：
接口 Deque 中的 pollFirst
返回：
此列表的第一個元素；如果此列表為空，則返回 null

方法：
    * public E pollLast()
功能：    
    * 獲取并移除此列表的最后一個元素；如果此列表為空，則返回 null。 
指定者：
    * 接口Deque中的pollLast
返回：
    * 此列表的最后一個元素；如果此列表為空，則返回null

方法：
    * public E pop()
功能：
    * 從此列表所表示的堆棧處彈出一個元素。
    * 換句話說，移除并返回此列表的第一個元素。 
    * 此方法等效于removeFirst()。 
指定者：
    * 接口Deque中的pop方法
返回：
    * 此列表開頭的元素（它是此列表所表示的堆棧的頂部） 
拋出： 
    * NoSuchElementException-如果此列表為空

方法：
    * public void push(E e)
功能：
    * 將元素推入此列表所表示的堆棧。
    * 換句話說，將該元素插入此列表的開頭。 
    * 此方法等效于addFirst(E)。 
指定者：
    * 接口Deque中的push方法。
參數：
    * e-要推入的元素

public class Vector extends AbstractList
implements List, RandomAccess, Cloneable, Serializable

底層數據結構是數組，查詢快，增刪慢

線程安全，效率低（我們也不用Vector）

字段：
    * protected int capacityIncrement
描述：
    * 向量的大小大于其容量時，容量自動增加的量。
    * 如果容量的增量小于等于零，則每次需要增大容量時，向量的容量將增大一倍。 

字段：
    * protected int elementCountVector 
描述：
    * 對象中的有效組件數。
    * 從 elementData[0] 到 elementData[elementCount-1] 的組件均為實際項。 

字段：
    * protected Object[] elementData
描述：
    * 存儲向量組件的數組緩沖區。vector 的容量就是此數據緩沖區的長度，該長度至少要足以包含向量的所有元素。 
    * Vector 中的最后一個元素后的任何數組元素都為 null。 

方法：
    * public Vector()
功能：
    * 構造一個空向量，使其內部數據數組的大小為 10，其標準容量增量為零。 

方法：
    * public Vector(Collection c)
功能：
    * 構造一個包含指定collection中的元素的向量，這些元素按其collection的迭代器返回元素的順序排列。     
參數：
    * c-其元素要放入此向量中的collection 
拋出： 
    * NullPointerException-如果指定的collection為null

方法：
    * public Vector(int initialCapacity)
功能：
    * 使用指定的初始容量和等于零的容量增量構造一個空向量。 
參數：
    * initialCapacity-向量的初始容量 
拋出： 
    * IllegalArgumentException-如果指定的初始容量為負數

方法：
    * public Vector(int initialCapacity,int capacityIncrement)
功能：
    * 使用指定的初始容量和容量增量構造一個空的向量。 
參數：
    * initialCapacity-向量的初始容量
    * capacityIncrement-當向量溢出時容量增加的量 
拋出： 
    * IllegalArgumentException-如果指定的初始容量為負數

public interface Set extends Collection

一個不包含重復元素的collection

public class HashSet extends AbstractSet
implements Set, Cloneable, Serializable

不保證set的迭代順序，特別是它不保證該順序恒久不變

無索引

底層數據結構是哈希表(元素為鏈表的數組)

哈希表依賴于哈希值存儲

int hashCode()

boolean equals(Object obj)

先使用hashCode方法，再使用equals方法。即若hashCode方法返回的結果相同再使用equals方法。

public class LinkedHashSet extends HashSet
implements Set, Cloneable, Serializable

元素有序唯一

由鏈表保證元素有序

由哈希表保證元素唯一

底層數據結構由哈希表和鏈表組成。

public class TreeSetextends AbstractSet
implements NavigableSet, Cloneable, Serializable

使用元素的自然順序對元素進行排序

或者根據創建set時提供的Comparator進行排序

具體取決于使用的構造方法。

底層數據結構是紅黑樹(紅黑樹是一種自平衡的二叉樹)

保證元素的排序方式

方法：
    * public TreeSet()
功能：
    * 構造一個新的空set，該set根據其元素的自然順序進行排序。
    * 插入該set的所有元素都必須實現Comparable接口。
    * 所有這些元素都必須是可互相比較的：對于set中的任意兩個元素e1和e2，執行e1.compareTo(e2)都不得拋出 ClassCastException。
    * 如果用戶試圖將違反此約束的元素添加到set（例如，用戶試圖將字符串元素添加到其元素為整數的 set 中），則add調用將拋出ClassCastException。 

方法：
    * public TreeSet(Collection c)
功能：
    * 構造一個包含指定collection元素的新TreeSet，它按照其元素的自然順序進行排序。
    * 插入該set的所有元素都必須實現Comparable接口。
    * 另外，所有這些元素都必須是可互相比較的：對于set中的任意兩個元素 e1和e2，執行e1.compareTo(e2)都不得拋出ClassCastException。 
參數：
    * c-一個collection，其元素將組成新的set 
拋出： 
    * ClassCastException-如果c中的元素不是Comparable，或者是不可相互比較的 
    * NullPointerException-如果指定collection為null

方法：
    * public TreeSet(Comparator comparator)
功能：
    * 構造一個新的空 TreeSet，它根據指定比較器進行排序。
    * 插入到該set的所有元素都必須能夠由指定比較器進行相互比較：對于set中的任意兩個元素e1和e2，執行comparator.compare(e1, e2)都不得拋出ClassCastException。
    * 如果用戶試圖將違反此約束的元素添加到set中，則add調用將拋出ClassCastException。 
參數：
    * comparator-將用來對此set進行排序的比較器。如果該參數為null，則使用元素的自然順序。

方法：
    * public TreeSet(SortedSet s)
功能：
    * 構造一個與指定有序set具有相同映射關系和相同排序的新TreeSet。 
參數：
    * s-一個有序set，其元素將組成新set 
拋出： 
    * NullPointerException-如果指定有序set為null

public interface Map

Map是雙列集合。

方法：
    * void clear()
功能：
    * 從此映射中移除所有映射關系（可選操作）。
    * 此調用返回后，該映射將為空。 
拋出： 
    * UnsupportedOperationException-如果此映射不支持clear操作。

方法：
    * boolean containsKey(Object key)
功能：
    * 如果此映射包含指定鍵的映射關系，則返回true。
    * 即當且僅當此映射包含針對滿足 (key==null ? k==null : key.equals(k)) 的鍵k的映射關系時，返回 true，且最多只能有一個這樣的映射關系。 
參數：
    * key-測試是否存在于此映射中的鍵 
返回：
    * 如果此映射包含指定鍵的映射關系，則返回true 
拋出： 
    * ClassCastException-如果該鍵對于此映射是不合適的類型（可選） 
    * NullPointerException-如果指定鍵為null并且此映射不允許null鍵（可選）

方法：
    * boolean containsValue(Object value)
功能：
    * 如果此映射將一個或多個鍵映射到指定值，則返回true。
    * 即當且僅當此映射至少包含一個對滿足 (value==null ? v==null : value.equals(v)) 的值v的映射關系時，返回true。
    * 對于大多數Map接口的實現而言，此操作需要的時間可能與映射大小呈線性關系。 
參數：
    * value-測試是否存在于此映射中的值 
返回：
    * 如果此映射將一個或多個鍵映射到指定值，則返回 true 
拋出： 
    * ClassCastException-如果該值對于此映射是不合適的類型（可選） 
    * NullPointerException-如果指定值為null并且此映射不允許null值（可選）

方法：
    * Set> entrySet()
    * 返回此映射中包含的映射關系的 Set 視圖。該 set 受映射支持，所以對映射的更改可在此 set 中反映出來，反之亦然。如果對該 set 進行迭代的同時修改了映射（通過迭代器自己的 remove 操作，或者通過對迭代器返回的映射項執行 setValue 操作除外），則迭代結果是不確定的。set 支持元素移除，通過 Iterator.remove、Set.remove、removeAll、retainAll 和 clear 操作可從映射中移除相應的映射關系。它不支持 add 或 addAll 操作。 

返回：
    * 此映射中包含的映射關系的 set 視圖

方法：
    * boolean equals(Object o)比較指定的對象與此映射是否相等。如果給定的對象也是一個映射，并且這兩個映射表示相同的映射關系，則返回 true。更確切地講，如果 m1.entrySet().equals(m2.entrySet())，則兩個映射 m1 和 m2 表示相同的映射關系。這可以確保 equals 方法在不同的 Map 接口實現間運行正常。 

覆蓋：
    * 類 Object 中的 equals
參數：
    * o - 要與此映射進行相等性比較的對象 
返回：
    * 如果指定的對象等于此映射，則返回 true

V get(Object key)返回指定鍵所映射的值；如果此映射不包含該鍵的映射關系，則返回 null。 
更確切地講，如果此映射包含滿足 (key==null ? k==null : key.equals(k)) 的鍵 k 到值 v 的映射關系，則此方法返回 v；否則返回 null。（最多只能有一個這樣的映射關系）。 

如果此映射允許 null 值，則返回 null 值并不一定 表示該映射不包含該鍵的映射關系；也可能該映射將該鍵顯示地映射到 null。使用 containsKey 操作可區分這兩種情況。 


參數：
key - 要返回其關聯值的鍵 
返回：
指定鍵所映射的值；如果此映射不包含該鍵的映射關系，則返回 null 
拋出： 
ClassCastException - 如果該鍵對于此映射是不合適的類型（可選） 
NullPointerException - 如果指定鍵為 null 并且此映射不允許 null 鍵（可選）

方法：
    * int hashCode()
功能：
    * 返回此映射的哈希碼值。
    * 映射的哈希碼定義為此映射entrySet()視圖中每個項的哈希碼之和。這確保 m1.equals(m2) 對于任意兩個映射 m1 和 m2 而言，都意味著 m1.hashCode()==m2.hashCode()，正如 Object.hashCode() 常規協定的要求。 

覆蓋：
    * Object類中的hashCode方法。
返回：
    * 此映射的哈希碼值。

方法：
    * boolean isEmpty()
功能：
    * 如果此映射未包含鍵-值映射關系，則返回true。 
返回：
    * 如果此映射未包含鍵-值映射關系，則返回true。

Set keySet()返回此映射中包含的鍵的 Set 視圖。該 set 受映射支持，所以對映射的更改可在此 set 中反映出來，反之亦然。如果對該 set 進行迭代的同時修改了映射（通過迭代器自己的 remove 操作除外），則迭代結果是不確定的。set 支持元素移除，通過 Iterator.remove、Set.remove、removeAll、retainAll 和 clear 操作可從映射中移除相應的映射關系。它不支持 add 或 addAll 操作。 

返回：
此映射中包含的鍵的 set 視圖

V put(K key,V value)將指定的值與此映射中的指定鍵關聯（可選操作）。如果此映射以前包含一個該鍵的映射關系，則用指定值替換舊值（當且僅當 m.containsKey(k) 返回 true 時，才能說映射 m 包含鍵 k 的映射關系）。 

參數：
key - 與指定值關聯的鍵
value - 與指定鍵關聯的值 
返回：
以前與 key 關聯的值，如果沒有針對 key 的映射關系，則返回 null。（如果該實現支持 null 值，則返回 null 也可能表示此映射以前將 null 與 key 關聯）。 
拋出： 
UnsupportedOperationException - 如果此映射不支持 put 操作 
ClassCastException - 如果指定鍵或值的類不允許將其存儲在此映射中 
NullPointerException - 如果指定鍵或值為 null，并且此映射不允許 null 鍵或值 
IllegalArgumentException - 如果指定鍵或值的某些屬性不允許將其存儲在此映射中

void putAll(Map m)從指定映射中將所有映射關系復制到此映射中（可選操作）。對于指定映射中的每個鍵 k 到值 v 的映射關系，此調用等效于對此映射調用一次 put(k, v)。如果正在進行此操作的同時修改了指定的映射，則此操作的行為是不確定的。 

參數：
m - 要存儲在此映射中的映射關系 
拋出： 
UnsupportedOperationException - 如果此映射不支持 putAll 操作 
ClassCastException - 如果指定映射中的鍵或值的類不允許將其存儲在此映射中 
NullPointerException - 如果指定映射為 null，或者此映射不允許 null 鍵或值，并且指定的映射包含 null 鍵或值 
IllegalArgumentException - 如果指定映射中的鍵或值的某些屬性不允許將其存儲在此映射中

方法：
    * V remove(Object key)
功能：
    * 如果存在一個鍵的映射關系，則將其從此映射中移除（可選操作）。更確切地講，如果此映射包含從滿足 (key==null ? k==null :key.equals(k)) 的鍵 k 到值 v 的映射關系，則移除該映射關系。（該映射最多只能包含一個這樣的映射關系。） 
返回此映射中以前關聯該鍵的值，如果此映射不包含該鍵的映射關系，則返回 null。 

如果此映射允許 null 值，則返回 null 值并不一定 表示該映射不包含該鍵的映射關系；也可能該映射將該鍵顯示地映射到 null。 

調用返回后，此映射將不再包含指定鍵的映射關系。 


參數：
key - 從映射中移除其映射關系的鍵 
返回：
以前與 key 關聯的值；如果沒有 key 的映射關系，則返回 null。 
拋出： 
UnsupportedOperationException - 如果此映射不支持 remove 操作 
ClassCastException - 如果該鍵對于此映射是不合適的類型（可選） 
NullPointerException - 如果指定鍵為 null 并且此映射不允許 null 鍵（可選）

方法：
    * int size()
功能：
    * 返回此映射中的鍵-值映射關系數。
    * 如果該映射包含的元素大于Integer.MAX_VALUE，則返回Integer.MAX_VALUE。 
返回：
    * 此映射中的鍵-值映射關系數。

方法：
    * Collection values()
功能：
    * 返回此映射中包含的值的 Collection 視圖。該 collection 受映射支持，所以對映射的更改可在此 collection 中反映出來，反之亦然。如果對該 collection 進行迭代的同時修改了映射（通過迭代器自己的 remove 操作除外），則迭代結果是不確定的。collection 支持元素移除，通過 Iterator.remove、Collection.remove、removeAll、retainAll 和 clear 操作可從映射中移除相應的映射關系。它不支持 add 或 addAll 操作。 

返回：
    * 此映射中包含的值的 collection 視圖

public class HashMap extends AbstractMap
implements Map, Cloneable, Serializable

public class LinkedHashMap extends HashMap
implements Map

public class TreeMap extends AbstractMap
implements NavigableMap, Cloneable, Serializable

鍵是紅黑樹結構，可以保證鍵的排序和唯一性

3. 集合轉數組的方法 4. 集合轉數組的特點

十八、增強for循環 1. 概述

簡化數組和Collection集合的遍歷

for(元素數據類型 變量 : 數組或者Collection集合) {
    /*使用變量即可，該變量就是元素*/
}

簡化遍歷

增強for的目標需要判斷是否為null

普通for循環可以，但是索引要--。

迭代器可以刪除，但是必須要使用迭代器自身的remove方法，不能使用集合的remove方法，否則會出現并發修改異常。

增強for循環不能刪除。