Vector源碼分析

public class Vector<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
// 採用線性存儲結構
    protected Object[] elementData;
    // 元素的數量
    protected int elementCount;
    // 容量的增量
    protected int capacityIncrement;

    // 無參構造，指定初始容量爲10，容量增量爲0的一個
    public Vector() {
         this(10);
        }

    // 可以指定初始容量，增量爲0
    public Vector(int initialCapacity) {
            this(initialCapacity, 0);
        }

    // 指定初始容量，並指定增量
    public Vector(int initialCapacity, int capacityIncrement) {
            super();
            if (initialCapacity < 0)
                throw new IllegalArgumentException("Illegal Capacity: "+
                                                   initialCapacity);
            this.elementData = new Object[initialCapacity];
            this.capacityIncrement = capacityIncrement;
        }

    // 獲取vector的容量
    public synchronized int capacity() {
        return elementData.length;
    }

    // 獲得vector的大小
    public synchronized int size() {
        return elementCount;
    }

    // 判斷vector是否爲null
    public synchronized boolean isEmpty() {
        return elementCount == 0;
    }

    // 判斷是否包含該元素
    public int indexOf(Object o) {
        return indexOf(o, 0);
    }

    public synchronized int indexOf(Object o, int index) {
        if (o == null) {
            for (int i = index; i < elementCount; i++)
                if (elementData[i] == null)
                    return i;
        } else {
            for (int i = index; i < elementCount; i++)
                if (o.equals(elementData[i]))
                    return i;
        }
        return -1;
    }

    // 添加元素
    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);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

}

總結：
Vector和ArrayList都採用的是順序存儲結構，但是兩者有不同的地方。
1.Vector可以指定容器的容量增量，而ArrayList不可以。
2.當兩者採用無參構造的時候，Vertor在一初始化就開闢10長度的內存空間，而ArrayList沒有。
3.ArrayList每次擴充容量的一半，而Vector擴充一倍
4.兩者最主要的區別是：Vector是線程安全的，而ArrayList不是