ArrayList的初始容量以及扩容

先看没有指定容量的ArrayList构造函数和相关代码：

public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; // 默认初始容量，这只是一个标记，在执行add方法的时候检测到这个标记会把初始值设为10
}

public boolean add(E e) {
    ensureCapacityInternal(size/* 0 */ + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

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

private static int calculateCapacity(Object[] elementData, int minCapacity) {
	// 使用默认构造函数，第一次add符合if条件
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY /* 10 */, minCapacity /* 1 */);
    }
    return minCapacity;
}

从上面的代码和注释可以看出ArrayList的初始容量是0，在第一次add的时候扩容为10。

再看指定容量的ArrayList构造函数和相关代码：

public ArrayList(int initialCapacity/* 5 */) {
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA; // EMPTY_ELEMENTDATA是ArrayList中的空容量，和DEFAULTCAPACITY_EMPTY_ELEMENTDATA做区分
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    }
}

public boolean add(E e) {
    ensureCapacityInternal(size/* 当前容量 */ + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

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

private static int calculateCapacity(Object[] elementData, int minCapacity) {
	// 使用初始化容量构造函数，不符合if条件
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY /* 10 */, minCapacity /* 当前容量+1 */);
    }
    return minCapacity;
}

private void ensureExplicitCapacity(int minCapacity /* 当前容量+1 或 默认大小*/) {
    modCount++;

	// 当前容量不够添加新元素时会进行扩容
    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1); // 位移运算，相当于 int newCapacity = oldCapacity * 1.5
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity); // 拷贝生成新数组
}

从上面的源码可以看到：

1. 不指定ArrayList的初始容量，在第一次add的时候会把容量初始化为10个，这个数值是确定的；
2. ArrayList的扩容时机为add的时候容量不足，扩容的后的大小为原来的1.5倍，扩容需要拷贝以前数组的所有元素到新数组。