ArrayList 和 Vector 初始化和添加元素源码分析

ArrayList

初始化：

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; // 默认的空数组
transient Object[] elementData; // 用于存放集合元素的数组

// 指定初始化容量的构造器
public ArrayList(int initialCapacity) {
    // 判断给定的初始化容量
    if (initialCapacity > 0) {
        // 若大于 0，新创建一个指定容量的数组赋值给 elementData
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        // 若等于 0，将默认空数组赋值给 elementData
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        // 否则抛出异常
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    }
}

// 未指定初始化容量的无参构造器
public ArrayList() {
    // 将默认空数组赋值给 elementData
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

第一次添加元素：

private int size; // 集合中包含元素的个数，默认值为 0

// 第一次添加元素
public boolean add(E e) {
    ensureCapacityInternal(size + 1);  // 判断新增加元素时，容量是否满足
    elementData[size++] = e; // 将元素添加到数组中
    return true;
}

private void ensureCapacityInternal(int minCapacity) { // minCapacity = 1
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

private static final int DEFAULT_CAPACITY = 10;

// 第一次添加时：elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA；minCapacity = 1
private static int calculateCapacity(Object[] elementData, int minCapacity) {
    // 判断是否是第一次添加元素
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        // 如果是第一次添加，返回 10 和 minCapacity（1）最大值，也就是指定输入默认容量为 10
        return Math.max(DEFAULT_CAPACITY, minCapacity); 
    }
    return minCapacity;
}

// 第一次添加时：minCapacity = 10
private void ensureExplicitCapacity(int minCapacity) {
    modCount++;
    // 第一次添加时，数组是一个空数组，容量为 0，所以可以进入此判断
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

// 第一次添加时：minCapacity = 10
// 用于初始化数组
private void grow(int minCapacity = 10) {
    int oldCapacity = elementData.length; // 将 elementData.length（0） 赋值给 oldCapacity
    // 从这可以看出新的容量是在就的容量基础上增加 50%，若第一次添加 newCapacity = 0
    int newCapacity = oldCapacity + (oldCapacity >> 1); 
    // 第一次添加：newCapacity = 0；minCapacity = 10，可以进入判断
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity; // 将 minCapacity（10）赋值给新容量
    // 该判断是用于判断容量是否超过最大容量
    if (newCapacity - MAX_ARRAY_SIZE > 0) 
        newCapacity = hugeCapacity(minCapacity);
    // 创建新数组，容量为 newCapacity，第一次添加时为 10
    elementData = Arrays.copyOf(elementData, newCapacity);
}

Vector

初始化：

protected int capacityIncrement; // 每次扩容的增量，未指定，默认为 0

public Vector() {
    this(10); // 使用无参构造器创建 Vector 时，默认指定容量为 10，并调用自定义指定容量的有参构造器
}

// 自定义容量的有参构造器
public Vector(int initialCapacity) {
    this(initialCapacity, 0); // 调用自定义容量，并且自定义增量的有参构造器，若为指定，增量为 0
}

// 调用自定义容量，并且自定义增量的有参构造器
public Vector(int initialCapacity, int capacityIncrement) {
    super();
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+ initialCapacity);
    this.elementData = new Object[initialCapacity]; // 初始化数组，容量为 10
    this.capacityIncrement = capacityIncrement; // 将形参中的增量辅助给成员变量 capacityIncrement
}

第一次添加元素：

protected int elementCount; // 元素的个数，默认为 0

public synchronized boolean add(E e) {
    modCount++;
    ensureCapacityHelper(elementCount + 1); // 判断新增加元素时，容量是否满足
    elementData[elementCount++] = e; // 将元素添加到数组中
    return true;
}

private void ensureCapacityHelper(int minCapacity) { // 第一次添加：minCapacity = 1
    if (minCapacity - elementData.length > 0) // 判断当前容量是否满足，第一次添加：1 - 10 < 0 ==> false
        grow(minCapacity); // 若添加的元素个数大于默认容量 10，执行该方法，进行扩容
}

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8; // 数组最大容量

private void grow(int minCapacity) {
    int oldCapacity = elementData.length; // 将添加前数组的容量赋值给：oldCapacity
    // 从这可以看出，新容量是旧容量的 2 倍
    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);
}