幾個要掌握的API

1.Stack棧

方法摘要
boolean	empty()           測試堆棧是否爲空。
E	peek()           查看堆棧頂部的對象，但不從堆棧中移除它。
E	pop()           移除堆棧頂部的對象，並作爲此函數的值返回該對象。
E	push(E item)           把項壓入堆棧頂部。
int	search(Object o)           返回對象在堆棧中的位置，以 1 爲基數。

 

從類 java.util.Vector 繼承的方法

add, add,addAll, addAll, addElement, capacity, clear, clone, contains,containsAll, copyInto,elementAt, elements,ensureCapacity, equals,firstElement, get, hashCode, indexOf, indexOf, insertElementAt, isEmpty, lastElement, lastIndexOf, lastIndexOf, remove, remove, removeAll,removeAllElements, removeElement,removeElementAt, removeRange,retainAll, set, setElementAt, setSize, size, subList, toArray,toArray, toString, trimToSize

 

從類 java.util.AbstractList 繼承的方法

iterator, listIterator,listIterator

 

從類 java.lang.Object 繼承的方法

finalize, getClass,notify, notifyAll, wait, wait, wait

從接口 java.util.List 繼承的方法

iterator, listIterator,listIterator

2.Vector向量

public class Vector<E>

extends AbstractList<E>implements List<E>, RandomAccess, Cloneable, Serializable

Vector 類可以實現可增長的對象數組。與數組一樣，它包含可以使用整數索引進行訪問的組件。但是，Vector 的大小可以根據需要增大或縮小，以適應創建Vector 後進行添加或移除項的操作。

每個向量會試圖通過維護 capacity 和 capacityIncrement 來優化存儲管理。capacity 始終至少應與向量的大小相等；這個值通常比後者大些，因爲隨着將組件添加到向量中，其存儲將按capacityIncrement 的大小增加存儲塊。應用程序可以在插入大量組件前增加向量的容量；這樣就減少了增加的重分配的量。

由 Vector 的 iterator 和 listIterator 方法所返回的迭代器是快速失敗的：如果在迭代器創建後的任意時間從結構上修改了向量（通過迭代器自身的 remove 或 add 方法之外的任何其他方式），則迭代器將拋出 ConcurrentModificationException。因此，面對併發的修改，迭代器很快就完全失敗，而不是冒着在將來不確定的時間任意發生不確定行爲的風險。Vector 的 elements 方法返回的 Enumeration不是 快速失敗的。

注意，迭代器的快速失敗行爲不能得到保證，一般來說，存在不同步的併發修改時，不可能作出任何堅決的保證。快速失敗迭代器盡最大努力拋出 ConcurrentModificationException。因此，編寫依賴於此異常的程序的方式是錯誤的，正確做法是：迭代器的快速失敗行爲應該僅用於檢測 bug。

Vector()
          構造一個空向量，使其內部數據數組的大小爲 10，其標準容量增量爲零。

Vector(Collection<? extendsE> c)
          構造一個包含指定 collection 中的元素的向量，這些元素按其 collection 的迭代器返回元素的順序排列。

Vector(int initialCapacity)
          使用指定的初始容量和等於零的容量增量構造一個空向量。

Vector(int initialCapacity, int capacityIncrement)
          使用指定的初始容量和容量增量構造一個空的向量。

 

方法摘要
boolean	add(E e)           將指定元素添加到此向量的末尾。
void	add(int index, E element)           在此向量的指定位置插入指定的元素。
boolean	addAll(Collection<? extendsE> c)           將指定 Collection 中的所有元素添加到此向量的末尾，按照指定 collection 的迭代器所返回的順序添加這些元素。
boolean	addAll(int index, Collection<? extends E> c)           在指定位置將指定 Collection 中的所有元素插入到此向量中。
void	addElement(E obj)           將指定的組件添加到此向量的末尾，將其大小增加 1。
int	capacity()           返回此向量的當前容量。
void	clear()           從此向量中移除所有元素。
Object	clone()           返回向量的一個副本。
boolean	contains(Object o)           如果此向量包含指定的元素，則返回 true。
boolean	containsAll(Collection<?> c)           如果此向量包含指定 Collection 中的所有元素，則返回 true。
void	copyInto(Object[] anArray)           將此向量的組件複製到指定的數組中。
E	elementAt(int index)           返回指定索引處的組件。
Enumeration<E>	elements()           返回此向量的組件的枚舉。
void	ensureCapacity(int minCapacity)           增加此向量的容量（如有必要），以確保其至少能夠保存最小容量參數指定的組件數。
boolean	equals(Object o)           比較指定對象與此向量的相等性。
E	firstElement()           返回此向量的第一個組件（位於索引 0) 處的項）。
E	get(int index)           返回向量中指定位置的元素。
int	hashCode()           返回此向量的哈希碼值。
int	indexOf(Object o)           返回此向量中第一次出現的指定元素的索引，如果此向量不包含該元素，則返回 -1。
int	indexOf(Object o, int index)           返回此向量中第一次出現的指定元素的索引，從 index 處正向搜索，如果未找到該元素，則返回 -1。
void	insertElementAt(E obj, int index)           將指定對象作爲此向量中的組件插入到指定的 index 處。
boolean	isEmpty()           測試此向量是否不包含組件。
E	lastElement()           返回此向量的最後一個組件。
int	lastIndexOf(Object o)           返回此向量中最後一次出現的指定元素的索引；如果此向量不包含該元素，則返回 -1。
int	lastIndexOf(Object o, int index)           返回此向量中最後一次出現的指定元素的索引，從 index 處逆向搜索，如果未找到該元素，則返回 -1。
E	remove(int index)           移除此向量中指定位置的元素。
boolean	remove(Object o)           移除此向量中指定元素的第一個匹配項，如果向量不包含該元素，則元素保持不變。
boolean	removeAll(Collection<?> c)           從此向量中移除包含在指定 Collection 中的所有元素。
void	removeAllElements()           從此向量中移除全部組件，並將其大小設置爲零。
boolean	removeElement(Object obj)           從此向量中移除變量的第一個（索引最小的）匹配項。
void	removeElementAt(int index)           刪除指定索引處的組件。
protected  void	removeRange(int fromIndex, int toIndex)           從此 List 中移除其索引位於 fromIndex（包括）與 toIndex（不包括）之間的所有元素。
boolean	retainAll(Collection<?> c)           在此向量中僅保留包含在指定 Collection 中的元素。
E	set(int index, E element)           用指定的元素替換此向量中指定位置處的元素。
void	setElementAt(E obj, int index)           將此向量指定 index 處的組件設置爲指定的對象。
void	setSize(int newSize)           設置此向量的大小。
int	size()           返回此向量中的組件數。
List<E>	subList(int fromIndex, int toIndex)           返回此 List 的部分視圖，元素範圍爲從 fromIndex（包括）到 toIndex（不包括）。
Object[]	toArray()           返回一個數組，包含此向量中以恰當順序存放的所有元素。
<T> T[]	toArray(T[] a)           返回一個數組，包含此向量中以恰當順序存放的所有元素；返回數組的運行時類型爲指定數組的類型。
String	toString()           返回此向量的字符串表示形式，其中包含每個元素的 String 表示形式。
void	trimToSize()           對此向量的容量進行微調，使其等於向量的當前大小。

 

從類 java.util.AbstractList 繼承的方法

iterator, listIterator,listIterator

 

從類 java.lang.Object 繼承的方法

finalize, getClass,notify, notifyAll, wait, wait, wait

 

從接口 java.util.List 繼承的方法

iterator, listIterator,listIterator

3.Map

接口 Map<K,V>

類型參數：

K - 此映射所維護的鍵的類型

V - 映射值的類型

將鍵映射到值的對象。一個映射不能包含重複的鍵；每個鍵最多隻能映射到一個值。

方法摘要
void	clear()           從此映射中移除所有映射關係（可選操作）。
boolean	containsKey(Object key)           如果此映射包含指定鍵的映射關係，則返回 true。
boolean	containsValue(Object value)           如果此映射將一個或多個鍵映射到指定值，則返回 true。
Set<Map.Entry<K,V>>	entrySet()           返回此映射中包含的映射關係的 Set 視圖。
boolean	equals(Object o)           比較指定的對象與此映射是否相等。
V	get(Object key)           返回指定鍵所映射的值；如果此映射不包含該鍵的映射關係，則返回 null。
int	hashCode()           返回此映射的哈希碼值。
boolean	isEmpty()           如果此映射未包含鍵-值映射關係，則返回 true。
Set<K>	keySet()           返回此映射中包含的鍵的 Set 視圖。
V	put(K key, V value)           將指定的值與此映射中的指定鍵關聯（可選操作）。
void	putAll(Map<? extends K,? extends V> m)           從指定映射中將所有映射關係複製到此映射中（可選操作）。
V	remove(Object key)           如果存在一個鍵的映射關係，則將其從此映射中移除（可選操作）。
int	size()           返回此映射中的鍵-值映射關係數。
Collection<V>	values()           返回此映射中包含的值的 Collection 視圖。

 4.List鏈表

與 set 不同，列表通常允許重複的元素。更確切地講，列表通常允許滿足 e1.equals(e2) 的元素對 e1 和 e2，並且如果列表本身允許 null 元素的話，通常它們允許多個 null 元素。難免有人希望通過在用戶嘗試插入重複元素時拋出運行時異常的方法來禁止重複的列表，但我們希望這種用法越少越好。List 接口在 iterator、add、remove、equals 和 hashCode 方法的協定上加了一些其他約定，試圖添加不合格的元素會拋出未經檢查的異常，通常是 NullPointerException 或 ClassCastException。試圖查詢不合格的元素是否存在可能會拋出異常，也可能簡單地返回 false；某些實現會採用前一種行爲，而某些則採用後者。概括地說，試圖對不合格元素執行操作時，如果完成該操作後不會導致在列表中插入不合格的元素，則該操作可能拋出一個異常，也可能成功，這取決於實現的選擇。此接口的規範中將這樣的異常標記爲“可選”。

方法摘要
boolean	add(E e)           向列表的尾部添加指定的元素（可選操作）。
void	add(int index, E element)           在列表的指定位置插入指定元素（可選操作）。
boolean	addAll(Collection<? extends E> c)           添加指定 collection 中的所有元素到此列表的結尾，順序是指定 collection 的迭代器返回這些元素的順序（可選操作）。
boolean	addAll(int index, Collection<? extends E> c)           將指定 collection 中的所有元素都插入到列表中的指定位置（可選操作）。
void	clear()           從列表中移除所有元素（可選操作）。
boolean	contains(Object o)           如果列表包含指定的元素，則返回 true。
boolean	containsAll(Collection<?> c)           如果列表包含指定 collection 的所有元素，則返回 true。
boolean	equals(Object o)           比較指定的對象與列表是否相等。
E	get(int index)           返回列表中指定位置的元素。
int	hashCode()           返回列表的哈希碼值。
int	indexOf(Object o)           返回此列表中第一次出現的指定元素的索引；如果此列表不包含該元素，則返回 -1。
boolean	isEmpty()           如果列表不包含元素，則返回 true。
Iterator<E>	iterator()           返回按適當順序在列表的元素上進行迭代的迭代器。
int	lastIndexOf(Object o)           返回此列表中最後出現的指定元素的索引；如果列表不包含此元素，則返回 -1。
ListIterator<E>	listIterator()           返回此列表元素的列表迭代器（按適當順序）。
ListIterator<E>	listIterator(int index)           返回列表中元素的列表迭代器（按適當順序），從列表的指定位置開始。
E	remove(int index)           移除列表中指定位置的元素（可選操作）。
boolean	remove(Object o)           從此列表中移除第一次出現的指定元素（如果存在）（可選操作）。
boolean	removeAll(Collection<?> c)           從列表中移除指定 collection 中包含的其所有元素（可選操作）。
boolean	retainAll(Collection<?> c)           僅在列表中保留指定 collection 中所包含的元素（可選操作）。
E	set(int index, E element)           用指定元素替換列表中指定位置的元素（可選操作）。
int	size()           返回列表中的元素數。
List<E>	subList(int fromIndex, int toIndex)           返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之間的部分視圖。
Object[]	toArray()           返回按適當順序包含列表中的所有元素的數組（從第一個元素到最後一個元素）。
<T> T[]	toArray(T[] a)           返回按適當順序（從第一個元素到最後一個元素）包含列表中所有元素的數組；返回數組的運行時類型是指定數組的運行時類型。

5.Set 集合 一個不包含重複元素的 collection。更確切地講，set 不包含滿足 e1.equals(e2) 的元素對 e1 和 e2，並且最多包含一個 null 元素

對這些構造方法的其他規定是（不要奇怪），所有構造方法必須創建一個不包含重複元素的 set（正如上面所定義的）。

注：如果將可變對象用作 set 元素，那麼必須極其小心。如果對象是 set 中某個元素，以一種影響 equals 比較的方式改變對象的值，那麼 set 的行爲就是不確定的。此項禁止的一個特殊情況是不允許某個 set 包含其自身作爲元素。

某些 set 實現對其所包含的元素有所限制。例如，某些實現禁止 null 元素，而某些則對其元素的類型所有限制。試圖添加不合格的元素會拋出未經檢查的異常，通常是 NullPointerException 或 ClassCastException。試圖查詢不合格的元素是否存在可能會拋出異常，也可能簡單地返回 false；某些實現會採用前一種行爲，而某些則採用後者。概括地說，試圖對不合格元素執行操作時，如果完成該操作後不會導致在 set 中插入不合格的元素，則該操作可能拋出一個異常，也可能成功，這取決於實現的選擇。此接口的規範中將這樣的異常標記爲“可選”。 

方法摘要
boolean	add(E e)           如果 set 中尚未存在指定的元素，則添加此元素（可選操作）。
boolean	addAll(Collection<? extends E> c)           如果 set 中沒有指定 collection 中的所有元素，則將其添加到此 set 中（可選操作）。
void	clear()           移除此 set 中的所有元素（可選操作）。
boolean	contains(Object o)           如果 set 包含指定的元素，則返回 true。
boolean	containsAll(Collection<?> c)           如果此 set 包含指定 collection 的所有元素，則返回 true。
boolean	equals(Object o)           比較指定對象與此 set 的相等性。
int	hashCode()           返回 set 的哈希碼值。
boolean	isEmpty()           如果 set 不包含元素，則返回 true。
Iterator<E>	iterator()           返回在此 set 中的元素上進行迭代的迭代器。
boolean	remove(Object o)           如果 set 中存在指定的元素，則將其移除（可選操作）。
boolean	removeAll(Collection<?> c)           移除 set 中那些包含在指定 collection 中的元素（可選操作）。
boolean	retainAll(Collection<?> c)           僅保留 set 中那些包含在指定 collection 中的元素（可選操作）。
int	size()           返回 set 中的元素數（其容量）。
Object[]	toArray()           返回一個包含 set 中所有元素的數組。
<T> T[]	toArray(T[] a)           返回一個包含此 set 中所有元素的數組；返回數組的運行時類型是指定數組的類型。

6.Queue<E>隊列

在處理元素前用於保存元素的 collection。除了基本的 Collection 操作外，隊列還提供其他的插入、提取和檢查操作。每個方法都存在兩種形式：一種拋出異常（操作失敗時），另一種返回一個特殊值（null 或 false，具體取決於操作）。插入操作的後一種形式是用於專門爲有容量限制的 Queue 實現設計的；在大多數實現中，插入操作不會失敗。

	拋出異常	返回特殊值
插入	add(e)	offer(e)
移除	remove()	poll()
檢查	element()	peek()

如果可能，offer 方法可插入一個元素，否則返回 false。這與 Collection.add 方法不同，該方法只能通過拋出未經檢查的異常使添加元素失敗。offer 方法設計用於正常的失敗情況，而不是出現異常的情況，例如在容量固定（有界）的隊列中。

remove() 和 poll() 方法可移除和返回隊列的頭。到底從隊列中移除哪個元素是隊列排序策略的功能，而該策略在各種實現中是不同的。remove() 和 poll() 方法僅在隊列爲空時其行爲有所不同：remove() 方法拋出一個異常，而 poll() 方法則返回 null。

element() 和 peek() 返回，但不移除，隊列的頭。

Queue 接口並未定義阻塞隊列的方法，而這在併發編程中是很常見的。BlockingQueue 接口定義了那些等待元素出現或等待隊列中有可用空間的方法，這些方法擴展了此接口。

Queue 實現通常不允許插入 null 元素，儘管某些實現（如 LinkedList）並不禁止插入 null。即使在允許 null 的實現中，也不應該將 null 插入到 Queue 中，因爲 null 也用作 poll 方法的一個特殊返回值，表明隊列不包含元素。

Queue 實現通常未定義 equals 和 hashCode 方法的基於元素的版本，而是從 Object 類繼承了基於身份的版本，因爲對於具有相同元素但有不同排序屬性的隊列而言，基於元素的相等性並非總是定義良好的。 

方法摘要
boolean	add(E e)           將指定的元素插入此隊列（如果立即可行且不會違反容量限制），在成功時返回 true，如果當前沒有可用的空間，則拋出 IllegalStateException。
E	element()           獲取，但是不移除此隊列的頭。
boolean	offer(E e)           將指定的元素插入此隊列（如果立即可行且不會違反容量限制），當使用有容量限制的隊列時，此方法通常要優於 add(E)，後者可能無法插入元素，而只是拋出一個異常。
E	peek()           獲取但不移除此隊列的頭；如果此隊列爲空，則返回 null。
E	poll()           獲取並移除此隊列的頭，如果此隊列爲空，則返回 null。
E	remove()           獲取並移除此隊列的頭。

從接口 java.util.Collection 繼承的方法

addAll, clear, contains, containsAll, equals, hashCode, isEmpty, iterator, remove, removeAll, retainAll, size, toArray, toArray

7.

類 PriorityQueue<E>優先隊列

優先級隊列的元素按照其自然順序進行排序，或者根據構造隊列時提供的 Comparator 進行排序，具體取決於所使用的構造方法。優先級隊列不允許使用 null 元素。依靠自然順序的優先級隊列還不允許插入不可比較的對象（這樣做可能導致 ClassCastException）。

此隊列的頭 是按指定排序方式確定的最小 元素。如果多個元素都是最小值，則頭是其中一個元素——選擇方法是任意的。隊列獲取操作 poll、remove、peek 和 element 訪問處於隊列頭的元素。

優先級隊列是無界的，但是有一個內部容量，控制着用於存儲隊列元素的數組大小。它通常至少等於隊列的大小。隨着不斷向優先級隊列添加元素，其容量會自動增加。無需指定容量增加策略的細節。

此類及其迭代器實現了 Collection 和 Iterator 接口的所有可選 方法。方法 iterator() 中提供的迭代器不 保證以任何特定的順序遍歷優先級隊列中的元素。如果需要按順序遍歷，請考慮使用 Arrays.sort(pq.toArray())。

注意，此實現不是同步的。如果多個線程中的任意線程修改了隊列，則這些線程不應同時訪問 PriorityQueue 實例。相反，請使用線程安全的 PriorityBlockingQueue 類。

實現注意事項：此實現爲排隊和出隊方法（offer、poll、remove() 和 add）提供 O(log(n)) 時間；爲 remove(Object) 和 contains(Object) 方法提供線性時間；爲獲取方法（peek、element 和 size）提供固定時間。 

構造方法摘要

PriorityQueue()
          使用默認的初始容量（11）創建一個 PriorityQueue，並根據其自然順序對元素進行排序。

PriorityQueue(Collection<? extends E> c)
          創建包含指定 collection 中元素的 PriorityQueue。

PriorityQueue(int initialCapacity)
          使用指定的初始容量創建一個 PriorityQueue，並根據其自然順序對元素進行排序。

PriorityQueue(int initialCapacity, Comparator<? super E> comparator)
          使用指定的初始容量創建一個 PriorityQueue，並根據指定的比較器對元素進行排序。

PriorityQueue(PriorityQueue<? extends E> c)
          創建包含指定優先級隊列元素的 PriorityQueue。

PriorityQueue(SortedSet<? extends E> c)
          創建包含指定有序 set 元素的 PriorityQueue。

 

方法摘要
boolean	add(E e)           將指定的元素插入此優先級隊列。
void	clear()           從此優先級隊列中移除所有元素。
Comparator<? super E>	comparator()           返回用來對此隊列中的元素進行排序的比較器；如果此隊列根據其元素的自然順序進行排序，則返回 null。
boolean	contains(Object o)           如果此隊列包含指定的元素，則返回 true。
Iterator<E>	iterator()           返回在此隊列中的元素上進行迭代的迭代器。
boolean	offer(E e)           將指定的元素插入此優先級隊列。
E	peek()           獲取但不移除此隊列的頭；如果此隊列爲空，則返回 null。
E	poll()           獲取並移除此隊列的頭，如果此隊列爲空，則返回 null。
boolean	remove(Object o)           從此隊列中移除指定元素的單個實例（如果存在）。
int	size()           返回此 collection 中的元素數。
Object[]	toArray()           返回一個包含此隊列所有元素的數組。
<T> T[]	toArray(T[] a)           返回一個包含此隊列所有元素的數組；返回數組的運行時類型是指定數組的類型。

 

從類 java.util.AbstractQueue 繼承的方法

addAll, element, remove

 

從類 java.util.AbstractCollection 繼承的方法

containsAll, isEmpty, removeAll, retainAll, toString

 

從類 java.lang.Object 繼承的方法

clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait

 

從接口 java.util.Collection 繼承的方法

containsAll, equals, hashCode, isEmpty, removeAll, retainAll