Vector源码解析 --基于JDK1.8

结构

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

Vector继承自AbstractList，实现了RandomAccess、Cloneable、java.io.Serializable接口。

属性

	protected Object[] elementData;//动态数组，存放Vector中的元素
	
    protected int elementCount;//动态数组的存放元素的个数
    
    protected int capacityIncrement;//动态数组每次的增长系数

    /** use serialVersionUID from JDK 1.0.2 for interoperability */
    private static final long serialVersionUID = -2767605614048989439L;

构造函数

	/**
     * initialCapacity:Vector的初始容量
     * capacityIncrement：增长系数
     */
	public Vector(int initialCapacity, int capacityIncrement) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        this.elementData = new Object[initialCapacity];
        this.capacityIncrement = capacityIncrement;
    }

    /**
     * 指定初始容量，增长系数默认为0
     */
    public Vector(int initialCapacity) {
        this(initialCapacity, 0);
    }

    /**
     * 默认初始容量为10，增长系数为0
     */
    public Vector() {
        this(10);
    }

    /**
     * 传入集合，把集合转为数组，指定elementData 和elementCount 
     */
    public Vector(Collection<? extends E> c) {
        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);
    }

重要方法

1.扩容机制
Vector的扩容机制和ArrayList相似，都由grow函数决定。发送add操作时调用。

public synchronized void ensureCapacity(int minCapacity) {
        if (minCapacity > 0) {
            modCount++;
            ensureCapacityHelper(minCapacity);
        }
    }

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

当新加入元素后，数组长度不够时调用grow方法。

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);
    }

1. 当定义了capacityIncrement（大于0）时，数组新长度为原长度增长capacityIncrement
   的值，若没有定义capacityIncrement （默认为0），则数组新长度为原长度的两倍。
2. 如果新长度小于最小容量，则数组新长度为最小容量。
3. 如果新长度大于MAX_ARRAY_SIZE（2^31-8）,则新长度为2 ^31。

Vector的扩容判断和ArrayList一致，但是增长系数不一致。

由于Vector是线程安全的，所以执行效率比ArrayList低