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);