List介面下一共實現了三個類：ArrayList，Vector，LinkedList。
LinkedList主要保持資料的插入順序的時候使用，採用連結串列結構。

ArrayList，Vector主要區別為以下幾點：
（1）：Vector是執行緒安全的，原始碼中有很多的synchronized可以看出，而ArrayList不是。導致Vector效率無法和ArrayList相比；
（2）：ArrayList和Vector都採用線性連續儲存空間，當儲存空間不足的時候，ArrayList預設增加為原來的50%，Vector預設增加為原來的一倍；
（3）：Vector可以設定capacityIncrement，而ArrayList不可以，從字面理解就是capacity容量，Increment增加，容量增長的引數。

原始碼分析：
首先看看構造器：
ArrayList：三個

    /**
     * Constructs an empty list with an initial capacity of ten.
     * 構造一個預設初始容量為10的list 
     */
    public ArrayList() {
        super();
        this.elementData = EMPTY_ELEMENTDATA;
    }

    /**
     * 構造一個指定預設長度的list initialCapacity 不能小於0;
     * Constructs an empty list with the specified initial capacity.
     *
     * @param
 
  initialCapacity  the initial capacity of the list
     * @throws IllegalArgumentException if the specified initial capacity
     *         is negative
     */
    public ArrayList(int initialCapacity) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "
 
+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];
    }




 /**  構造一個包含collection 元素的list
     * Constructs a list containing the elements of the specified
     * collection, in the order they are returned by the collection's
     * iterator.
     *
     * @param c the collection whose elements are to be placed into this list
     * @throws NullPointerException if the specified collection is null
     */
    public ArrayList(Collection<? extends E> c) {
      ...
    }

Vector：四個

//構造一個指定預設長度的list
  public Vector(int initialCapacity) {
        this(initialCapacity, 0);
    }
 //構造一個預設初始容量為10的list 
  public Vector() {
        this(10);
    }
  //構造一個包含collection 元素的list
  public Vector(Collection<? extends E> c) {
        ...
    }
//區別在於可以設定capacityIncrement
 public Vector(int initialCapacity, int capacityIncrement) {
        super();
       ...
    }

vector多了一個public Vector(int initialCapacity, int capacityIncrement)構造器，可以設定容量增長，arraylist是沒有的。

主要新增原始碼分析

ArrayList類：

    public boolean add(E e) {  
        ensureCapacityInternal(size + 1);  // Increments modCount!!  
        elementData[size++] = e;  
        return true;  
    }  

    private void ensureCapacityInternal(int minCapacity) {  
        modCount++;  
        // overflow-conscious code  

        //如果新增一個元素之後，新容器的大小大於容器的容量，那麼就無法存值了，需要擴充空間  
        if (minCapacity - elementData.length > 0)  

            grow(minCapacity);  
    }  

    private void grow(int minCapacity) {  
        // overflow-conscious code  
        int oldCapacity = elementData.length;  
        int newCapacity = oldCapacity + (oldCapacity >> 1); //擴充的空間增加原來的50%（即是原來的1.5倍）  
        if (newCapacity - minCapacity < 0) //如果容器擴容之後還是不夠，那麼幹脆直接將minCapacity設為容器的大小  
            newCapacity = minCapacity;  
        if (newCapacity - MAX_ARRAY_SIZE > 0) //如果擴充的容器太大了的話，那麼就執行hugeCapacity  
            newCapacity = hugeCapacity(minCapacity);  
        // minCapacity is usually close to size, so this is a win:  
        elementData = Arrays.copyOf(elementData, newCapacity);  
    }  

Vector類：

     public synchronized boolean add(E e) {  
         modCount++;  
         ensureCapacityHelper(elementCount + 1);  
         elementData[elementCount++] = e;  
         return true;  
     }  

     private void ensureCapacityHelper(int minCapacity) {  
         // overflow-conscious code  
         if (minCapacity - elementData.length > 0)  
             grow(minCapacity);  
     }  

     private void grow(int minCapacity) {  
         // overflow-conscious code  
         int oldCapacity = elementData.length;  
         int newCapacity = oldCapacity + ((capacityIncrement > 0) ?  
                                          capacityIncrement : oldCapacity);  

         /** 

         這個擴容需要做個判斷：如果容量增量初始化的不是0，即使用的public Vector(int initialCapacity,int capacityIncrement) 

         構造方法進行的初始化，那麼擴容的容量是(oldCapacity+capacityIncrement)，就是原來的容量加上容量增量的值； 

         如果沒有設定容量增量，那麼擴容後的容量就是(oldCapacity+oldCapacity)，就是原來容量的二倍。 

         **/  

         if (newCapacity - minCapacity < 0)  
             newCapacity = minCapacity;  
         if (newCapacity - MAX_ARRAY_SIZE > 0)  
             newCapacity = hugeCapacity(minCapacity);  
         elementData = Arrays.copyOf(elementData, newCapacity);  
     }