ArrayList源碼解析（上）

成員變量

1. elementData爲實際存儲數據的數組
2. size爲ArrayList的實際大小，和elementData的長度有所區別
3. 有一個特殊的地方，elementData使用transient修飾，即不可以被序列化，這麼做的原因是：
   elementData數組的長度在大多數情況下，是大於實際數據的數量size的，所以不需要將空的元素也進行序列化操作。對elementData的序列化操作其實是由writeObject()和readObject()實現的。

private static final long serialVersionUID = 8683452581122892189L;

//默認的容量
private static final int DEFAULT_CAPACITY = 10;

private static final Object[] EMPTY_ELEMENTDATA = {};

//實際存儲數據的其實是這個數組
private transient Object[] elementData;

//ArrayList的大小，和elementData的長度不一定相等
private int size;

構造函數

1. 三個構造函數
2. 最後一個函數由於c.toArray可能不會反回一個Object數組，所以特殊處理一下

public ArrayList(int initialCapacity) {
    super();
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                initialCapacity);
    this.elementData = new Object[initialCapacity];
}

public ArrayList() {
    super();
    this.elementData = EMPTY_ELEMENTDATA;
}

public ArrayList(Collection<? extends E> c) {
    elementData = c.toArray();
    size = elementData.length;
    // c.toArray might (incorrectly) not return Object[] (see 6260652)
    if (elementData.getClass() != Object[].class)
        elementData = Arrays.copyOf(elementData, size, Object[].class);
}

關於擴展容量的相關操作

1. 方法調用關係：ensureCapacity() -> ensureExplicitCapacity() -> grow() -> hugeCapacity()
2. 核心的方法是grow()方法，如果minCapacity大於原來容量的1.5倍，容量增加到minCapacity；否則增加到1.5倍。
3. 對於ensureCapacity()這個方法，如果事先知道ArrayList所需存儲的數據量大小，我們可以直接調用來設置，避免每次拷貝數組花費的額外時間，提升效率。

/**
 * 按照size的大小縮減elementData的長度
*/
public void trimToSize() {
    //操作計數器，定義在AbstractList中
    modCount++;
    if (size < elementData.length) {
        elementData = Arrays.copyOf(elementData, size);
    }
}

/**
 * 增加容量到minCapacity大小
 */
public void ensureCapacity(int minCapacity) {
    int minExpand = (elementData != EMPTY_ELEMENTDATA)
        // any size if real element table
        ? 0
        // larger than default for empty table. It's already supposed to be
        // at default size.
        : DEFAULT_CAPACITY;

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

/**
* 主要爲add方法所用
*/
private void ensureCapacityInternal(int minCapacity) {
    if (elementData == EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }

    ensureExplicitCapacity(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;

/**
 * 增加容量的核心函數。
 * 如果minCapacity大於原來容量的1.5倍，容量增加到minCapacity；否則增加到1.5倍。
 */
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;
}