ArrayList源码解析二

自动扩容

自动扩容是ArrayList 最核心的性质了。每次向数组中添加元素时，都会检查添加后元素的个数是否会超出当前数组的长度，如果超出，数组将会进行扩容。

数组进行扩容时，会将老数组中的元素重新拷贝一份到新的数组中，每次数组容量的增长大约是其原容量的1.5倍。

由于拷贝这种操作的代价是很高的，因此在实际使用时，我们应该尽量避免频繁发生数组扩容的情况。当我们可预知要保存的元素的多少时，要在构造ArrayList实例时，就指定其容量，以避免数组扩容的发生。或者根据实际需求，通过调用 ensureCapacity 方法来手动增加 ArrayList 实例的容量。

自动扩容涉及到的源码：

/**
 * Increases the capacity of this <tt>ArrayList</tt> instance, if
 * necessary, to ensure that it can hold at least the number of elements
 * specified by the minimum capacity argument.
 *
 * @param   minCapacity   the desired minimum capacity
 */
public void ensureCapacity(int minCapacity) {
    int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
        // any size if not default element table
        ? 0
        // larger than default for default empty table. It's already
        // supposed to be at default size.
        : DEFAULT_CAPACITY;

    if (minCapacity > minExpand) {
        ensureExplicitCapacity(minCapacity);
    }
}

private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

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

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

/**
 * The maximum size of array to allocate.
 * Some VMs reserve some header words in an array.
 * Attempts to allocate larger arrays may result in
 * OutOfMemoryError: Requested array size exceeds VM limit
 */
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

/**
 * Increases the capacity to ensure that it can hold at least the
 * number of elements specified by the minimum capacity argument.
 *
 * @param minCapacity the desired minimum capacity
 */
private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    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);
}

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

自动扩容涉及到好几个方法，我们该从哪一个看起呢。

因为自动扩容一般是和add联系密切的，我们先看一个add方法。

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

可以看到他调用了 ensureCapacityInternal 方法，并且我们还要稍微留意这个注释，源码里面拥有的注释都是值得我们留意的。

Increments modCount!! ： 递增 modCount 。

然后我们看一下 ensureCapacityInternal 方法：

请记住 minCapacity 是指的增加元素后需要的数组长度。

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

他先调用了 calculateCapacity 方法。

private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

这个方法很简单，就是判断一下 elementData 是不是等于DEFAULTCAPACITY_EMPTY_ELEMENTDATA，及判断一个现在的 ArrayList 是不是刚被使用无参构造new出来。如果是无参构造的话，并且 minCapacity 小于10，就返回 DEFAULT_CAPACITY (10)。其他情况均直接返回传入的大小即可。

接着 ensureCapacityInternal 方法会调用 ensureExplicitCapacity 方法。

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;

    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

这个方法的第一行 modCount++ 就对应上了我们上面让注意的 Increments modCount!! 注释。

这个 modCount 是用来记录操作次数的，一般在我们的增加和修改的方法里面使用，是一种线程安全机制，具体的作用这里不细讲。

然后会判断 minCapacity 是否大于 elementData.length，及判断增 加元素后需要的数组长度 是否大于 现有的数组长度。如果大于，则代表着需要扩容，然后调用 grow 方法。

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    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);
}

然后第一句注释：overflow-conscious code，就告诉我们，扩容不是直接就能扩的，得把溢出的情况排除。

其中，

int newCapacity = oldCapacity + (oldCapacity >> 1);

这一句代码，就是我们平常说的 ArrayList 自动扩容是 1.5倍 的支撑证据了。

接着是两个if判断。

第一个if判断：

if (newCapacity - minCapacity < 0)
    newCapacity = minCapacity;

这个判断是说，当预计扩充 1.5倍 过后，依旧比 minCapacity 小，那就直接扩充到 minCapacity 大小就完事了。

这种情况，一般我们使用 add()方法 的时候不会碰到，当时用 addAll() 的时候可能会命中。比如：

ArrayList<Object> list = new ArrayList<>(10);
ArrayList<Object> list1 = new ArrayList<>(2);
list1.addAll(list);

这个情况大家可以去debug看看，list1 的容量会直接从2扩容到10。

第二个判断：

private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
if (newCapacity - MAX_ARRAY_SIZE > 0)
    newCapacity = hugeCapacity(minCapacity);

这个的解释可以看这个：ArrayList源码中的MAX_ARRAY_SIZE

最后终于确定 newCapacity 的值后，就调用 Arrays.copyOf() 去扩容，这个方法的底层是 native 方法，就不细究了。

自此ArrayList的自动扩容结束。