ArrayList和Vector是採用陣列方式儲存資料，此陣列元素總數大於實際儲存的資料個數以便增加和插入元素，二者都允許直接序號索引元素，但是插入資料要移動陣列元素等記憶體操作，所以它們索引資料快、插入資料慢。

private transient Object[] elementData;public ArrayList(int initialCapacity) {    super();    if (initialCapacity < 0)        throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);    this
 
.elementData = new Object[initialCapacity];} // 空建構函式，預設容量大小為10public ArrayList() {    this(10);}public ArrayList(Collection<? extends E> c) {    elementData = c.toArray();    size = elementData.length;    // c.toArray might (incorrectly) not return Object[] (see 6260652)    if (elementData.getClass() != Object[].class)        elementData = Arrays.copyOf(elementData, size, Object[].class);}
 

Vector由於使用了synchronized同步方法（如add、insert、remove、set、equals、hashcode等操作），因此是執行緒安全，效能上比ArrayList要差。

protected Object[] elementData;protected int capacityIncrement;public Vector(int initialCapacity, int capacityIncrement) {    super();    if (initialCapacity < 0)        throw new IllegalArgumentException("Illegal Capacity: "
 
+ initialCapacity);    this.elementData = new Object[initialCapacity];    this.capacityIncrement = capacityIncrement;}// 設定容量大小為initialCapacity，預設增長個數為0public Vector(int initialCapacity) {    this(initialCapacity, 0);}// 空建構函式，預設容量大小為10public Vector() {    this(10);}

LinkedList使用雙向連結串列實現儲存，按序號索引資料需要進行向前或向後遍歷，但是插入資料時只需要記錄本項的前後項即可，所以插入數度較快！

LinkedList雙向連結串列，是指可以從first依次遍歷至last（從頭到尾），也可以從last遍歷至first（從尾到頭），但首尾沒有構成環，不同於雙向迴圈連結串列（注意區分）：

 transient Node<E> first; transient Node<E> last; public LinkedList() { } private void linkFirst(E e) {        final Node<E> f = first;        final Node<E> newNode = new Node<>(null, e, f);  // 插入新節點，同時連線首、尾節點        first = newNode;        if (f == null)   // 起始節點為空（null），表示插入後有且只有一個節點，因此first = last = newNode            last = newNode;        else            f.prev = newNode;        size++;        modCount++;    }    void linkLast(E e) {        final Node<E> l = last;        final Node<E> newNode = new Node<>(l, e, null);  // 插入新節點，同時連線首、尾節點        last = newNode;        if (l == null)   // 末尾節點為空（null），表示插入後有且只有一個節點，因此first = last = newNode            first = newNode;        else            l.next = newNode;        size++;        modCount++;    }

其中，Node類結構如下：

 private static class Node<E> {        E item;        Node<E> next;        Node<E> prev;        Node(Node<E> prev, E element, Node<E> next) {            this.item = element; // 節點資料            this.next = next;  // 連線下一節點            this.prev = prev;  // 連線上一節點        }    }

線性表、連結串列、雜湊表是常用的資料結構，在進行Java開發時，JDK已經為我們提供了一系列相應的類來實現基本的資料結構，這些類均在java.util包中。

|--------List 
|----------LinkedList
|----------ArrayList 
|----------Vector 
|-----Stack 
|--------Set 
|----------HashSet. 
|-----LinkedHashSet 
|----------SortedSet 
|-----TreeSet 

Collection. 
● 實現該介面及其子介面的所有類都可應用clone()方法，並是序列化類. 

.....List. 
.....● 可隨機訪問包含的元素 
.....● 元素是有序的 
.....● 可在任意位置增、刪元素 
.....● 不管訪問多少次，元素位置不變 
.....● 允許重複元素 
.....● 用Iterator實現單向遍歷，也可用ListIterator實現雙向遍歷 

..........ArrayList 
..........● 用陣列作為根本的資料結構來實現List 
..........● 元素順序儲存 
..........● 新增元素改變List大小時，內部會新建一個數組，在將新增元素前將所有資料拷貝到新陣列中 
..........● 隨機訪問很快，刪除非頭尾元素慢，新增元素慢而且費資源 
..........● 較適用於無頻繁增刪的情況 
..........● 比陣列效率低，如果不是需要可變陣列，可考慮使用陣列 
..........● 非執行緒安全 

..........Vector. 
..........● 另一種ArrayList，具備ArrayList的特性 
..........● 所有方法都是執行緒安全的（雙刃劍，和ArrayList的主要區別） 
..........● 比ArrayList效率低 

...............Stack 
...............● LIFO的資料結構 

..........LinkedList. 
..........● 連結物件資料結構（類似連結串列） 
..........● 隨機訪問很慢，增刪操作很快，不耗費多餘資源 
..........● 非執行緒安全 

.....Set. 
.....● 不允許重複元素，可以有一個空元素 
.....● 不可隨機訪問包含的元素 
.....● 只能用Iterator實現單向遍歷 

..........HashSet 
..........● 用HashMap作為根本資料結構來實現Set 
..........● 元素是無序的 
..........● 迭代訪問元素的順序和加入的順序不同 
..........● 多次迭代訪問，元素的順序可能不同 
..........● 非執行緒安全 

...............LinkedHashSet 
...............● 基於HashMap和連結串列的Set實現 
...............● 迭代訪問元素的順序和加入的順序相同 
...............● 多次迭代訪問，元素的順序不變  
...............● 因此可說這是一種有序的資料結構 
...............● 效能比HashSet差 
...............● 非執行緒安全 

..........SortedSet 
..........● 加入SortedSet的所有元素必須實現Comparable介面 
..........● 元素是有序的 

...............TreeSet. 
...............● 基於TreeMap實現的SortedSet 
...............● 排序後按升序排列元素 
...............● 非執行緒安全 

Collection是最基本的集合介面，一個Collection代表一組Object，即Collection的元素（Elements）。一些Collection允許相同的元素而另一些不行，一些能排序而另一些不行。Java SDK不提供直接繼承自Collection的類，Java SDK提供的類都是繼承自Collection的“子介面”如List和Set。

所有實現Collection介面的類都必須提供兩個標準的建構函式：

1）無引數的建構函式，用於建立一個空的Collection

2）有一個Collection引數的建構函式，用於建立一個新的Collection，這個新的Collection與傳入的Collection有相同的元素。

後一個建構函式允許使用者複製一個Collection。

如何遍歷Collection中的每一個元素？

不論Collection的實際型別如何，它都支援一個iterator()的方法，該方法返回一個迭代子，使用該迭代子即可逐一訪問Collection中每一個元素。典型的用法如下：

除了具有Collection介面必備的iterator()方法外，List還提供一個listIterator()方法，返回一個ListIterator介面，和標準的Iterator介面相比，ListIterator多了一些add()之類的方法，允許新增，刪除，設定元素，還能向前或向後遍歷。

LinkedList實現了List介面，允許null元素。此外在LinkedList的首部或尾部提供額外的get、remove、insert方法。

這些操作使LinkedList可被用作堆疊（stack），佇列（queue）或雙向佇列（deque）。

每個ArrayList例項都有一個容量（Capacity），即用於儲存元素的陣列的大小。這個容量可隨著不斷新增新元素而自動增加，但是增長演算法並沒有定義。當需要插入大量元素時，在插入前可以呼叫ensureCapacity方法來增加ArrayList的容量以提高插入效率。

 public void ensureCapacity(int minCapacity) {  // minCapacity： 期望設定的最小容量大小        if (minCapacity > 0)            ensureCapacityInternal(minCapacity);  // 內部方法實現（private）    }  private void ensureCapacityInternal(int minCapacity) {        modCount++;        // overflow-conscious code        if (minCapacity - elementData.length > 0)  // 如果期望的最小容量minCapacity大於當前元素個數，則設定            grow(minCapacity);    }  private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;    private void grow(int minCapacity) {        // overflow-conscious code        int oldCapacity = elementData.length;        int newCapacity = oldCapacity + (oldCapacity >> 1);  // 增長當前元素個數的1/2，即增長後為原先元素總量的3/2          if (newCapacity - minCapacity < 0)  // 設定的minCapacity大於自動增長的容量，則按minCapacity最大設定（即取最大的容量）            newCapacity = minCapacity;        if (newCapacity - MAX_ARRAY_SIZE > 0) // 超過了VMs最大的記憶體分配空間（注：Integer.MAX_VALUE - 8;其中減去8位元組是因為Integer附加資訊額外佔用了8個位元組）            newCapacity = hugeCapacity(minCapacity);        // minCapacity is usually close to size, so this is a win:        elementData = Arrays.copyOf(elementData, newCapacity);    }    private static int hugeCapacity(int minCapacity) {        if (minCapacity < 0) // overflow            throw new OutOfMemoryError();        return (minCapacity > MAX_ARRAY_SIZE) ?            Integer.MAX_VALUE :            MAX_ARRAY_SIZE;    }

Vector非常類似ArrayList，但是Vector是同步的。

由Vector建立的Iterator，雖然和ArrayList建立的Iterator是同一介面，但是，因為Vector是同步的，當一個Iterator被建立而且正在被使用，另一個執行緒改變了Vector的狀態（例如，新增或刪除了一些元素），這時呼叫Iterator的方法時將丟擲ConcurrentModificationException，因此必須捕獲該異常。

Stack繼承自Vector，也是同步的，實現一個後進先出的堆疊。Stack提供5個額外的方法使得Vector得以被當作堆疊使用。基本的push和pop方法，還有peek方法得到棧頂的元素，empty方法測試堆疊是否為空，search方法檢測一個元素在堆疊中的位置。

Stack剛建立後是空棧。

Map

Map 
● 鍵值對，鍵和值一一對應 
● 不允許重複的鍵. 

.....Hashtable. 
.....● 用作鍵的物件必須實現了hashcode()、equals()方法，也就是說只有Object及其子類可用作鍵 
.....● 鍵、值都不能是空物件 
.....● 多次訪問，對映元素的順序相同 
.....● 執行緒安全的 

..........Properties 
..........● 鍵和值都是字串 

.....HashMap 
.....● 鍵和值都可以是空物件 
.....● 不保證對映的順序 
.....● 多次訪問，對映元素的順序可能不同 
.....● 非執行緒安全 

...............LinkedHashMap 
...............● 多次訪問，對映元素的順序是相同的 
...............● 效能比HashMap差 

.....WeakHashMap.. 
.....● 當某個鍵不再正常使用時，垃圾收集器會移除它，即便有對映關係存在 
.....● 非執行緒安全 

.....SortedMap. 
.....● 鍵按升序排列 
.....● 所有鍵都必須實現.Comparable.介面. 

...............TreeMap. 
...............● 基於紅黑樹的SortedMap實現 
...............● 非執行緒安全

Map沒有繼承Collection介面，Map提供key到value的對映。一個Map中不能包含相同的key，每個key只能對映一個value。

Map介面提供3種集合的檢視，Map的內容可以被當作一組key集合，一組value集合，或者一組key-value對映。

Map介面定義：

public interface Map<K,V> { int size(); boolean isEmpty();  boolean containsKey(Object key); boolean containsValue(Object value);  V get(Object key); V put(K key, V value); V remove(Object key);  void putAll(Map<? extends K, ? extends V> m); void clear();  Set<K> keySet();      // key 集合 Collection<V> values();     // value 集合 Set<Map.Entry<K, V>> entrySet();  // key-value 集合  interface Entry<K,V> {  K getKey();  V getValue();  V setValue(V value);    boolean equals(Object o);  int hashCode(); }  boolean equals(Object o); int hashCode();}

Hashtable通過initial capacity和load factor兩個引數調整效能。通常預設的load factor 0.75較好地實現了時間和空間的均衡。增大load factor可以節省空間但相應的查詢時間將增大，這會影響像get和put這樣的操作。

 private transient Entry[] table; // 陣列實現 private float loadFactor; public Hashtable(int initialCapacity, float loadFactor) {        if (initialCapacity < 0)            throw new IllegalArgumentException("Illegal Capacity: " + initialCapacity);        if (loadFactor <= 0 || Float.isNaN(loadFactor))            throw new IllegalArgumentException("Illegal Load: " + loadFactor);        if (initialCapacity==0)  // 初始容量為0時，預設設定為1            initialCapacity = 1;        this.loadFactor = loadFactor;        table = new Entry[initialCapacity];        threshold = (int)(initialCapacity * loadFactor); // 實際閾值    } public Hashtable(int initialCapacity) {        this(initialCapacity, 0.75f); // 預設 loadFactor = 0.75f    }  public Hashtable() {        this(11, 0.75f);  // 預設 initialCapacity = 11， loadFactor = 0.75f    }  public Hashtable(Map<? extends K, ? extends V> t) {        this(Math.max(2*t.size(), 11), 0.75f);  // 申請兩倍Map大小，與預設11比較，取其大        putAll(t);    }

由於作為key的物件將通過計算其雜湊函式來確定與之對應的value的位置，因此任何作為key的物件都必須實現hashCode和equals方法。

hashCode和equals方法繼承自根類Object，如果你用自定義的類當作key的話，要相當小心，按照雜湊函式的定義，如果兩個物件相同，即obj1.equals(obj2)=true，則它們的hashCode必須相同，但如果兩個物件不同，則它們的hashCode不一定不同，如果兩個不同物件的hashCode相同，這種現象稱為衝突，衝突會導致操作雜湊表的時間開銷增大，所以儘量定義好的hashCode()方法，能加快雜湊表的操作。

如果相同的物件有不同的hashCode，對雜湊表的操作會出現意想不到的結果（期待的get方法返回null），要避免這種問題，只需要牢記一條：要同時複寫equals方法和hashCode方法，而不要只寫其中一個。

HashMap和Hashtable類似，不同之處在於HashMap是非同步的，並且允許null，即null value和null key。

但是將HashMap視為Collection時（values()方法可返回Collection），其迭代子操作時間開銷和HashMap的容量成比例。因此，如果迭代操作的效能相當重要的話，不要將HashMap的初始化容量設得過高，或者load factor過低。

 static final int DEFAULT_INITIAL_CAPACITY = 16;  // 預設 initialCapacity = 16（2指數的整倍數） static final int MAXIMUM_CAPACITY = 1 << 30;  // 最大容量（向左位移30位而不是31位，是因為int最高位為符號位） static final float DEFAULT_LOAD_FACTOR = 0.75f;  // 預設 loadFactor = 0.75f  transient Entry[] table; int threshold; final float loadFactor;  public HashMap(int initialCapacity, float loadFactor) {        if (initialCapacity < 0)            throw new IllegalArgumentException("Illegal initial capacity: " + initialCapacity);        if (initialCapacity > MAXIMUM_CAPACITY)  // 超過最大容量時，則重置為最大容量            initialCapacity = MAXIMUM_CAPACITY;        if (loadFactor <= 0 || Float.isNaN(loadFactor))            throw new IllegalArgumentException("Illegal load factor: " + loadFactor);        // Find a power of 2 >= initialCapacity        int capacity = 1;        while (capacity < initialCapacity)            capacity <<= 1;  // 容量大小以2的指數級增長        this.loadFactor = loadFactor;        threshold = (int)(capacity * loadFactor);        table = new Entry[capacity];        init();    }  void init() {    }  public HashMap(int initialCapacity) {        this(initialCapacity, DEFAULT_LOAD_FACTOR);    }  public HashMap() {        this.loadFactor = DEFAULT_LOAD_FACTOR;        threshold = (int)(DEFAULT_INITIAL_CAPACITY * DEFAULT_LOAD_FACTOR);        table = new Entry[DEFAULT_INITIAL_CAPACITY];        init();    }  public HashMap(Map<? extends K, ? extends V> m) {        this(Math.max((int) (m.size() / DEFAULT_LOAD_FACTOR) + 1, DEFAULT_INITIAL_CAPACITY), DEFAULT_LOAD_FACTOR);        putAllForCreate(m);    }

Vector是同步的。這個類中的一些方法保證了Vector中的物件是執行緒安全的。

ArrayList則是非同步的，因此ArrayList中的物件並不是執行緒安全的。

因為同步的要求會影響執行的效率，所以如果你不需要執行緒安全的集合那麼使用ArrayList是一個很好的選擇，這樣可以避免由於同步帶來的不必要的效能開銷。

2） 資料增長

從內部實現機制來講ArrayList和Vector都是使用陣列(Array)來控制集合中的物件。

當你向這兩種型別中增加（插入）元素的時候，如果元素的數目超出了內部陣列目前的長度，它們都需要擴充套件內部陣列的長度，Vector預設情況下自動增長原來一倍的陣列長度，ArrayList是原來的50%，所以最後你獲得的這個集合所佔的空間總是比你實際需要的要大。所以如果你要在集合中儲存大量的資料那麼使用Vector有一些優勢，因為你可以通過設定集合的初始化大小來避免不必要的資源開銷。

3） 使用模式

在ArrayList和Vector中，從一個指定的位置（通過索引）查詢資料或是在集合的末尾增加、移除一個元素所花費的時間是一樣的，這個時間我們用O(1)表示。

但是，如果在集合的其他位置增加或移除元素那麼花費的時間會呈線形增長：O(n-i)，其中n代表集合中元素的個數，i代表元素增加或移除元素的索引位置。為什麼會這樣呢？以為在進行上述操作的時候集合中第i和第i個元素之後的所有元素都要執行位移的操作。這一切意味著什麼呢？

這意味著，你只是查詢特定位置的元素或只在集合的末端增加、移除元素，那麼使用Vector或ArrayList都可以。如果是其他操作，你最好選擇其他的集合操作類。比如，LinkList集合類在增加或移除集合中任何位置的元素所花費的時間都是一樣的?O(1)，但它在查詢索引一個元素的使用時卻比較慢O(i)，其中i是索引的位置。

使用ArrayList也很容易，因為你可以簡單的使用索引來代替建立iterator物件的操作。

LinkList也會為每個插入的元素建立物件，所有你要明白它也會帶來額外的開銷。

最後，在《Practical Java》一書中Peter Haggar建議使用一個簡單的陣列（Array）來代替Vector或ArrayList。尤其是對於執行效率要求高的程式更應如此。因為使用陣列(Array)避免了同步、額外的方法呼叫和不必要的重新分配空間的操作。

總結

如果涉及到堆疊、佇列等操作，應該考慮用List；

對於需要快速插入，刪除元素，應該使用LinkedList；

如果需要快速隨機訪問元素，應該使用ArrayList。

如果程式在單執行緒環境中，或者訪問僅僅在一個執行緒中進行，考慮非同步的類，其效率較高，

如果多個執行緒可能同時操作一個類，應該使用同步的類。

參考推薦：