java集合详解之Vector

1 特点

• 有序的，可以存储重复值和null值。
• 底层是数组实现的，线程安全。结构与ArrayList非常相似，同样是一个线性的动态可扩容数组。
• 初始容量是10，没有设置扩容增量的情况下以自身的2倍容量扩容，可以设置容量增量，初始容量和扩容量可以通过构造函数public Vector(int initialCapacity, int capacityIncrement)进行初始化。

2 源码分析

2.1 接口的定义和属性

public class Vector<E>
    extends AbstractList<E>
    implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
    /**
     * 存储Vector中的元素的，本身是一个数组
     */
    protected Object[] elementData;

    /**
     * Vector 存储的元素个数，其实就是ArrayList 中的size ，只不过名字不一样而已
     */
    protected int elementCount;

    /**
     * 动态数组的增长系数（增量）。
     * 如果在创建Vector时，指定了capacityIncrement的大小；每次数组容量增加时，增加的大小都是capacityIncrement。
     *如果没有指定则是以自身的2倍容量扩容。
     */
    protected int capacityIncrement;


    private static final long serialVersionUID = -2767605614048989439L;
}

2.2 构造方法

    /**
     * 无参构造，创建一个空的vector,指定内部的数组的大小是10，并且增量是0
     */
    public Vector() {
        this(10);
    }

    /**
     * 指定初始容量，initialCapacity是默认容量大小。增量为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,vector中的元素按照集合的遍历顺序存储
     */
    public Vector(Collection<? extends E> c) {
        Object[] a = c.toArray();
        elementCount = a.length;
        if (c.getClass() == ArrayList.class) {
            elementData = a;
        } else {
            elementData = Arrays.copyOf(a, elementCount, Object[].class);
        }
    }

2.3 add(E element)

实现方式跟ArrayList的add类似，只是方法上多了synchronized和扩容大小不同。

    //添加特定的元素到Vector的尾部，需要注意的是这个方法是synchronized
    public synchronized boolean add(E e) {
        modCount++;
        //在添加元素之前要保证数组大小可以容纳该元素
        ensureCapacityHelper(elementCount + 1);
        elementData[elementCount++] = e;
        return true;
    }

    //确保足够的容量
    private void ensureCapacityHelper(int minCapacity) {
        // 当实际需要的最小容量大于数组的容量，不满足要求的容量则进行扩容
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

    //扩容
    private void grow(int minCapacity) {
        int oldCapacity = elementData.length;
        //如果增量capacityIncrement>0，则根据指定的增量扩容，否则就以原来的一倍扩容
        int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                         capacityIncrement : oldCapacity);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        //创建一个容量为newCapacity的数组，并把数组elementData元素复制到新的数组里
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

    //容量最大值
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    //当超出最大值进行处理
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

2.4 add(int index, E element)

    //插入一个指定的元素到Vector的指定位置    
    public void add(int index, E element) {
        insertElementAt(element, index);
    }

    //将元素插入到指定位置，当前位置及其以后位置都要移动到当前位置的下个位置
    public synchronized void insertElementAt(E obj, int index) {
        modCount++;
        if (index > elementCount) {
            throw new ArrayIndexOutOfBoundsException(index
                                                     + " > " + elementCount);
        }
        //跟add里面的一样，保证数组容量足够
        ensureCapacityHelper(elementCount + 1);
        // 移动当前位置和其后置的元素
        System.arraycopy(elementData, index, elementData, index + 1, elementCount - index);
        elementData[index] = obj;
        elementCount++;
    }

2.5 get(int index)

    //返回Vector中特定位置的的元素
    public synchronized E get(int index) {
        if (index >= elementCount)
            throw new ArrayIndexOutOfBoundsException(index);

        return elementData(index);
    }

其他方法就不一一介绍了，基本和ArrayList实现方式一样，Vector 实现了线程安全，在每个方法上加synchronized 锁。