Java集合框架源码——Vector解析

Vector 和 ArrayList 类似，都是基于数组来实现的。但是 Vector 是线程同步（Synchronized）的，所以它也是线程安全的，而 Arraylist 是线程异步的，是不安全的。如果不考虑到线程的安全因素，一般用 ArrayList 效率比较高。
ArrayList 可以参考： Java集合框架源码——ArrayList解析

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

Vector 和 ArrayList 的父类以及实现的接口一样。

属性

    // 实际存放元素的数组
    protected Object[] elementData;
    // 实际元素的数量
    protected int elementCount;
    // 数组每次扩张的大小
    protected int 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);
    }

    // 将给定的集合加入Vector中
    public Vector(Collection<? extends E> c) {
        elementData = c.toArray();
        elementCount = elementData.length;
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, elementCount, Object[].class);
    }

成员函数

各个方法的逻辑基本和 ArrayList 一致，只是都加上了 synchronized 同步关键字。容量扩张这里稍有些不同，其他增删改查方法不再详细分析。

容量调整

trimToSize()

同步的方法，逻辑和 ArrayList 一致

    public synchronized void trimToSize() {
        modCount++;
        int oldCapacity = elementData.length;
        if (elementCount < oldCapacity) {
            elementData = Arrays.copyOf(elementData, elementCount);
        }
    }

ensureCapacity(int minCapacity)

同步的方法，逻辑和 ArrayList 一致。这里 Vector 扩张时，如果没有定义扩张的步长，那么每次扩张都直接扩张为之前的 2 倍大小，而不是像 ArrayList 那样到原来的 1.5 倍大小。

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

    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

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

    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }

setSize(int newSize)

设置 Vector 大小，如果给定大小大于当前元素总数，那么扩张至给定大小，新增元素都为 null ； 如果给定大小不大于当前元素，那么从目标位置开始的元素到最后，都置为 null 。

    public synchronized void setSize(int newSize) {
        modCount++;
        if (newSize > elementCount) {
            ensureCapacityHelper(newSize);
        } else {
            for (int i = newSize ; i < elementCount ; i++) {
                elementData[i] = null;
            }
        }
        elementCount = newSize;
    }

capacity()

当前数组的最大容量。

    public synchronized int capacity() {
        return elementData.length;
    }

size()

当前 Vector 中的元素个数

    public synchronized int size() {
        return elementCount;
    }