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不是