轉載請註明出處：http://blog.csdn.net/ns_code/article/details/35793865

Vector簡介

    Vector也是基於陣列實現的，是一個動態陣列，其容量能自動增長。

    Vector是JDK1.0引入了，它的很多實現方法都加入了同步語句，因此是執行緒安全的（其實也只是相對安全，有些時候還是要加入同步語句來保證執行緒的安全），可以用於多執行緒環境。

    Vector沒有絲線Serializable介面，因此它不支援序列化，實現了Cloneable介面，能被克隆，實現了RandomAccess介面，支援快速隨機訪問。

Vector原始碼剖析

    Vector的原始碼如下（加入了比較詳細的註釋）：

package java.util;  
 
public class Vector<E>  
    extends AbstractList<E>  
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable  
{  
     
    // 儲存Vector中資料的陣列  
    protected Object[] elementData;  
 
    // 實際資料的數量  
    protected int elementCount;  
 
    // 容量增長係數  
    protected int capacityIncrement;  
 
    // Vector的序列版本號  
    private static final long serialVersionUID = -2767605614048989439L;  
 
    // Vector建構函式。預設容量是10。  
    public Vector() {  
        this(10);  
    }  
 
    // 指定Vector容量大小的建構函式  
    public Vector(int initialCapacity) {  
        this(initialCapacity, 0);  
    }  
 
    // 指定Vector"容量大小"和"增長係數"的建構函式  
    public Vector(int initialCapacity, int capacityIncrement) {  
        super();  
        if (initialCapacity < 0)  
            throw new IllegalArgumentException("Illegal Capacity: "+  
                                               initialCapacity);  
        // 新建一個陣列，陣列容量是initialCapacity  
        this.elementData = new Object[initialCapacity];  
        // 設定容量增長係數  
        this.capacityIncrement = capacityIncrement;  
    }  
 
    // 指定集合的Vector建構函式。  
    public Vector(Collection<? extends E> c) {  
        // 獲取“集合(c)”的陣列，並將其賦值給elementData  
        elementData = c.toArray();  
        // 設定陣列長度  
        elementCount = elementData.length;  
        // c.toArray might (incorrectly) not return Object[] (see 6260652)  
        if (elementData.getClass() != Object[].class)  
            elementData = Arrays.copyOf(elementData, elementCount, Object[].class);  
    }  
 
    // 將陣列Vector的全部元素都拷貝到陣列anArray中  
    public synchronized void copyInto(Object[] anArray) {  
        System.arraycopy(elementData, 0, anArray, 0, elementCount);  
    }  
 
    // 將當前容量值設為 =實際元素個數  
    public synchronized void trimToSize() {  
        modCount++;  
        int oldCapacity = elementData.length;  
        if (elementCount < oldCapacity) {  
            elementData = Arrays.copyOf(elementData, elementCount);  
        }  
    }  
 
    // 確認“Vector容量”的幫助函式  
    private void ensureCapacityHelper(int minCapacity) {  
        int oldCapacity = elementData.length;  
        // 當Vector的容量不足以容納當前的全部元素，增加容量大小。  
        // 若 容量增量係數>0(即capacityIncrement>0)，則將容量增大當capacityIncrement  
        // 否則，將容量增大一倍。  
        if (minCapacity > oldCapacity) {  
            Object[] oldData = elementData;  
            int newCapacity = (capacityIncrement > 0) ?  
                (oldCapacity + capacityIncrement) : (oldCapacity * 2);  
            if (newCapacity < minCapacity) {  
                newCapacity = minCapacity;  
            }  
            elementData = Arrays.copyOf(elementData, newCapacity);  
        }  
    }  
 
    // 確定Vector的容量。  
    public synchronized void ensureCapacity(int minCapacity) {  
        // 將Vector的改變統計數+1  
        modCount++;  
        ensureCapacityHelper(minCapacity);  
    }  
 
    // 設定容量值為 newSize  
    public synchronized void setSize(int newSize) {  
        modCount++;  
        if (newSize > elementCount) {  
            // 若 "newSize 大於 Vector容量"，則調整Vector的大小。  
            ensureCapacityHelper(newSize);  
        } else {  
            // 若 "newSize 小於/等於 Vector容量"，則將newSize位置開始的元素都設定為null  
            for (int i = newSize ; i < elementCount ; i++) {  
                elementData[i] = null;  
            }  
        }  
        elementCount = newSize;  
    }  
 
    // 返回“Vector的總的容量”  
    public synchronized int capacity() {  
        return elementData.length;  
    }  
 
    // 返回“Vector的實際大小”，即Vector中元素個數  
    public synchronized int size() {  
        return elementCount;  
    }  
 
    // 判斷Vector是否為空  
    public synchronized boolean isEmpty() {  
        return elementCount == 0;  
    }  
 
    // 返回“Vector中全部元素對應的Enumeration”  
    public Enumeration<E> elements() {  
        // 通過匿名類實現Enumeration  
        return new Enumeration<E>() {  
            int count = 0;  
 
            // 是否存在下一個元素  
            public boolean hasMoreElements() {  
                return count < elementCount;  
            }  
 
            // 獲取下一個元素  
            public E nextElement() {  
                synchronized (Vector.this) {  
                    if (count < elementCount) {  
                        return (E)elementData[count++];  
                    }  
                }  
                throw new NoSuchElementException("Vector Enumeration");  
            }  
        };  
    }  
 
    // 返回Vector中是否包含物件(o)  
    public boolean contains(Object o) {  
        return indexOf(o, 0) >= 0;  
    }  
 
 
    // 從index位置開始向後查詢元素(o)。  
    // 若找到，則返回元素的索引值；否則，返回-1  
    public synchronized int indexOf(Object o, int index) {  
        if (o == null) {  
            // 若查詢元素為null，則正向找出null元素，並返回它對應的序號  
            for (int i = index ; i < elementCount ; i++)  
            if (elementData[i]==null)  
                return i;  
        } else {  
            // 若查詢元素不為null，則正向找出該元素，並返回它對應的序號  
            for (int i = index ; i < elementCount ; i++)  
            if (o.equals(elementData[i]))  
                return i;  
        }  
        return -1;  
    }  
 
    // 查詢並返回元素(o)在Vector中的索引值  
    public int indexOf(Object o) {  
        return indexOf(o, 0);  
    }  
 
    // 從後向前查詢元素(o)。並返回元素的索引  
    public synchronized int lastIndexOf(Object o) {  
        return lastIndexOf(o, elementCount-1);  
    }  
 
    // 從後向前查詢元素(o)。開始位置是從前向後的第index個數；  
    // 若找到，則返回元素的“索引值”；否則，返回-1。  
    public synchronized int lastIndexOf(Object o, int index) {  
        if (index >= elementCount)  
            throw new IndexOutOfBoundsException(index + " >= "+ elementCount);  
 
        if (o == null) {  
            // 若查詢元素為null，則反向找出null元素，並返回它對應的序號  
            for (int i = index; i >= 0; i--)  
            if (elementData[i]==null)  
                return i;  
        } else {  
            // 若查詢元素不為null，則反向找出該元素，並返回它對應的序號  
            for (int i = index; i >= 0; i--)  
            if (o.equals(elementData[i]))  
                return i;  
        }  
        return -1;  
    }  
 
    // 返回Vector中index位置的元素。  
    // 若index月結，則丟擲異常  
    public synchronized E elementAt(int index) {  
        if (index >= elementCount) {  
            throw new ArrayIndexOutOfBoundsException(index + " >= " + elementCount);  
        }  
 
        return (E)elementData[index];  
    }  
 
    // 獲取Vector中的第一個元素。  
    // 若失敗，則丟擲異常！  
    public synchronized E firstElement() {  
        if (elementCount == 0) {  
            throw new NoSuchElementException();  
        }  
        return (E)elementData[0];  
    }  
 
    // 獲取Vector中的最後一個元素。  
    // 若失敗，則丟擲異常！  
    public synchronized E lastElement() {  
        if (elementCount == 0) {  
            throw new NoSuchElementException();  
        }  
        return (E)elementData[elementCount - 1];  
    }  
 
    // 設定index位置的元素值為obj  
    public synchronized void setElementAt(E obj, int index) {  
        if (index >= elementCount) {  
            throw new ArrayIndexOutOfBoundsException(index + " >= " +  
                                 elementCount);  
        }  
        elementData[index] = obj;  
    }  
 
    // 刪除index位置的元素  
    public synchronized void removeElementAt(int index) {  
        modCount++;  
        if (index >= elementCount) {  
            throw new ArrayIndexOutOfBoundsException(index + " >= " +  
                                 elementCount);  
        } else if (index < 0) {  
            throw new ArrayIndexOutOfBoundsException(index);  
        }  
 
        int j = elementCount - index - 1;  
        if (j > 0) {  
            System.arraycopy(elementData, index + 1, elementData, index, j);  
        }  
        elementCount--;  
        elementData[elementCount] = null; /* to let gc do its work */ 
    }  
 
    // 在index位置處插入元素(obj)  
    public synchronized void insertElementAt(E obj, int index) {  
        modCount++;  
        if (index > elementCount) {  
            throw new ArrayIndexOutOfBoundsException(index  
                                 + " > " + elementCount);  
        }  
        ensureCapacityHelper(elementCount + 1);  
        System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);  
        elementData[index] = obj;  
        elementCount++;  
    }  
 
    // 將“元素obj”新增到Vector末尾  
    public synchronized void addElement(E obj) {  
        modCount++;  
        ensureCapacityHelper(elementCount + 1);  
        elementData[elementCount++] = obj;  
    }  
 
    // 在Vector中查詢並刪除元素obj。  
    // 成功的話，返回true；否則，返回false。  
    public synchronized boolean removeElement(Object obj) {  
        modCount++;  
        int i = indexOf(obj);  
        if (i >= 0) {  
            removeElementAt(i);  
            return true;  
        }  
        return false;  
    }  
 
    // 刪除Vector中的全部元素  
    public synchronized void removeAllElements() {  
        modCount++;  
        // 將Vector中的全部元素設為null  
        for (int i = 0; i < elementCount; i++)  
            elementData[i] = null;  
 
        elementCount = 0;  
    }  
 
    // 克隆函式  
    public synchronized Object clone() {  
        try {  
            Vector<E> v = (Vector<E>) super.clone();  
            // 將當前Vector的全部元素拷貝到v中  
            v.elementData = Arrays.copyOf(elementData, elementCount);  
            v.modCount = 0;  
            return v;  
        } catch (CloneNotSupportedException e) {  
            // this shouldn't happen, since we are Cloneable  
            throw new InternalError();  
        }  
    }  
 
    // 返回Object陣列  
    public synchronized Object[] toArray() {  
        return Arrays.copyOf(elementData, elementCount);  
    }  
 
    // 返回Vector的模板陣列。所謂模板陣列，即可以將T設為任意的資料型別  
    public synchronized <T> T[] toArray(T[] a) {  
        // 若陣列a的大小 < Vector的元素個數；  
        // 則新建一個T[]陣列，陣列大小是“Vector的元素個數”，並將“Vector”全部拷貝到新陣列中  
        if (a.length < elementCount)  
            return (T[]) Arrays.copyOf(elementData, elementCount, a.getClass());  
 
        // 若陣列a的大小 >= Vector的元素個數；  
        // 則將Vector的全部元素都拷貝到陣列a中。  
    System.arraycopy(elementData, 0, a, 0, elementCount);  
 
        if (a.length > elementCount)  
            a[elementCount] = null;  
 
        return a;  
    }  
 
    // 獲取index位置的元素  
    public synchronized E get(int index) {  
        if (index >= elementCount)  
            throw new ArrayIndexOutOfBoundsException(index);  
 
        return (E)elementData[index];  
    }  
 
    // 設定index位置的值為element。並返回index位置的原始值  
    public synchronized E set(int index, E element) {  
        if (index >= elementCount)  
            throw new ArrayIndexOutOfBoundsException(index);  
 
        Object oldValue = elementData[index];  
        elementData[index] = element;  
        return (E)oldValue;  
    }  
 
    // 將“元素e”新增到Vector最後。  
    public synchronized boolean add(E e) {  
        modCount++;  
        ensureCapacityHelper(elementCount + 1);  
        elementData[elementCount++] = e;  
        return true;  
    }  
 
    // 刪除Vector中的元素o  
    public boolean remove(Object o) {  
        return removeElement(o);  
    }  
 
    // 在index位置新增元素element  
    public void add(int index, E element) {  
        insertElementAt(element, index);  
    }  
 
    // 刪除index位置的元素，並返回index位置的原始值  
    public synchronized E remove(int index) {  
        modCount++;  
        if (index >= elementCount)  
            throw new ArrayIndexOutOfBoundsException(index);  
        Object oldValue = elementData[index];  
 
        int numMoved = elementCount - index - 1;  
        if (numMoved > 0)  
            System.arraycopy(elementData, index+1, elementData, index,  
                     numMoved);  
        elementData[--elementCount] = null; // Let gc do its work  
 
        return (E)oldValue;  
    }  
 
    // 清空Vector  
    public void clear() {  
        removeAllElements();  
    }  
 
    // 返回Vector是否包含集合c  
    public synchronized boolean containsAll(Collection<?> c) {  
        return super.containsAll(c);  
    }  
 
    // 將集合c新增到Vector中  
    public synchronized boolean addAll(Collection<? extends E> c) {  
        modCount++;  
        Object[] a = c.toArray();  
        int numNew = a.length;  
        ensureCapacityHelper(elementCount + numNew);  
        // 將集合c的全部元素拷貝到陣列elementData中  
        System.arraycopy(a, 0, elementData, elementCount, numNew);  
        elementCount += numNew;  
        return numNew != 0;  
    }  
 
    // 刪除集合c的全部元素  
    public synchronized boolean removeAll(Collection<?> c) {  
        return super.removeAll(c);  
    }  
 
    // 刪除“非集合c中的元素”  
    public synchronized boolean retainAll(Collection<?> c)  {  
        return super.retainAll(c);  
    }  
 
    // 從index位置開始，將集合c新增到Vector中  
    public synchronized boolean addAll(int index, Collection<? extends E> c) {  
        modCount++;  
        if (index < 0 || index > elementCount)  
            throw new ArrayIndexOutOfBoundsException(index);  
 
        Object[] a = c.toArray();  
        int numNew = a.length;  
        ensureCapacityHelper(elementCount + numNew);  
 
        int numMoved = elementCount - index;  
        if (numMoved > 0)  
        System.arraycopy(elementData, index, elementData, index + numNew, numMoved);  
 
        System.arraycopy(a, 0, elementData, index, numNew);  
        elementCount += numNew;  
        return numNew != 0;  
    }  
 
    // 返回兩個物件是否相等  
    public synchronized boolean equals(Object o) {  
        return super.equals(o);  
    }  
 
    // 計算雜湊值  
    public synchronized int hashCode() {  
        return super.hashCode();  
    }  
 
    // 呼叫父類的toString()  
    public synchronized String toString() {  
        return super.toString();  
    }  
 
    // 獲取Vector中fromIndex(包括)到toIndex(不包括)的子集  
    public synchronized List<E> subList(int fromIndex, int toIndex) {  
        return Collections.synchronizedList(super.subList(fromIndex, toIndex), this);  
    }  
 
    // 刪除Vector中fromIndex到toIndex的元素  
    protected synchronized void removeRange(int fromIndex, int toIndex) {  
        modCount++;  
        int numMoved = elementCount - toIndex;  
        System.arraycopy(elementData, toIndex, elementData, fromIndex,  
                         numMoved);  
 
        // Let gc do its work  
        int newElementCount = elementCount - (toIndex-fromIndex);  
        while (elementCount != newElementCount)  
            elementData[--elementCount] = null;  
    }  
 
    // java.io.Serializable的寫入函式  
    private synchronized void writeObject(java.io.ObjectOutputStream s)  
        throws java.io.IOException {  
        s.defaultWriteObject();  
    }  
} 

幾點總結

    Vector的原始碼實現總體與ArrayList類似，關於Vector的原始碼，給出如下幾點總結：

    1、Vector有四個不同的構造方法。無參構造方法的容量為預設值10，僅包含容量的構造方法則將容量增長量（從原始碼中可以看出容量增長量的作用，第二點也會對容量增長量詳細說）明置為0。

    2、注意擴充容量的方法ensureCapacityHelper。與ArrayList相同，Vector在每次增加元素（可能是1個，也可能是一組）時，都要呼叫該方法來確保足夠的容量。當容量不足以容納當前的元素個數時，就先看構造方法中傳入的容量增長量引數CapacityIncrement是否為0，如果不為0，就設定新的容量為就容量加上容量增長量，如果為0，就設定新的容量為舊的容量的2倍，如果設定後的新容量還不夠，則直接新容量設定為傳入的引數（也就是所需的容量），而後同樣用Arrays.copyof()方法將元素拷貝到新的陣列。

    3、很多方法都加入了synchronized同步語句，來保證執行緒安全。

    5、其他很多地方都與ArrayList實現大同小異，Vector現在已經基本不再使用。