Java的ArrayList集合源碼深度解析以及應用介紹

   本文對Java中的ArrayList集合的源碼進行了深度解析，包括各種方法、擴容機制、迭代器機制、快速失敗/安全失敗機制的底層實現，並且給出了ArrayList的基本應用。

1 ArrayList的概述

public class ArrayList
   extends AbstractList
   implements List, RandomAccess, Cloneable, Serializable

   ArrayList 繼承自 AbstractList，實現了 List 接口 ，底層基於數組實現容量大小動態變化，在物理內存上採用順序存儲結構，即數組。因此可根據索引快速的查找元素，還具有基於索引操作元素的一套方法，允許 null 元素的存在。
   同時還實現了 RandomAccess標誌性接口，這意味着這個集合支持 快速隨機訪問 策略，那麼使用傳統for循環的方式遍歷數據會優於用迭代器遍歷數據，即使用get（index）方法獲取數據相比於迭代器遍歷更加快速！
   ArrayList還實現了Cloneable、Serializable兩個標誌性接口，所以ArrayList支持克隆、序列化。

2 ArrayList的源碼解析

  ArrayList的底層數據結構就是一個數組，數組元素的類型爲Object類型，對ArrayList的所有操作底層都是基於數組的。

初始容量：
  JDK7以前： 調用空構造器則是立即初始化爲10個容量的數組。
  JDK7開始： 調用空構造器初始化容量爲0的空數組，在第一次add()之時默認擴容至少爲10個容量，也可指定初始化數組的容量。

擴容：
  JDK7之前：大約1.5倍
  int newCapacity = (oldCapacity * 3)/2 + 1;
  JDK7開始：大約1.5倍
  int newCapacity = oldCapacity + (oldCapacity >> 1)

注意： 當計算出的擴容後的容量仍然小於最小容量時，此時設置擴容後的容量改爲最小容量。另外，實際上擴容機制沒有上面那麼簡單，後面原碼處會講到。

2.1. 主要類屬性

/**
 * 如果不指定容量（空構造器）,則在添加數據時的空構造器默認初始容量最小爲10
 */
private static final int DEFAULT_CAPACITY = 10;
/**
 * 出現在需要用到空數組的地方，其中一處是使用自定義初始容量構造方法時候如果你指定初始容量爲0的時候，那麼elementData指向該數組。另一處是使用包含指定collection集合元素的列表的構造方法時，如果被包含的列表中沒有數據，那麼elementData指向該數組。
 */
private static final Object[] EMPTY_ELEMENTDATA = {};
/**
 *如果使用默認構造方法，那麼elementData指向該數組。在添加元素時會判斷是否是使用默認構造器第一次添加，如果是數組就會擴容至10個容量。
 */
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/**
 * 默認未初始化的儲存ArrayList集合元素的底層數組,其長度就是ArrayList的容量。
 */
transient Object[] elementData;
/**
 * 私有的elementData數組中具體的元素對象的數量,可通過size方法獲得。默認初始值爲0，在add、remove等方法時size會改變
 */
private int size;

2.2 構造器與初始化容量

2.2.1 ArrayList()

  實際上當我們創建一個空ArrayList集合時，其數組爲空數組，即初始化容量爲0。其源碼爲：

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

  每次我們調用初始化一個空白的集合ArrayList，它的底層數組其實是空的。那人們說的初始化容量是10到底是從哪來的呢？
使用空構造器時，其實當我們第一次爲ArrayList添加元素的時候，底層數組擴容到了至少10。這在擴容機制中會講到！

2.2.2 ArrayList(Collection<? extends E> c)

  構造一個包含指定collection集合元素的列表，這些元素是按照該collection的迭代器返回它們的順序排列的。

public ArrayList(Collection<? extends E> c) {
    //獲取指定collection的內部元素數組,簡單的直接複製給新集合內部的數組引用，toArray方法會去除了後面的空餘的容量只返回有效數據
    elementData = c.toArray();
    //判斷是否是空數組,即添加進來的集合是否有數據
    if ((size = elementData.length) != 0) {
        //如果有數據,轉換爲Object[]類型的數組
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        //如果沒有數據,則直接初始化爲一個容量爲0的空集合
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

2.2.3 ArrayList(int initialCapacity)

  構造一個具有指定初始容量的空列表。

public ArrayList(int initialCapacity) {
    //判斷指定初始容量的值
    if (initialCapacity > 0) {
        //如果指定初始容量大於0,則構建指定長度的空數組並賦值給elementData
        this.elementData = new Object[initialCapacity];
    } else if (initialCapacity == 0) {
        //如果指定初始容量等於0,則將已有的空數組賦值給elementData
        this.elementData = EMPTY_ELEMENTDATA;
    } else {
        //如果指定初始容量小於0,則將拋出IllegalArgumentException異常
        throw new IllegalArgumentException("Illegal Capacity: "+
                initialCapacity);
    }
}

2.3 add方法與擴容機制

2.3.1 源碼解析

  添加元素的方法如下，看起來很簡單，但是卻可以分爲幾步：

public boolean add(E e) {
    //判斷並進行數組的擴容or長度超限的方法
    ensureCapacityInternal(size + 1);  //modCount+1
    //爲size的所在索引賦值，並且size自增1
    elementData[size++] = e;
    return true;
}

  方法中調用的ensureCapacityInternal方法主要用來擴容or判斷長度超限。

/**
 * @param minCapacity 最小容量，此時minCapacity=size + 1
 */
private void ensureCapacityInternal(int minCapacity) {
    //如果內部數組=DEFAULTCAPACITY_EMPTY_ELEMENTDATA,即是採用空構造器初始化集合並且第一次添加元素
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        //比較DEFAULT_CAPACITY(10)和minCapacity的大小,即最小容量不小於10
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    //走下一個方法，判斷是否需要擴容or判斷數組長度是否溢出
    ensureExplicitCapacity(minCapacity);
}

/**
 * 判斷是否需要走擴容or判斷數組長度是否可能溢出
 * @param minCapacity 最小容量
 */
private void ensureExplicitCapacity(int minCapacity) {
    //該字段定義在ArrayList的父類AbstractList,用於存儲結構修改次數,這確保了快速失敗機制。
    modCount++;
    //如果minCapacity減去此時數組的長度的值大於0,此時開始擴容或者進行數組長度溢出判斷。這裏說明加載因子爲1,即size+1:capacity=1時進行擴容
    if (minCapacity - elementData.length > 0)
        //擴容or長度溢出判斷方法
        grow(minCapacity);
}

/**
 * 要分配的數組的最大大小。嘗試分配較大的數組可能會導致內存錯誤OutOfMemoryError:請求的數組大小超過 VM 限制,該值沒有特別實際的意義。
 */
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

/**
 * 擴容or長度溢出判斷方法
 * @param minCapacity 最小容量
 */
private void grow(int minCapacity) {
    //原容量
    int oldCapacity = elementData.length;
    //新容量,即擴容後的容量,這裏就是如何擴容的.新容量擴大到原容量的1.5倍左右，右移一位相當於原數值除以2的商。
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    //如果新容量減去最小容量的值小於0
    if (newCapacity - minCapacity < 0)
        //新容量等於最小容量
        newCapacity = minCapacity;
    //如果新容量減去建議最大容量的值大於0
    if (newCapacity - MAX_ARRAY_SIZE > 0)
        //調整新容量上限或者拋出OutOfMemoryError
        newCapacity = hugeCapacity(minCapacity);
    /*
     * 最終進行新數組的構建和重新賦值,此後原數組被摒棄
     * elementData:原數組
     * newCapacity:新數組容量
     * */
    elementData = Arrays.copyOf(elementData, newCapacity);
}

/**
 * Arrays類的copyof方法,其內部調用內一個多參數方法
 * @param original
 * @param newLength
 * @param <T>
 * @return
 */
public static <T> T[] copyOf(T[] original, int newLength) {
    //original.getClass():獲取原數組的類型,作爲新數組的類型
    return (T[]) copyOf(original, newLength, original.getClass());
}

/**
 * Arrays類的copyof方法,最終還是調用的System.arraycopy方法進行數組元素的轉移。
 * @param original  原數組
 * @param newLength 返回的新數組的長度
 * @param newType   新數組的類型
 *                  將返回新的數組
 */
public static <T, U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
    @SuppressWarnings("unchecked")
    //新數組的構建
            T[] copy = ((Object) newType == (Object) Object[].class)
            ? (T[]) new Object[newLength]
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
    /*
     * 調用arraycopy方法,將數據克隆到新數組
     * 參數一:原數組
     * 參數二:copy的起始索引
     * 參數三:新數組
     * 參數四:copy到新數組的起始索引
     * 參數五:要複製的數組元素的數量。
     * */
    System.arraycopy(original, 0, copy, 0,
            Math.min(original.length, newLength));
    return copy;
}

2.3.2 執行流程

  根據上面的源碼可以總結出arraylist的add方法的流程，共有六步：

1. 計算出最小容量；
2. 判斷是否需要擴容or數組長度溢出；
3. 計算新的容量；
4. 考慮數組長度溢出；
5. 數組擴容；
6. 添加元素。

2.3.2.1 計算出最小容量

  調用ensureCapacityInternal(minCapacity)方法，方法內部首先判斷elementData 是否等於DEFAULTCAPACITY_EMPTY_ELEMENTDATA，這在類屬性和構造器部分已經見過了，如果相等，那麼說明：該集合是使用的默認空構造器初始化的，並且是第一次添加數據。
  然後minCapacity 設置爲DEFAULT_CAPACITY和minCapacity的最大值，即至少是10，可能超過10是因爲。addAll方法可能一次性添加超過10個的數據。
  注意，使用指定容量或者指定包含集合的構造方法創建的對象，使用add方法時，上面的判斷都是false，即此時minCapacity不會設置爲10，而是size+1。

2.3.2.2 判斷是否需要擴容or數組長度溢出

  接下來走ensureExplicitCapacity(minCapacity)方法，該方法首先modCount自增一，該字段與ConcurrentModificationException異常有關，後面會講到。
  然後判斷如果最小容量減去底層數組長度的值大於0時，即需要擴容或者可能是數組長度溢出（後面步驟會講），進入步驟3，可以看到擴容因子是1；如果最小容量減去底層數組長度小於等於0，那麼該方法結束，進入步驟5。

2.3.2.3 計算新的容量

  grow(minCapacity)方法就是擴容or數組長度溢出判斷的方法，可以首先會計算新的容量：

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

  明顯新容量是原長度加上原長度右移1位，這個>>是右移運算法,相當於oldCapacity/2，即新容量（newCapacity）爲原長度的1.5倍左右。
  然後判斷如果新容量減去最小容量的值小於0，那麼設置新容量等於最小容量。 這是有可能發生的情況，比如：使用指定容量的構造器創建集合，指定初始容量爲0，然後在添加第一個數時，計算新容量=0+(0>>1)明顯還是爲0，此時小於最小容量(0+1)，因此新容量需要等於1。
  然後進入步驟4，也就是考慮數組長度溢出或者從新分配最小值的情況。

2.3.2.4 考慮數組長度溢出

  接下來是步驟4，考慮數組長度溢出或者從新分配新容量的情況。
  首先判斷新容量減去最大數組容量是否大於0，如果大於0，那麼進入hugeCapacity方法；否則該步驟結束。
  hugeCapacity用於計算新的容量或者拋出數組大小溢出異常。
  首先它會判斷minCapacity是否小於0，如果是，那麼就是數組長度大小溢出了，直接拋出OutOfMemoryError異常，很多人會疑問minCapacity還會小於0嗎？這種情況是有可能發生的，並且這裏牽扯到了計算機底層二進制數據存儲的問題。 關於數值的計算機存儲，可以看這篇文章：計算機進制轉換詳解以及Java的二進制的運算方法，講的很詳細，這是弄懂後面的源碼的關鍵，主要是看“二進制計算的坑”那一部分！
  在步驟1中，當數組長度size等於Integer.MAX_VALUE，即等於int類型的最大值2147483647時，此時再加1，根據計算機的運算機制，此時得出的minCapacity值爲-2147483648，很明顯小於0，然後而進行到步驟2時，計算minCapacity-size的值，即-2147483648-2147483647，根據計算機的運算機制，此時得出的值爲1，就會進入步驟3。
  然後計算新容量，此時newCapacity=2147483647+2147483647>>1，算出來的值爲-1073741826。此時minCapacity=-2147483648，newCapacity=-1073741826，明顯newCapacity- minCapacity是大於0的。
  接下來纔是進入到步驟4，此時在if條件部分：-1073741826-MAX_ARRAY_SIZE，我們找到MAX_ARRAY_SIZE字段，它的值爲（Integer.MAX_VALUE – 8），實際上這只是ArrayrList建議的數組的最大長度，某些VM的實現可能需額外的長度存儲一些頭信息，最大長度超過MAX_ARRAY_SIZE在某些VM上可能引發OutOfMemoryError。但是這個最大長度是一定的嗎？那肯定不是，這只是一個建議值，實際上很多虛擬機對數組元素添加個數可以超過MAX_ARRAY_SIZE的長度。這個具體還是要看JVM的實現，以及堆內存的大小，本人HotSpot JDK8測試結果如下：

/**
 * 測試數組最大分配長度,這和VM實現,以及對內存大小有關
 */
@Test
public void test3() {
    // 嘗試分配Integer.MAX_VALUE-1長的byte數組,將會拋出異常:
    // java.lang.OutOfMemoryError: Requested array size exceeds VM limit
    //表示請求分配的數組長度超過了VM的限制
    byte[] arr1=new byte[Integer.MAX_VALUE-1];
    // 但是分配Integer.MAX_VALUE-2長的byte數組,則不會拋出異常
    //說明本人HotSpot JDK8虛擬機循序分配的數組最大長度爲Integer.MAX_VALUE-2
    byte[] arr2=new byte[Integer.MAX_VALUE-2];
    //嘗試分配Integer.MAX_VALUE-2長的int數組,則直接拋出異常:
    //java.lang.OutOfMemoryError: Java heap space
    //這說明,你具體能夠分配多大長度的數組,還要看數組的類型,說白了就是你的JVM的堆空間內存的大小
    int[] arr3=new int[Integer.MAX_VALUE-2];
}

  根據本人做出的實驗，所以說MAX_ARRAY_SIZE這個東西，看看就行了，實際上沒啥太大用作，不必過於深究，對於網上所說的用於存放數組長度之類的，切記不必過分相信。實際上Java因不支持超過2³¹ -1（約21億）個元素的數組而廣泛受到批評。
  扯遠了，我們回到剛纔的地方，-1073741826-MAX_ARRAY_SIZE的值明顯還是大於0的，值爲1073741831，因此進入hugeCapacity方法，此時首先判斷minCapacity是否小於0，明顯經過上面的一系列步驟，minCapacity=- 2147483648<0，那麼說明數組長度的分配超過了來最大限制（Java數組長度不能超過int的最大值，即Integer.MAX_VALUE-2147483647），此時即可拋出長度分配超限異常，程序結束，這裏直接拋出OutOfMemoryError異常爲什麼這裏要拋出OutOfMemoryError異常呢？……
  如果此時minCapacity沒有小於0，如果minCapacity大於MAX_ARRAY_SIZE，那麼直接將newCapacity設置爲Integer.MAX_VALUE，即最大容量；否則，newCapacity設置爲MAX_ARRAY_SIZE （通過返回值設置），從這裏我們也能看出來MAX_ARRAY_SIZE實際上沒什麼太大用處，也並不是數組最大分配長度。
  如果步驟4順利結束，而不是拋出異常，那麼進入步驟5。

2.3.2.5 數組擴容

  接下來步驟5就是一段代碼：

elementData = Arrays.copyOf(elementData, newCapacity);

  很明顯就是，重新構建一個數組，然後將原來數組的元素拷貝到新數組中，新數組的長度爲newCapacity。並修改原數組的引用指向這個新建數組，原數組自動拋棄（java垃圾回收機制會自動回收）。
  從這一步也能看出來，ArrayList所謂的可變長度，實際上在底層也只是新建一個更長的數組，然後拷貝原數組的元素到新數組，並將引用指向新數組而已。因此，ArrayList的改變集合結構的方法，比如增、刪等方法，性能都比較一般，因爲增（觸發擴容）、刪（觸發後續元素左移）一個元素就可能涉及到大量其他元素的移動，並且隨着ArrayList集合元素越來越多，其增、刪的性能越來越低，但是由於是數組，因此根據索引查詢元素的效率很高。
還有一種優化就是，在創建 ArrayList 對象時就指定大概的最大容量大小，這樣就能減少擴容操作的次數。
  步驟5結束，該方法結束，進入最後一步，即步驟6——添加元素。

2.3.2.6 添加元素

  進入步驟6時，ensureCapacityInternal方法已經徹底結束了，此時只剩下最後一步，即添加元素，哈哈，添加元素方法的真正添加元素的步驟卻是在最後一步，神奇吧！
  添加元素也很簡單，默認添加在size的索引處，即添加在末尾，然後size自增一，此時程序正常結束，返回true。
  然後設置size++的值爲要添加的新值size則在向數組添加對象後，自增1。即所謂的ArrayList能自動改變容量，不過是給引用變量賦了新建的容量更大數組的引用而已！

2.4 addAll方法

public boolean addAll(Collection<? extends E> c)

  按照指定 collection 的迭代器所返回的元素順序，將該 collection 中的所有元素添加到此列表的尾部。說白了就是將一個集合的全部元素添加到另一個集合中.

/**
 * @param c 需要被添加的集合
 * @return 如果此列表由於調用而發生更改，則返回 true
 */
public boolean addAll(Collection<? extends E> c) {
    //獲取被添加集合的元素數組
    Object[] a = c.toArray();
    //獲取元素數組的長度
    int numNew = a.length;
    //確保容量能容納這些數據,該方法上面已經講解了,注意這裏modeCount只自增1，並且由於addAll存在。
    ensureCapacityInternal(size + numNew);
    //數組元素的拷貝
    System.arraycopy(a, 0, elementData, size, numNew);
    //size增加numNew
    size += numNew;
    //如果獲取元素數組的長度numNew不等於0，則返回 true 
    return numNew != 0;
}

2.5 remove方法

public E remove(int index)

  移除此列表中指定索引位置上的元素。向左移動所有後續元素（將其索引減1）。
  從源碼中可以看到，需要調用System.arraycopy() 將刪除元素 index+1 後面的元素都複製到 index 位置上，該操作的時間複雜度爲 O(N)，可以看出 ArrayList 刪除元素和擴容一樣，代價是非常高的。
  remove的源碼，還是比較簡單的：

public E remove(int index) {
    rangeCheck(index);
    modCount++;
    //獲取將要被移除的數據
    E oldValue = elementData(index);

    //要移動的數據長度size-(index + 1)  最小值0最大值size-1
    int numMoved = size - index - 1;
    if (numMoved > 0)
        //將index+1後面的列表對象前移一位,該操作將會覆蓋index以及之後的元素,相當於刪除了一位元素
        System.arraycopy(elementData, index+1, elementData, index, numMoved);
    // 數組前移一位，size自減-，空出來的位置(原數組的有效數據的最後一位)置null，原來的具體的對象的銷燬由Junk收集器負責
    elementData[--size] = null;
    //返回原數據
    return oldValue;
}

2.6 get方法

public E get(int index)

  返回此列表中指定索引位置上的元素。

public E get(int index) {
    //檢查索引長度是否符合要求
    rangeCheck(index);
    return elementData(index);
}
private void rangeCheck(int index) {
    //如果索引長度大於等於size,則拋出IndexOutOfBoundsException異常
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

2.7 set方法

public E set(int index,E element)

  用指定的元素替代此列表中指定索引位置上的元素。

public E set(int index, E element) {
    //檢查索引長度是否符合要求
    rangeCheck(index);
    //獲取舊的值
    E oldValue = elementData(index);
    //替換值
    elementData[index] = element;
    //返回舊值
    return oldValue;
}

2.8 clone方法

  返回的是一個全新的ArrayList實例對象，但是其elementData，也就是存儲數據的數組，存儲的對象還是指向了舊的ArrayList存儲的那些對象。也就是ArrayList這個類實現了深拷貝，但是對於存儲的對象還是淺拷貝。

public Object clone() {
    try {
        //淺克隆
        ArrayList<?> v = (ArrayList<?>) super.clone();
        //elementData的深克隆,舊的數組和新的數組的element不是同一個了,但是elementData數組中的儲存對象還是淺克隆（儲存的是直接量則會深克隆）
        //兩個集合內部數組的對象指向相同的地址
        v.elementData = Arrays.copyOf(elementData, size);
        v.modCount = 0;
        return v;
    } catch (CloneNotSupportedException e) {
        // this shouldn't happen, since we are Cloneable
        throw new InternalError(e);
    }
}

2.9 序列化

  ArrayList 基於數組實現，並且具有動態擴容特性，因此保存元素的數組不一定都會被使用，那麼就沒必要全部進行序列化。
  保存元素的數組 elementData 使用 transient 修飾，該關鍵字聲明存儲元素的數組默認不會被序列化。
transient Object[] elementData;
  很多人就有疑問了，那麼ArrayList爲什麼序列化之後再反序列化回來時還能保存原來的數據呢？實際上ArrayList額外自己實現了writeObject() 和 readObject() 來控制序列化數組中有元素填充那部分內容，該部分內容纔是真正需要被序列化的。
  Java在序列化時需要默認調用 ObjectOutputStream 的 writeObject() 將對象轉換爲字節流並輸出。而writeObject()方法會判斷——在傳入的對象存在 writeObject()的時候，即對象自己實現了writeObject()方法的時候，會去反射調用該對象實現的writeObject()方法來實現序列化。
  反序列化使用的是 ObjectInputStream 的 readObject() 方法，原理類似。
writeObject：

private void writeObject(java.io.ObjectOutputStream s)
    throws java.io.IOException{
    // Write out element count, and any hidden stuff
    int expectedModCount = modCount;
    s.defaultWriteObject();

    // Write out size as capacity for behavioural compatibility with clone()
    s.writeInt(size);

    // 這裏可以看到，被序列化的那部分數據是真正存在元素的空間，後續沒被使用空間並沒有被序列化，因以節省內存空間。
    for (int i=0; i<size; i++) {
        s.writeObject(elementData[i]);
    }

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

readObject：

private void readObject(java.io.ObjectInputStream s)
    throws java.io.IOException, ClassNotFoundException {
    elementData = EMPTY_ELEMENTDATA;

    // Read in size, and any hidden stuff
    s.defaultReadObject();

    // Read in capacity
    s.readInt(); // ignored

    if (size > 0) {
        // be like clone(), allocate array based upon size not capacity
        ensureCapacityInternal(size);

        Object[] a = elementData;
        //反序列化時，按正確順序讀取所有元素.
        for (int i=0; i<size; i++) {
            a[i] = s.readObject();
        }
    }
}

2.10. 其他方法

public int size()

  返回此列表中的元素數。

public int size() {
    return size;
}
public boolean isEmpty()
如果此列表中沒有元素，則返回 true
public boolean isEmpty() {
    return size == 0;
}

public Object[] toArray()

  按適當順序（從第一個到最後一個元素）返回包含此列表中所有元素的數組。

public Object[] toArray() {
    //返回一個新數組,新數組只包含elementData的有效元素,size:有效元素個數
    return Arrays.copyOf(elementData, size);
}

public List subList(int fromIndex,int toIndex)

  返回列表中指定的 fromIndex（包括 ）和 toIndex（不包括）之間的部分視圖。因此無論改變哪一個集合的數據，另一個的對應數據都會隨之改變。並且返回的集合屬於SubList類型，不能強轉換爲Arraylist。

public List<E> subList(int fromIndex, int toIndex) {
    subListRangeCheck(fromIndex, toIndex, size);
    return new SubList(this, 0, fromIndex, toIndex);
}

public void clear()

  清空列表。

public void clear() {
    // modCount自增1
modCount++;
    // 將底層數組的每個位置的值都置空
    for (int i = 0; i < size; i++)
        elementData[i] = null;
// size置爲0
    size = 0;
}

3 迭代器

  list集合均具有獲取迭代器的方法iterator()和listIterator()。

3.1 Iterator迭代器

Iterator iterator()

  返回在此 collection 的元素上進行迭代的Iterator迭代器，可以用來遍歷、操作collection集合。
  iterator迭代器和枚舉的區別：

1. 迭代器允許調用者利用定義良好的語義在迭代期間從迭代器所指向的 collection
   移除元素。這裏的“枚舉”是指Vector類的elements()方法。
2. 方法名稱得到了改進。

3.1.1 Iterator設計思想

  Iterator爲什麼不定義成爲一個類而是一個接口？
  Java提供了很多的集合類，這些集合類的數據結構是不同的和存儲方式不同,所以它們的遍歷方式也應該不是一樣的。
  假如迭代器定義爲一個類,首先若是具體類那麼就會提供一個公共的實現不同集合遍歷的方法,我們知道這是不可能的。
  若是迭代器一個抽象類又因爲java中類是單繼承的,繼承了迭代器便無法繼承其他類,所以不行,而且集合的根接口無法繼承抽象類。
  而無論哪種集合，都應該具備獲取元素的操作，而且，最好在輔助於判斷功能，這樣，在獲取前，先判斷，更不容易出錯。也就是說，判斷功能和獲取功能應該是一個集合遍歷所具備的，而每種集合的方式又不太一樣，所以我們把這兩個功能給提取出來，並不提供具體實現，這種方式就是接口。
  那麼迭代器真正的具體的實現類在哪裏呢？真正的實現在具體的子類中，以內部類的方式體現的。
  下面是Iterator迭代器和ArrayList集合的關係：

//Iterator接口的定義和方法
public interface Iterator {
    boolean hasNext();
    Object next();
    void remove();
}

// Iterable接口具有獲取Iterator接口的方法
public interface Iterable {
    Iterator iterator();
}

// Collection接口繼承Iterable接口，具有獲取迭代器的功能
public interface Collection extends Iterable {
    Iterator iterator();
}

//List接口繼承Collection接口，同樣繼承了獲取迭代器的功能
public interface List extends Collection {
    Iterator iterator();
}

// ArrayList實現List接口，具體實現了獲取迭代器的功能
public class ArrayList implements List {
    //實現iterator方法
    public Iterator iterator() {
        //返回的匿名內部類對象,已經對Iterator做出了具體的實現
        return new Itr();
    }

    //Iterator接口的具體實現,是在具體實現類的內部類中
    private class Itr implements Iterator<E> {
        public boolean hasNext() {
            //實現hasNext的方法體
        }
        public Object next() {
            //實現next的方法體
        }
        public void remove() {
            //實現remove的方法體
        }
    }
}

Collection c = new ArrayList();
//編譯看左邊，調用看右邊,實際上調用的是ArrayList的iterator方法
Iterator it = c.iterator();     //返回new Itr();
while(it.hasNext()){
    System.out.println(it.next());
}

4.3.1.1. Iterator（接口）的方法

boolean hasNext()

  如果仍有元素可以迭代，則返回true。

E next()

  返回迭代的下一個元素。

void remove()

  從迭代器指向的collection中移除迭代器返回的最後一個元素。

案例：

Collection<String> cl = new ArrayList<>();
cl.add("aa");
cl.add("bb");
cl.add("cc");
cl.add("dd");
//使用while循環,結構更加明瞭
Iterator<String> iterator1 = cl.iterator();
while (iterator1.hasNext()) {
    String next =  iterator1.next();
    System.out.println(next);
}
//使用for循環,利於回收內存
for (Iterator<String> iterator2 = cl.iterator();iterator2.hasNext();)
{
    String next = iterator2.next();
    System.out.println(next);
}

3.1.2 Iterator源碼解析

Iterator iterator()

  該方法屬於集合的方法，被描述爲：返回按適當順序在列表的元素上進行迭代的迭代器。

public Iterator<E> iterator() {
    return new Itr();
}

  可以看到，實際上就是返回一個對象，我們能夠猜到，這就是實現類自己提供的迭代器的實現對象。因此，我們的重點就是看Itr對象是如何實現的！

/**
 * ArrayList內部的迭代器的具體實現
 */
private class Itr implements Iterator<E> {
    //要返回的下一個元素的索引
    int cursor;
    //返回的最後一個元素的索引;如果沒有元素,則是-1
    int lastRet = -1;
    //在創建迭代器對象的時候設置預期的被修改次數 等於該集合最新的被修改次數
    //被用於實現快速失敗機制。
    int expectedModCount = modCount;

    /**
     * 是否有下一個元素
     *
     * @return
     */
    public boolean hasNext() {
        //如果下一個元素的索引不等於集合的size那麼說明還有下一個元素
        return cursor != size;
    }

    /**
     * 獲取下一個元素
     *
     * @return 下一個元素
     */
    public E next() {
        /*首先檢查 該集合在迭代過程是結構是否被改變,如果是將會拋出ConcurrentModificationException異常*/
        checkForComodification();
        //i記錄當前cursor的值，初始化Itr時cursor默認值爲0
        int i = cursor;
        //如果i大於等於size，即下一個元素的索引大於等於size,拋出NoSuchElementException異常
        //出現這種情況可能是出現了"併發修改集合元素"
        if (i >= size)
            //拋出NoSuchElementException異常
            throw new NoSuchElementException();
        //獲取外部類的elementData
        Object[] elementData = ArrayList.this.elementData;
        //如果如果i大於等於elementData.length，將會拋出ConcurrentModificationException異常
        //出現這種情況可能是出現了"併發修改集合元素"
        if (i >= elementData.length)
            //拋出ConcurrentModificationException異常
            throw new ConcurrentModificationException();
        //設置要返回的下一個元素的下一個元素的索引爲原值+1
        cursor = i + 1;
        //返回當前cursor索引的值,並將lastRet設置爲當前將要被返回的元素的索引
        return (E) elementData[lastRet = i];
    }

    /**
     * 移除下一個元素。
     */
    public void remove() {
        //如果lastRet小於0,則拋出異常,默認是小於0的
        //因此要想移除下一個元素,那麼必須先要獲取下一個元素
        if (lastRet < 0)
            throw new IllegalStateException();
        checkForComodification();
        /*移除過程中,如果發生IndexOutOfBoundsException異常，那麼可能是出現了"併發修改集合元素"*/
        try {
            //調用外部類的方法 嘗試移除下一個元素
            ArrayList.this.remove(lastRet);
            //設置cursor等於被移除的下一個元素的索引
            cursor = lastRet;
            //移除元素之後 重新設置lastRet等於-1
            lastRet = -1;
            //設置expectedModCount重新等於modCount
            expectedModCount = modCount;
        } catch (IndexOutOfBoundsException ex) {
            throw new ConcurrentModificationException();
        }
    }

    /**
     * 檢測是否發生了"併發修改",如果是則拋出ConcurrentModificationException異常
     * 這裏的"併發修改異常"是字面翻譯,實際上在單線程情況下也可能觸發
     */
    final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }
}

3.1.3 Iterator實例解析

  上面已經提供了詳細的源碼註釋，下面根據案例來理解其工作流程！

@Test
public void test5() {
    ArrayList<Integer> integers = new ArrayList<Integer>(Arrays.asList(1, 2, 3));
    //獲取迭代器
    Iterator<Integer> iterator = integers.iterator();
    //是否存在下一個元素
    while (iterator.hasNext()) {
        //獲取下一個元素
        Object next = iterator.next();
        //移除下一個元素
        iterator.remove();
    }
}

  首先建立一個集合，使用的是傳入一個數組轉換成的集合的構造器，之後integers集合便擁有了那3個元素（1,2,3）！
  然後是獲取迭代器的方法iterator()，即獲取Itr對象，此時對象中的cursor字段默認爲0，lastRet字段初始化爲-1，expectedModCount位0，因此當前該集合並沒有結構的改變，即modCount=0。
  然後是第一次循環，循環條件是hasNext()方法返回true，明顯cursor（0）不等於size（3），表示存在下一個元素，因此進入循環體。
  next()即獲取下一個元素，首先判斷是否出現併發修改，其實就是判斷modCount和expectedModCount是否還是相等，這裏明顯還是相等的，進入下一步設置i=cursor=0，接下來是一系列，都滿足，然後設置cursor=i+1=1，然後返回elementData[lastRet = i]，即返回elementData[0]，並且設置lastRet=0。
  可以想象，如果下一個方法還是next方法，那麼cursor=1，lastRet=0，然後cursor=2，lastRet=1，返回elementData[1]。如此循環，當cursor==size時，上一次循環返回的數據是elementData[size-1]，此時數組迭代遍歷完畢即可退出循環。
  但是本例後續還有一個remove方法，我們來繼續分析remove的源碼，首先是一個判斷，明顯lastRet=0，因此不會拋出異常，但是如果是多線程條件下，或者多次調用remove都是可能拋出異常的。
  接下來是移除lastRet索引的元素，即移除數組頭部0索引的元素，然後設置cursor=lastRet=0，lastRet=-1。我們知道在外部類的remove方法中，有一個modCount++的代碼，此時modCount和expectedModCount不一致了，因此爲了不拋出異常重新設置expectedModCount = modCount。
  到此刪除方法結束，該次循環結束。此時cursor=0，lastRet=-1，modCount和expectedModCount還是相等的。進入下一次循環我們發現還是和第一次循環一樣的參數值，但是集合中的第一個元素已經被我們取出來並且移除了，如此循環，當移除全部元素時，hasNext方法立即判斷cursor=size=0返回true，此時循環結束，遍歷並移除集合元素的操作結束，程序結束。
  以上就是Iterator迭代器的工作原理，還是比較簡單的！

3.2 ListIterator列表迭代器

  List集合專用的迭代器，繼承了Iterator迭代器，JDK2！

public interface ListIterator extends Iterator

相比於Iterator的特點（優點）：

1. 在迭代期間可以對元素進行增刪改操作
2. 可以反向迭代容器當中的元素。

3.2.1 獲取ListIterator的方法

ListIterator listIterator();

  想要用此方法反向迭代，必須先正向迭代，將迭代器移動至列表結尾。再反向迭代。

public ListIterator listIterator(int index)

  想要用此方法反向迭代，需要index=list.size()。將迭代器定義至列表結尾。

3.2.2 ListIterator的特性

相比於Iterator增加的API方法（功能）：

void add(E e)

  將指定的元素插入列表。新元素被插入到隱式光標前：不影響對 next 的後續調用，並且對 previous 的後續調用會返回此新元素。即對正向迭代無影響，反向迭代，將會返回新元素。

void set(E e)

  用指定元素替換 next 或 previous 返回的最後一個元素

boolean hasPrevious();

  如果以逆向遍歷列表，列表迭代器有多個元素，則返回 true。

E previous()

  返回列表中的前一個元素。

int nextIndex()

  返回對 next 的後續調用所返回元素的索引，如果列表迭代器在列表的結尾，則返回列表大小。

int previousIndex()

  返回對 previous 的後續調用所返回元素的索引，如果列表迭代器在列表的開始，則返回 -1。

3.2.3 ListIterator的實現

  列表迭代器ListIterator，實際上是Iterator的加強版，採用的是繼承Itr來實現的，因此他們的實現思想和基本原理一致，這裏不再贅述！

4 快速失敗(fail-fast)與安全失敗(fail-safe)

4.1 快速失敗(fail-fast)

  如果我們去查看ArrayList的API，能夠看到這一段描述：

  此類的 iterator 和 listIterator方法返回的迭代器是快速失敗的：在創建迭代器之後，除非通過迭代器自身的 remove 或 add方法從結構上對列表進行修改，否則在任何時間以任何方式對列表進行修改，迭代器都會拋出 ConcurrentModificationException。因此，面對併發的修改，迭代器很快就會完全失敗，而不是冒着在將來某個不確定時間發生任意不確定行爲的風險。
  注意，迭代器的快速失敗行爲無法得到保證，因爲一般來說，不可能對是否出現不同步併發修改做出任何硬性保證。快速失敗迭代器會盡最大努力拋出ConcurrentModificationException。因此，爲提高這類迭代器的正確性而編寫一個依賴於此異常的程序是錯誤的做法：迭代器的快速失敗行爲應該僅用於檢測bug。

  上面說的快速失敗機制是什麼呢？
  實際上在源碼中我們已經見過該機制的工作過程了。就是checkForComodification方法中檢測的內容，如果expectedmodCount和當前modCount不相等，那麼就算“併發修改”，此時觸發快速失敗機制，即馬上拋出ConcurrentModificationException異常。
具體工作過程是如何的呢？
  首先是modCount，modCount變量實際上被定義在ArrayList的父類AbstractList中，被用來記錄集合結構修改的次數，在add、remove、addAll、clear等方法調用過程中，modCount會自增，表示集合元素結構被修改。
  在初始化迭代器時，會在迭代器內部設置expectedModCount變量等於外部的modCount變量，此時是肯定不會拋出ConcurrentModificationException異常的。
  集合在被遍歷期間如果內容發生變化，就會改變modCount的值。每當迭代器使用hashNext()/next()遍歷下一個元素之前，都會檢測modCount變量是否爲expectedmodCount值，是的話就返回遍歷；否則拋出異常，終止遍歷。
  接下來就是，如果在遍歷期間，集合元素結構被修改了之時快速失敗機制的處理。我們知道修改集合元素結構的方式有兩種一種是使用集合的方法，另一種是使用迭代器提供的方法，我們剛纔看到了，使用迭代器提供的remove方法時，實際上還是調用的集合的remove方法刪除元素，但是在刪除元素之後會將expectedModCount重新置爲modCount的值，即讓這兩個值變得想等了，因此單線程下使用迭代器的remove方法刪除元素是不會除法快速失敗機制的；但是如果僅僅使用集合的remove方法刪除元素，此時expectedModCount不等於modCount，因此下一次調用next方法時，checkForComodification()方法馬上觸發快速失敗機制拋出異常!
  快速失敗演示：

/**
 * 快速失敗演示
 */
@Test
public void test6() {
    ArrayList<Integer> integers = new ArrayList<Integer>(Arrays.asList(1, 2, 3));
    //獲取迭代器
    Iterator<Integer> iterator = integers.iterator();
    //是否存在下一個元素
    while (iterator.hasNext()) {
        //獲取下一個元素
        Object next = iterator.next();
        //使用集合的方法 移除一個元素，此時會在next()方法中拋出異常
        integers.remove(0);
    }
}

  以上就是快速失敗機制的原理，還是比較簡單的！
  場景：實際上，java.util包下的集合類都是快速失敗的，不能在迭代過程中使用集合的方法修改集合元素結構。

4.2 安全失敗(fail-safe)

  有了快速失敗，我們自然會想是否存在“安全失敗”呢？實際上還真的存在。
  安全失敗，是相對於快速失敗而言的，快速失敗時立即拋出異常，安全失敗則是不會拋出異常，失敗的“很安全”，但是，也是屬於一個“失敗”的操作。
  採用安全失敗機制的集合容器，實際上在遍歷時不是直接在原來的集合內容上訪問的，而是先複製原有集合內容，在拷貝的集合上進行遍歷。這種機制也被稱爲“寫時複製”（Copy-On-Write，簡稱COW），很多實現都使用了該機制，比如Redis的快照功能，Redis寫快照的時候，就用到了Linux底層的Copy-On-Write技術。
  原理：
  由於迭代時是對原集合的拷貝進行遍歷，所以在遍歷過程中對原集合所作的修改並不能被迭代器檢測到，所以不會觸發ConcurrentModificationException。
  優缺點：
  基於拷貝內容的優點是避免了ConcurrentModificationException，但同樣地，迭代器並不能訪問到對於原始集合修改後的內容，即：迭代器遍歷的是開始遍歷那一刻拿到的集合拷貝，在遍歷期間原集合發生的修改迭代器是不知道的。同時這樣造成的代價就是產生一個拷貝的對象，佔用內存，同時數組的copy也是相當損耗性能的。
  因此，例如CopyOnWriteArrayList等集合從根本上直接杜絕了使用迭代器的remove、add方法，調用CopyOnWriteArrayList的迭代器的remove、add直接拋出UnsupportedOperationException
  場景：
  實際上，java.util.concurrent包下的容器都是安全失敗，可以在多線程下併發使用，併發修改，不會拋出異常，但是同樣會造成數據異常。

/**
 * 安全失敗機制演示,不會拋出異常,但是造成了數據不一致
 */
@Test
public void test8() {
    CopyOnWriteArrayList<Integer> integers = new CopyOnWriteArrayList<Integer>(Arrays.asList(1, 2, 3));
    //獲取迭代器
    Iterator<Integer> iterator = integers.iterator();
    //是否存在下一個元素
    while (iterator.hasNext()) {
        //使用集合的方法 移除第一個元素，此時不會在next()方法中拋出異常
        Integer remove = integers.remove(0);
        System.out.println("被移除的: " + remove);
        //獲取下一個元素,被移除的元素還是能獲取到,正是由於Copy-On-Write技術造成的
        Object next = iterator.next();
        System.out.println("獲取到的: " + next);
    }
}

  上面的演示中，首先刪除集合第一個元素，但是下面還是能夠從迭代器中獲取，這也是數據不一致的一種表現。

5 ArrayList的應用

5.1 List去重

  去重思路一： 藉助輔助集合

ArrayList<String> al = new ArrayList<String>();
al.add("aa");
al.add("bb");
al.add("aa");
al.add("dd");
al.add("dd");
al.add("dd");
al.add(null);
al.add("ee");
al.add("ee");
//去重思路一  藉助輔助集合
ArrayList<String> al2 = new ArrayList<String>();
for (String s : al) {
    if (!al2.contains(s))
    {
        al2.add(s);
    }
}
al.clear();
al.addAll(al2);
System.out.println(al);   //[aa, bb, dd, null, ee]

  去重思路二：
  直接利用列表迭代器，無需藉助輔助集合（打亂順序）

ListIterator<String> sli = al.listIterator();
while (sli.hasNext()) {
    String next =  sli.next();   //獲得下一個元素
    sli.remove();   //移除獲得的元素
    if (!al.contains(next))  //判斷源集合是否包含被移除的元素
    {
        sli.add(next);  //沒包含就再添加進來
    }
}
System.out.println(al);

  注意： contains(obj); remove(Object obj);
  以上兩個方法底層是依據equals方法：根據equals方法返回的值，判斷是否移除/或者是判斷是否存在。因此對對象去重時，需要重寫equals方法，使得equals比較的是具體值而不是地址。

  去重思路三：
  使用Java8的lambda表達式輕鬆實現集合去重

al = al.stream().collect(Collectors.collectingAndThen(Collectors.toCollection(HashSet::new), ArrayList::new));
System.out.println(al);

5.2 List排序

  Clooections的sort方法：

public static <T extends Comparable<? super T>> void sort(List list) --自然排序
public static void sort(List list,Comparator<? super T> c) --自定義排序

5.3 獲取ArrayList的容量

  明顯我們無法直接通過可用方法獲取ArrayList的容量，因此只有使用反射獲取：

// 獲取list容量
public static Integer getCapacity(ArrayList list) {
    Integer length = null;
    Class clazz = list.getClass();
    Field field;
    try {
        field = clazz.getDeclaredField("elementData");
        field.setAccessible(true);
        Object[] object = (Object[]) field.get(list);
        length = object.length;
        return length;
    } catch (Exception e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
    return length;
}

5.4 Array和ArrayList的區別以及使用條件

  Array 和 ArrayList都是存放數據的容器.array是代表的是數組，arraylist是一個集合，arraylist底層使用的封裝了一個object數組。它的可變就是數組擴容
區別:

1. Array可以包含基本類型和對象類型，ArrayList只能包含對象類型，jdk1.5之後傳入基本類型會自動裝箱。
2. Array數組在存放的時候一定是同種類型的元素。ArrayList就不一定了，因爲ArrayList可以存儲Object。
3. Array大小是固定的，ArrayList的大小是動態變化的。
4. ArrayList作爲Array的增強版，當然是在方法上比Array更多樣化，比如添加全部addAll()、刪除全部removeAll()、返回迭代器iterator()等。

使用條件：

1. 當存放的內容數量不固定，不確定，有限時採用arraylist。
2. 如果想要保存一些在整個程序運行期間都會存在而且不變的數據，可以放在數組裏。
3. 如果我們需要對元素進行頻繁的移動或刪除，或者是處理的是超大量的數據，那麼，使用ArrayList的效率很低，使用數組進行這樣的容量調整動作很麻煩，我們可以選擇LinkedList。

5.5 迭代器和for循環速度測試

public class ArrayListTest {
    static List<Integer> list = new ArrayList<Integer>();

    static {
        for (int i = 1; i <= 100000000; i++) {
            list.add(i);
        }
    }

    public static long arrayFor() {
        //開始時間
        long startTime = System.currentTimeMillis();
        for (int j = 0; j < list.size(); j++) {
            Object num = list.get(j);
        }
        //結束時間
        long endTime = System.currentTimeMillis();
        //返回所用時間
        return endTime - startTime;
    }

    public static long arrayIterator() {
        long startTime = System.currentTimeMillis();
        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            Object next = iterator.next();
        }
        long endTime = System.currentTimeMillis();
        return endTime - startTime;
    }

    public static void main(String[] args) {
        long time1 = arrayFor();
        long time2 = arrayIterator();

        System.out.println("ArrayList for循環所用時間==" + time1);
        System.out.println("ArrayList 迭代器所用時間==" + time2);
    }
}

6 總結

  ArrayLIst的底層實現就是使用的數組，因此支持重複元素，支持null元素，元素按照插入順序存放、取出。它的可變長度，實際上就是在底層做的數組的來回拷貝，所以實際上如果增、刪操作比較多的話，性能還是比較低下的。但是由於底層是數組，支持隨機訪問，因此如果是遍歷操作比較多的話，那麼性能還是比較高的。
  ArrayLIst稍微複雜點的地方可能是判斷數組容量是否超限的原理（涉及計算機二進制數據的計算原理），以及迭代器的原理，但是都不算很難，總體來說ArrayLIst源碼非常簡單了。
  我們後續將會介紹的更多集合，它們的難度總體也會越來越高，比如LinkedList、TreeMap、HashMap，LinkedHashMap等基本集合以及JUC包中的高級併發集合。如果想學習集合源碼的關注我的更新！

如果有什麼不懂或者需要交流，可以留言。另外希望點贊、收藏、關注，我將不間斷更新各種Java學習博客！