從類的定義淺析

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable

public class Vector<E>
    extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable

public
 
 class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable

public abstract class AbstractSequentialList<E> extends AbstractList<E> {

首先從繼承父類來看：

ArrayList & Vector 都繼承了AbstractList 抽象類（提供了
List 介面的預設

其次從實現介面來看：

①、三者都實現了 List 介面（定義了列表必須實現的方法）、Cloneable 介面（可以呼叫Object.clone方法返回該物件的淺拷貝）、java.io.Serializable 介面（支援序列化和反序列化）；
②、ArrayList & Vector 兩者都實現了 RandomAccess 介面（提供了快速隨機訪問儲存的元素的功能），而 LinkedList 實現了 Deque 介面（支援雙向佇列

從類的屬性淺析

ArrayList.java

    private static final int DEFAULT_CAPACITY = 10; // 預設容量
    transient Object[] elementData;                 // 裝元素的容器，不可序列化
    private int size;                               // ArrayList 的大小

Vector.java

    protected Object[] elementData;   // 裝元素的容器
    protected int elementCount;       // Vector 的大小
    protected int capacityIncrement;  // 每次 Vector 容量增加時的增量值

LinkedList.java

    transient int size = 0;     // LinkedList 的大小
    transient Node<E> first;    // 頭指標
    transient Node<E> last;     // 尾指標
    // 結點的定義
    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;
        }
    }

由上原始碼可知：
①、ArrayList & Vector 兩者底層的資料結構是陣列結構，所以改查很快，增刪較慢（又因為 Vector 是執行緒同步的，所以增刪改查都比 ArrayList 慢）。而 LinkedList 的底層的資料結構是連結串列結構，所以改查較慢，增刪較快。
②、ArrayList & Vector 底層都維護了一個 Object[] 物件陣列用於儲存物件，預設陣列的長度是 10。但是 ArrayList 的物件陣列，通過 transient 修飾，不可序列化。
③、Vector 維護了一個 capacityIncrement 欄位，可以通過構造器去設定每次擴容的大小，而 ArrayList 沒有。

從類的擴容方法淺析

ArrayList.java

    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // 擴容
        elementData[size++] = e;
        return true;
    }
    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        ensureExplicitCapacity(minCapacity);
    }
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    private void grow(int minCapacity) {
        int oldCapacity = elementData.length;
        // 陣列擴容：增大 0.5 倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

Vector.java

    public synchronized boolean add(E e) {
        modCount++;
        // 擴容方法
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }
    private void ensureCapacityHelper(int minCapacity) {
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    private void grow(int minCapacity) {
        int oldCapacity = elementData.length;
        // 陣列擴容：增大 1 倍（capacityIncrement  表示每次 Vector 容量增加時的增量值）
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

由上原始碼可知：
ArrayList 擴容時，容量自動增長為原來的容量的 1.5 倍，而 Vector 的容量自動增長為原來的容量的 2 倍。

從遍歷的方法淺析

三者都支援三種遍歷方式：for-each()（幾乎與迭代器一樣）、迭代器方式、下標遞增或遞減迴圈。
ArrayList，下標遞增或遞減迴圈方式是速度最快的，但是 for-each() 實現更加簡單，且速度沒慢太多，推薦使用。
LinkedList，for-each() 方式是速度最快的。

總結

①、
ArrayList & Vector 支援隨機訪問；
LinkedList 只支援按次序訪問；

②、
三者都定義了列表必須實現的方法、可以呼叫Object.clone方法返回該物件的淺拷貝、支援序列化和反序列化；

③、
ArrayList & Vector 提供了隨機訪問功能；
LinkedList 支援雙向佇列；

④、
ArrayList & Vector 是陣列結構，所以改查很快，增刪較慢（又因為 Vector 是執行緒同步的，所以增刪改查都比 ArrayList 慢）。
LinkedList 是連結串列結構，所以改查較慢，增刪較快。

⑤、
ArrayList & Vector 底層都維護了一個 Object[] 物件陣列用於儲存物件，預設陣列的長度是 10。
但是 ArrayList 的物件陣列，通過 transient 修飾，不可序列化。

⑥、
Vector 維護了一個 capacityIncrement 欄位，可以通過構造器去設定每次擴容的大小，而 ArrayList 沒有。

⑦、
ArrayList 擴容時，容量自動增長為原來的容量的 1.5 倍；
Vector 擴容時，容量自動增長為原來的容量的 2 倍。

⑧、
無論哪種，都推薦使用 for-each() 遍歷的方式。

注意：Vector 屬於遺留容器，已經不推薦使用。

Q：但 ArrayList 和 LinkedListed 都是非執行緒安全的，所以如果遇到多個執行緒操作同一個容器的場景，該怎麼處理？
A：可以通過工具類 Collections 中的 synchronizedList() 方法將其轉換成執行緒安全的容器後再使用（這是對裝潢模式的應用，將已有物件傳入另一個類的構造器中建立新的物件來增強實現）。