java.util.ArrayList 源码解析

开发环境：

jdk1.8.0_162

ArrayList基于数组实现，有序，可重复，元素能够是null。

/**
* Default initial capacity.
* 初始容量默认为10
*/
private static final int DEFAULT_CAPACITY = 10;

/**
 * Shared empty array instance used for empty instances.
 */
private static final Object[] EMPTY_ELEMENTDATA = {};

/**
 * Shared empty array instance used for default sized empty instances. We
 * distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
 * first element is added.
 */
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

/**
* The size of the ArrayList (the number of elements it contains).
* ArrayList包含的元素的个数
* @serial
*/
private int size;

列表中的元素都是保存在成员变量elementData中

/**
* The array buffer into which the elements of the ArrayList are stored.
* The capacity of the ArrayList is the length of this array buffer.
* Any empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA will be expanded to DEFAULT_CAPACITY when the first element is added.
*/
transient Object[] elementData;

elementData默认是一个空数组

public ArrayList() {
   this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

调用【add(E e)】方法末尾添加元素 源码解析

public boolean add(E e) {
    // 检查是否须要扩容，若有必要就进行扩容
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    // 开始将元素插入到数组中，并将list中的元素个数+1
    elementData[size++] = e;
    return true;
}

扩容源码以下：

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

private static int calculateCapacity(Object[] elementData, int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        // 首次添加元素返回默认容量DEFAULT_CAPACITY
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    // 返回参数minCapacity
    return minCapacity;
}

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;// 修改次数+1
    // overflow-conscious code
    if (minCapacity - elementData.length > 0) {
        // 若是elementData数组是空数组或是已经放满元素，则开始扩容
        grow(minCapacity);
    }  
}

private void grow(int minCapacity) {
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);
    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;
}

从上面的源码能够看出

1.首次扩容（首次添加元素的时候），list的容量增长到了10 (DEFAULT_CAPACITY)。

2.以后添加元素引起的扩容，扩容后的容量newCapacity = oldCapacity + (oldCapacity >> 1)。

3.添加元素直到某次扩容时，计算出扩容后的容量newCapacity > MAX_ARRAY_SIZE，list就会被直接扩容到Integer.MAX_VALUE。

 

调用【 add(int index, E element) 】方法在指定位置添加元素 源码解析

public void add(int index, E element) {
        // 检查index是否在区间[0 , size-1]以内，若是不在，抛出异常
        rangeCheckForAdd(index);
        // 检查是否须要扩容，若有必要就进行扩容
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        // 开始将元素插入到数组中
        System.arraycopy(elementData, index, elementData, index + 1, size - index);
        elementData[index] = element;
        // list中的元素个数+1
        size++;
    }

相比于 add(E e) ：

1.多了一步插入位置index的检查

2.插入元素的动做也多了一步

System.arraycopy(elementData, index, elementData, index + 1, size - index);