ArrayList關鍵知識

1、成員變量

private static final int DEFAULT_CAPACITY = 10; // 默認容量，在未指定初始容量時，默認容量爲10
private static final Object[] EMPTY_ELEMENTDATA = {}; // 除自動擴容場景外使用此空數組
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; // 在擴容若是elementData指向此數組，elementData會初始化爲容量爲10的數組
transient Object[] elementData; // 數據存儲數組
private int size; // 元素個數

2、關於初始化

ArrayList提供了三種構造器：

1. 無參構造器：

public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA; // 無參構造器，默認初始容量爲10，在第一次add時加載
}

2. 指定容量構造器：

public ArrayList(int initialCapacity) {
    if (initialCapacity > 0) {
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        this.elementData = EMPTY_ELEMENTDATA; // 指定了初始容量爲0時，指向空數組
    } else {
        throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
    }
}

3. 指定集合構造器

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

3、關於擴容

1. 在調用add()方法是會調用ensureCapacityInternal(int minCapacity)告訴List我最少須要多少容量

private void ensureCapacityInternal(int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) { // 若是elementData指向上文說的空數組，則將最少須要10個容量
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }

    ensureExplicitCapacity(minCapacity); // 判斷是否須要擴容
}

2.  ensureExplicitCapacit(int minCapacity)方法會判斷到底需不須要擴容

private void ensureExplicitCapacity(int minCapacity) {
    modCount++; // 每次可能須要擴容的時候，必然會操做集合，因此在這裏贊成進行modCount++

    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity); // 若是須要的最小容量 大於 當前elementData.length，則擴容
}

 3. grow(int minCapacity)會進行擴容操做，默認按照原容量的1.5倍擴容

private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length; // 老容量
    int newCapacity = oldCapacity + (oldCapacity >> 1); // 新容量默認等於 oldCapacity + oldCapacity / 2
    if (newCapacity - minCapacity < 0) // 若是計算的新容量 小於 須要的最小容量，則本次按照指定的minCapacity擴容
        newCapacity = minCapacity;
    if (newCapacity - MAX_ARRAY_SIZE > 0) // 若是新容量 大於 數組最大容量（Integer.Max_Value - 8）,進行大容量處理
        newCapacity = hugeCapacity(minCapacity);
    // minCapacity is usually close to size, so this is a win:
    elementData = Arrays.copyOf(elementData, newCapacity);
}

4. 對於minCapacity超過MAX_ARRAY_SIZE的狀況作一些操做 

private static int hugeCapacity(int minCapacity) {
    if (minCapacity < 0) // 超過最大限制，拋出內存溢出錯誤 
        throw new OutOfMemoryError();
    return (minCapacity > MAX_ARRAY_SIZE) ? // 不然返回最大數組長度（Integer.MAX_VALUE - 8）
        Integer.MAX_VALUE :
        MAX_ARRAY_SIZE;
}

5. 爲何數組最大容量是 Integer.MAX_VALUE - 8？

// 由於有些VM會給數組加一些頭部信息，若是指定再大的值可能會致使內存溢出

4、關於迭代

ArrayList內部實現Iterator接口，經過iterator()獲取迭代器

1. 迭代器成員變量

int cursor;       // 下一個迭代的元素地址
int lastRet = -1; // 當前迭代的元素地址，調用next()方法時會等於cursor
int expectedModCount = modCount; // 用於判斷是否有併發操做問題

2. 使用hasNext()方法，判斷是否還有未迭代的元素

public boolean hasNext() {
    return cursor != size;
}

3. 使用next()方法獲取下一個元素

public E next() {
    checkForComodification(); // 檢查是否有併發操做問題
    int i = cursor;  // 獲取當前元素下標
    if (i >= size)
        throw new NoSuchElementException();
    Object[] elementData = ArrayList.this.elementData;
    if (i >= elementData.length)
        throw new ConcurrentModificationException();
    cursor = i + 1;  // 指針指向下一個元素
    return (E) elementData[lastRet = i];  // 獲取當前元素
}

4. 若是須要刪除當前元素，使用remove()方法刪除，保證迭代器正常使用

public void remove() {
    if (lastRet < 0) // lastRet < 0說明當前沒有元素
        throw new IllegalStateException();
    checkForComodification();  // 檢查併發操做問題

    try {
        ArrayList.this.remove(lastRet);  // 按照下標刪除
        cursor = lastRet;  // cursor - 1
        lastRet = -1;  // 當前元素指向 -1
        expectedModCount = modCount; // 保證操做正常
    } catch (IndexOutOfBoundsException ex) {
        throw new ConcurrentModificationException();
    }
}

5. checkForComodification()檢查是否有併發操做

final void checkForComodification() {
    if (modCount != expectedModCount)
        throw new ConcurrentModificationException();
}