JAVA集合篇之Vector底层源码(JDK8)

Vector有四个构造方法

1.Vector()

Vector vector = new Vector();

分析：

/**
 * Constructs an empty vector so that its internal data array
 * has size {@code 10} and its standard capacity increment is
 * zero.
 */
public Vector() {
    this(10);
}

//该构造方法内部调用的是有参构造方法，即this(10)；10为默认容量，即initialCapacity = 10

//该有参构造方法，内部则调用的是带有两个参数的有参构造方法，即this(initialCapacity, 0)

//其中的0是第二个参数，即capacityIncrement（扩容增加值），默认为0

/**
 * Constructs an empty vector with the specified initial capacity and
 * with its capacity increment equal to zero.
 *
 * @param   initialCapacity   the initial capacity of the vector
 * @throws IllegalArgumentException if the specified initial capacity
 *         is negative
 */
public Vector(int initialCapacity) {
    this(initialCapacity, 0);
}

//以下方法的initialCapacity不能为负数，否则会抛出参数不合法异常，该方法实现对集合初始扩容为10

/**
 * Constructs an empty vector with the specified initial capacity and
 * capacity increment.
 *
 * @param   initialCapacity     the initial capacity of the vector
 * @param   capacityIncrement   the amount by which the capacity is
 *                              increased when the vector overflows
 * @throws IllegalArgumentException if the specified initial capacity
 *         is negative
 */
public Vector(int initialCapacity, int capacityIncrement) {
    super();
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    this.elementData = new Object[initialCapacity]; //扩容为10个元素大小的Object数组
    this.capacityIncrement = capacityIncrement;
}

//当进行添加操作,调用add(E e)方法。

/**
 * Appends the specified element to the end of this Vector.
 *
 * @param e element to be appended to this Vector
 * @return {@code true} (as specified by {@link Collection#add})
 * @since 1.2
 */
public synchronized boolean add(E e) {
    modCount++;
    ensureCapacityHelper(elementCount + 1);
    elementData[elementCount++] = e;
    return true;
}
//该方法在添加元素之前会确认容量，调用ensureCapacityHelper(elementCount + 1)方法。

/**
 * This implements the unsynchronized semantics of ensureCapacity.
 * Synchronized methods in this class can internally call this
 * method for ensuring capacity without incurring the cost of an
 * extra synchronization.
 *
 * @see #ensureCapacity(int)
 */
private void ensureCapacityHelper(int minCapacity) { //minCapacity = 0 + 1
    // overflow-conscious code
    //此时，minCapacity = 1，elementData.length = 10，不会进入if判断，不会扩容
    if (minCapacity - elementData.length > 0) 
        grow(minCapacity);
}

//ensureCapacityHelper方法调用结束后，直接将要加入的元素存入初始对象数组。

//继续新增，直到加入元素的个数大于初始容量10时，即加入第十一个元素时，执行

ensureCapacityHelper(elementCount + 1)方法时，参数为10 + 1 = 11

//此时minCapacity = 11，elementData.length = 10，会进入if判断，进行扩容，即调用grow(minCapacity)方法进行扩容。

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; //记录旧集合的元素个数 10
    //此时，capacityIncrement 默认为0，在调用初始构造方法的时候，默认赋值为0
    //因此，此时newCapacity  = oldCapacity  + oldCapacity；即扩容为原来大小2倍
    //因此，在调用构造方法的时候，如果没有显示的指定capacityIncrement 的大小，
    //则capacityIncrement  = 0，这里的扩容算法返回的增量永远是旧容量的大小，
    //相加后为旧容量的2倍，即扩容为原来的2倍。
    //如果，在调用构造方法的时候，如果调用的是两个参数的有参构造函数，即
    //Vector(int initialCapacity, int capacityIncrement)时，指定的capacityIncrement
    //则为增量大小，则每次扩容的大小为capacityIncrement的值。
    int newCapacity = oldCapacity + ((capacityIncrement > 0) ?
                                     capacityIncrement : oldCapacity);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    //进行扩容，底层也是调用的System.arraycopy方法
    elementData = Arrays.copyOf(elementData, newCapacity); 
}

//扩容完成，数组大小变为10 + 10 = 20,然后将新增的元素加入

//此后，添加的逻辑相似，当添加的元素又大于当前容量时，又继续扩容为旧容量的2倍，以此类推。有参构造与上述无参构造的差别在于有参会将传入的参数作为原始容量，即原始容量不再是默认10，而是传入的大小，扩容在没传入capacityIncrement大小时也是扩容为旧容量的2倍，如果指定了capacityIncrement大小，增扩容是在旧容量的基础上增加capacityIncrement的大小作为新容量。