Vector源码解析

Vector

构造函数

protected Object[] elementData;//用于存储对象

public Vector() {
    this(10);//初始化 Vector容量为10
}

public Vector(int initialCapacity) {
    // 初始化容量=10，容量增长=0
    this(initialCapacity, 0);
}

public Vector(int initialCapacity, int capacityIncrement) {
    super();
    // 初始化容量小于0，直接抛出异常
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
    // 初始化
    this.elementData = new Object[initialCapacity];//new一个固定容量（长度）的数组，并赋值给elementData
    this.capacityIncrement = capacityIncrement;//容量增长0赋值给capacityIncrement
}

add

protected transient int modCount = 0;
protected int elementCount;

public synchronized boolean add(E e) {
    modCount++;// 修改次数+1
    ensureCapacityHelper(elementCount + 1);//确保容量支持添加新元素，传入扩展后应该的最小长度
    elementData[elementCount++] = e;
    return true;
}

ensureCapacityHelper 确保容量支持添加新元素方法

private void ensureCapacityHelper(int minCapacity) {
    // overflow-conscious code
    // 由add中代码可知，minCapacity=elementCount+1，这个if是一定能进的
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);//传入elementCount扩展后应该的最小长度，此时elementCount并未被修改
}

grow

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;// 获取 当前elementData中的元素个数
    // 计算 新elementData的长度（新长度），增长量(capacityIncrement)大于0，取增长量，否则取旧长度
    int newCapacity = oldCapacity + ((capacityIncrement > 0) ? capacityIncrement : oldCapacity);
    // newCapacity < minCapacity 新长度 小于 扩展后应该的最小长度 证明新长度扩容不足，将扩展后应该的最小长度赋值给新长度
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    //  newCapacity > minCapacity 新长度 大于 扩展后应该的最小长度 证明新长度扩容足够，但是超出容量限制未知，所以调用了hugeCapacity用于防止超限
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    elementData = Arrays.copyOf(elementData, newCapacity);//生成一个新数组，并把此数组赋给elementData
}
// hugeCapacity目的是：防止扩容超出限制
private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE;
}

Arrays.copyOf

public static <T> T[] copyOf(T[] original, int newLength) {
    // 返回一个新数组，这个数组拷贝了original中的元素，并且长度为newLength
    return (T[]) copyOf(original, newLength, original.getClass());
}

remove

public synchronized E remove(int index) {
    modCount++;// 修改次数+1
    if (index >= elementCount)
        // 判断下标是否大于等于Vector的元素总量，大于等于证明越界了，抛出越界异常
        throw new ArrayIndexOutOfBoundsException(index);
    E oldValue = elementData(index);// 根据下标获取对象
    int numMoved = elementCount - index - 1;// 计算“待移除的元素”后面的元素数量
    if (numMoved > 0)
        //在原数组上操作，移除待删除元素。System.arraycopy是一个本地方法
        System.arraycopy(elementData, index+1, elementData, index, numMoved);
    elementData[--elementCount] = null; // Let gc do its work
    return oldValue;// 返回被删除的对象
}

System.arraycopy

public static native void arraycopy(Object src,int srcPos,Object dest,int destPos,int length);

由源码可知Vector和ArrayList的实现方式是一样的——基于数组实现，不同点是Vector是线程安全的，因为它的方法加了synchronized关键字