基于JDK1.8對Java中的ArrayList集合的源碼進行了深度解析，包括各種方法、擴容機制、迭代器機制、快速失敗/安全失敗機制的底層實現。

文章目錄

• 1 ArrayList的概述
• 2 ArrayList的源碼解析
• • 2.1. 主要類屬性
  • 2.2 構造器與初始化容量
  • • 2.2.1 ArrayList()
    • 2.2.2 ArrayList(Collection<? extends E> c)
    • 2.2.3 ArrayList(int initialCapacity)
  • 2.3 add方法與擴容機制
  • • 2.3.1 源碼解析
    • 2.3.2 執行流程
    • • 2.3.2.1 計算出最小容量
      • 2.3.2.2 判斷是否需要擴容or數組長度溢出
      • 2.3.2.3 計算新的容量
      • 2.3.2.4 考慮數組長度溢出
      • 2.3.2.5 數組擴容
      • 2.3.2.6 添加元素
    • 2.3.3 補充說明
  • 2.4 addAll方法
  • 2.5 remove方法
  • 2.6 get方法
  • 2.7 set方法
  • 2.8 clone方法
  • 2.9 序列化
  • 2.10. 其他方法
• 3 迭代器
• • 3.1 Iterator迭代器
  • • 3.1.1 Iterator設計思想
    • 3.1.2 Iterator源碼解析
    • 3.1.3 Iterator實例解析
  • 3.2 ListIterator列表迭代器
  • • 3.2.1 獲取ListIterator的方法
    • 3.2.2 ListIterator的特性
    • 3.2.3 ListIterator的實現
• 4 快速失敗(fail-fast)與安全失敗(fail-safe)機制
• • 4.1 快速失敗(fail-fast)
  • 4.2 安全失敗(fail-safe)
• 5 總結

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,則構建指定長度的空數組并賦值給elementDatathis.elementData = new Object[initialCapacity];} else if (initialCapacity == 0) {//如果指定初始容量等于0,則將已有的空數組賦值給elementDatathis.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自增1elementData[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的大小,即最小容量不小于10minCapacity = 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);//如果新容量減去最小容量的值小于0if (newCapacity - minCapacity < 0)//新容量等于最小容量newCapacity = minCapacity;//如果新容量減去建議最大容量的值大于0if (newCapacity - MAX_ARRAY_SIZE > 0)//調整新容量上限或者拋出OutOfMemoryErrornewCapacity = 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方法的流程，共有六步：

計算出最小容量；

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

計算新的容量；

考慮數組長度溢出；

數組擴容；

添加元素。

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，那么該方法結束，說明不需要擴容or數組長度并沒有溢出，進入步驟6。

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-2byte[] 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這個異常呢？目前還沒想通……

如果此時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。

2.3.3 補充說明

在add方法的源碼中，我們能看到很多判斷的是通過計算得到的值來判斷的：x-y>0。比如minCapacity - elementData.length>0。很多人看到這里就會直接簡化理解成比較兩個數大小，事實真的這么簡單的嗎？如果真的僅僅是比較兩個數的大小，那為什么不直接使用比較符號>或者<呢？

通過上面的分析以及介紹的計算機二進制計算原理，其實我們能夠知道，通過計算得到的值來判斷 而不是直接的比較兩個數大小的原因是為了能夠兼容數組長度溢出的情況。

比如最開始size=Integer.MaxValue-8，即2147483639，然后你調用addAll方法添加9個元素，minCapacity=size+9，minCapacity不是變成了2147483648，而是變成了-2147483648，如果此時直接使用比較符號，那么minCapacity是肯定小于elementData.length的值的，但是如果使用-2147483648-elementData.length，那么得到的值肯定是大于0的正數，后續的方法調用才能夠處理這種數組長度溢出的情況。如果僅僅使用比較符號，就不能判斷數組容量是否溢出的情況，從而造成異常！

JDK的源碼有很多看起來不能理解或者很傻的地方，但是實際上這些操作都是很有深意的，不要輕信別人的介紹（包括我），多多了自己思考，源碼這么寫到底是為了什么？你就能從讀源碼的過程中學到更多！

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增加numNewsize += 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-1int 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 Cloneablethrow 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 stuffint 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 stuffs.defaultReadObject();// Read in capacitys.readInt(); // ignoredif (size > 0) {// be like clone(), allocate array based upon size not capacityensureCapacityInternal(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置為0size = 0; }

3 迭代器

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

3.1 Iterator迭代器

Iterator iterator()

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

iterator迭代器和枚舉的區別：

迭代器允許調用者利用定義良好的語義在迭代期間從迭代器所指向的 collection
移除元素。這里的“枚舉”是指Vector類的elements()方法。

方法名稱得到了改進。

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;//返回的最后一個元素的索引;如果沒有元素,則是-1int lastRet = -1;//在創建迭代器對象的時候設置預期的被修改次數 等于該集合最新的被修改次數//被用于實現快速失敗機制。int expectedModCount = modCount;/*** 是否有下一個元素** @return*/public boolean hasNext() {//如果下一個元素的索引不等于集合的size那么說明還有下一個元素return cursor != size;}/*** 獲取下一個元素** @return 下一個元素*/public E next() {/*首先檢查 該集合在迭代過程是結構是否被改變,如果是將會拋出ConcurrentModificationException異常*/checkForComodification();//i記錄當前cursor的值，初始化Itr時cursor默認值為0int i = cursor;//如果i大于等于size，即下一個元素的索引大于等于size,拋出NoSuchElementException異常//出現這種情況可能是出現了"并發修改集合元素"if (i >= size)//拋出NoSuchElementException異常throw new NoSuchElementException();//獲取外部類的elementDataObject[] elementData = ArrayList.this.elementData;//如果如果i大于等于elementData.length，將會拋出ConcurrentModificationException異常//出現這種情況可能是出現了"并發修改集合元素"if (i >= elementData.length)//拋出ConcurrentModificationException異常throw new ConcurrentModificationException();//設置要返回的下一個元素的下一個元素的索引為原值+1cursor = 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等于-1lastRet = -1;//設置expectedModCount重新等于modCountexpectedModCount = 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的特點（優點）：

在迭代期間可以對元素進行增刪改操作

可以反向迭代容器當中的元素。

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的底層實現就是使用的數組，因此支持重復元素，支持null元素，元素按照插入順序存放、取出。它的可變長度，實際上就是在底層做的數組的來回拷貝，所以實際上如果增、刪操作比較多的話，性能還是比較低下的。但是由于底層是數組，支持隨機訪問，因此如果是遍歷操作比較多的話，那么性能還是比較高的。

ArrayLIst稍微復雜點的地方可能是判斷數組容量是否超限的原理（涉及計算機二進制數據的計算原理），以及迭代器的原理，但是都不算很難，總體來說ArrayLIst源碼非常簡單了。

我們后續將會介紹的更多集合，它們的難度總體也會越來越高，比如LinkedList、TreeMap、HashMap，LinkedHashMap等基本集合以及JUC包中的高級并發集合。如果想學習集合源碼的關注我的更新！

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

總結

以上是生活随笔為你收集整理的ArrayList源码深度解析以及快速失败和安全失败机制详解【一万字】的全部內容，希望文章能夠幫你解決所遇到的問題。

如果覺得生活随笔網站內容還不錯，歡迎將生活随笔推薦給好友。