ArrayList詳解-原始碼分析
1. 概述
在平時的開發中，用到最多的集合應該就是ArrayList了，本篇文章將結合原始碼來學習ArrayList。
- ArrayList是基於陣列實現的集合列表
- 支援任意性的訪問（可根據索引直接得到你想要的元素）
- 執行緒不安全
- 支援動態擴容
- 查詢快，增刪慢
- ...
這些大家應該都很清楚，下面根據原始碼來深入分析一下ArrayList。
2. ArrayList類宣告
原始碼如下所示：
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
初步分析：
- ArrayList類繼承於AbstractList抽象類
- ArrayList類實現了List、RandomAccess、Cloneable、Serializable介面
繼續分析一下：
- AbstractList抽象類其實已經實現了Collection介面中大部分方法
- 實現了RandomAccess介面，所以支援任意性訪問（隨機訪問）
- 實現了Cloneable介面，說明重寫了 clone()方法，支援拷貝（Cloneable 介面只是個合法呼叫 clone() 的標識（marker-interface)，一個物件想呼叫clone()方法，則該類必須實現Cloneable 介面，否則會報錯 CloneNotSupportedException ）
- 實現了Serializable介面，支援序列化操作
3. 成員變數
原始碼如下所示：
private static final long serialVersionUID = 8683452581122892189L;
/**
* Default initial capacity.
*/
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 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; // non-private to simplify nested class access
private int size;
初步思考：
-
一共有6個變數，各自的作用？
-
有兩個空陣列，只是命名不一樣，為什麼？
繼續分析：
- 各個變數的作用：
- serialVersionUID： 序列化版本號
- DEFAULT_CAPACITY：預設容量大小
- EMPTY_ELEMENTDATA：空陣列時的引用
- DEFAULTCAPACITY_EMPTY_ELEMENTDATA：初始化時預設的空陣列
- elementData：實際儲存集合元素的陣列
- size：實際元素的數量（int型別預設值為0）
- 兩個空陣列：
- 分別用於預設初始化和傳入容量時的初始化
4. 構造方法
原始碼如下所示：
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
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;
}
}
初步思考：
- 提供了三個構造方法
- 分別對應無參構造、指定集合容量的構造以及通過Collection的子類來構造一個ArrayList物件
繼續分析：
-
無參構造：
- 直接將DEFAULTCAPACITY_EMPTY_ELEMENTDA他的空陣列賦值給elementData（注意：此時ArrayList的陣列長度還是0）
-
指定容量構造：
- 引數大於0： 建立一個該引數大小的陣列，賦值給elementData
- 引數等於0： 將成員變數EMPTY_ELEMENTDATA陣列賦值給elementData
- 引數小於0： 丟擲異常
-
傳入Collection子類物件構造：
public ArrayList(Collection<? extends E> c) { /** *將傳入的集合轉換為一個Object型別的陣列，並將此陣列的引用賦給elementData */ elementData = c.toArray(); if ((size = elementData.length) != 0) {// 轉換後的陣列不為空時 /** * 判斷轉換後的陣列是不是Object[]陣列 * 如果不是的話，就把它複製為一個Object[]陣列，進行賦值 */ if (elementData.getClass() != Object[].class) elementData = Arrays.copyOf(elementData, size, Object[].class); } else { // 轉換後的陣列為空，用成員變數EMPTY_ELEMENTDATA來輔助 this.elementData = EMPTY_ELEMENTDATA; } }toArray()方法原始碼如下:
public Object[] toArray() { return Arrays.copyOf(elementData, size); }Arrays類的copyOf()方法原始碼如下：
@SuppressWarnings("unchecked") public static <T> T[] copyOf(T[] original, int newLength) { // 此處的copyOf()呼叫了本類的過載方法 return (T[]) copyOf(original, newLength, original.getClass()); }過載方法原始碼如下所示：
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); System.arraycopy(original, 0, copy, 0, Math.min(original.length, newLength)); return copy; }程式碼分析：
-
使用三元運算子進行判斷傳入陣列的型別
-
如果傳入的陣列型別強轉為Object[]陣列為true，則建立一個Object[newLength]陣列賦值給copy
-
如果為false，則利用反射獲取到傳入陣列的型別，建立一個該型別的指定長度的陣列賦值給copy
-
-
呼叫native方法進行賦值
-
最後返回copy
呼叫鏈最後呼叫到了native方法上：
public static native void arraycopy(Object src, int srcPos,Object dest, int destPos, int length); /** * 引數說明： * src：源物件 * srcPos：源陣列中的起始位置 * dest：目標陣列物件 * destPos：目標資料中的起始位置 * length：要拷貝的陣列元素的數量 */
原始碼中最後都呼叫到了native方法，只能看到方法名和引數，看不到具體的實現，對native方法做個簡單的介紹吧。
native宣告的介面方法： Java程式碼和本地C程式碼進行互操作的API，稱為Java Native Interface (Java本地介面)。也就是說，帶有native標記的方法，都是使用C語言來實現的，讀者瞭解到這裡即可，感興趣的可以去查閱下相關資料，這裡就不多闡述了。
5. 常用方法分析
-
add(E e)
原始碼如下所示：
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
初步分析：
- 呼叫一個ensureCapacityInternal()方法，ensure Capacity Internal 直接谷歌翻譯，意思是確保內部容量，此方法內應該就隱藏著ArrayList動態擴容的方法了！
- 將傳入引數e，賦值給elementData[]陣列中下標為size++的元素
- 返回true
繼續跟蹤ensureCapacityInternal()方法，該方法相關原始碼如下所示：
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
分析：
- 先對elementData陣列進行空陣列判斷，注意：這裡是直接使用 ==運算子來進行判斷的，回顧下前面講到的ArrayList的無參構造方法
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
發現了沒？如果使用預設的構造方法，呼叫的是DEFAULTCAPACITY_EMPTY_ELEMENTDATA空陣列，執行add()方法之前，ArrayList陣列的長度都是零，新增第一個元素後，陣列的長度就變為10了。
- 下一個方法是ensureExplicitCapacity()，我們繼續跟蹤。
該方法原始碼如下所示：
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
初步分析：
- 出現了一個前面沒看到的變數modCount
- 裡面還有一個grow()方法，ArrayList能夠動態擴容的原因就在這個方法裡面了，八九不離十了！grow這個單詞我還是認識的，哈哈哈~~~
繼續分析：
- 經過追蹤，發現modCount是ArrayList 的父類AbstractList的一個成員變數，作用是記錄ArrayList的size變化，新增元素時，該變數會自增一次。
- minCapacity變數是要新增元素在elementData陣列裡的索引，當該變數值超過elementData陣列長度的時候，elementData陣列就要進行動態擴容了！
接下來，看下grow()方法的原始碼，馬上就要揭開ArrayList能夠動態擴容的根本原因了，想想還有些激動，哈哈~
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);
}
分析：
-
將當前未新增新元素的elementData的陣列長度賦值給oldCapacity變數，表示舊陣列的容量
-
定義一個變數newCapacity，表示新陣列的容量，新陣列的容量大小為舊陣列容量的1.5倍
- 此處用到了移位操作，>>是移位運算子，表示帶符號數右移
- 向右移動n位，等同於除以2的n次方
-
此處需要注意一個地方，如果oldCapacity + (oldCapacity >> 1)執行的結果超過了int的最大值，即2的31次方減1，那麼新陣列的長度將變為負數
-
下面就是比較新陣列容量和舊陣列的容量，將較大的容量賦值給新陣列
-
如果新陣列的容量大小超過了定義的MAX_ARRAY_SIZE大小，那麼將呼叫hugeCapacity()方法
程式碼如下：
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
-
傳入的容量是負數，考慮到了數值溢位，丟擲異常
-
傳入的容量超過了MAX_ARRAY_SIZE大小，則將Integer.MAX_VALUE的值進行返回，否則返回MAX_ARRAY_SIZE
- 最後呼叫Arrays.copyOf()方法，將舊陣列複製到新陣列中，至此便完成了陣列的動態擴容
-
add(int index, E element)
原始碼如下所示：
public void add(int index, E element) {
rangeCheckForAdd(index);
ensureCapacityInternal(size + 1); // Increments modCount!!
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}
基於add()方法的分析，分析如下：
- 判斷索引是否越界
- 複製陣列，進行移動
- 將傳入引數賦值給指定下標的陣列元素
- 集合長度加1
rangeCheckForAdd()方法原始碼如下所示：
private void rangeCheckForAdd(int index) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
分析如下：
- 索引的上限是實際元素的長度，下限是0
- 超過這兩個邊界值就會丟擲異常
注意：由於此處判斷範圍上限取的實際元素的個數，那麼就會造成一個情況，我們使用指定容量的構造方法，建立了一個ArrayList物件，然後使用add（int index, E element）方法時，當新增的index不是0時，就會報錯
舉例如下：
public static void main(String[] args) {
List<String> a = new ArrayList<>(12);// 初始化指定了陣列的容量為12
a.add(5, "element");
}
//結果如下：
// Exception in thread "main" java.lang.IndexOutOfBoundsException: Index: 5, Size: 0
// at java.util.ArrayList.rangeCheckForAdd(ArrayList.java:661)
// at java.util.ArrayList.add(ArrayList.java:473)
// at test.TestAddArrayList.main(TestAddArrayList.java:11)
-
get(int index)
原始碼如下所示：
public E get(int index) {
rangeCheck(index);
return elementData(index);
}
private void rangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
E elementData(int index) {
return (E) elementData[index];
}
簡要分析：
- 首先判斷索引是否在正確的範圍之內，此處僅僅只是判斷了上限為實際元素個數
- 超過上限時的報錯提示資訊為 "Index: "+index+", Size: "+size
- 當index為負數時的報錯提示資訊則是：index，僅僅只是顯示你訪問的index值
- 呼叫elementData()方法，直接返回對應索引位置的元素
-
remove(int index)
原始碼如下所示：
public E remove(int index) {
rangeCheck(index);
modCount++;
E oldValue = elementData(index);
int numMoved = size - index - 1;
if (numMoved > 0)
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size] = null; // clear to let GC do its work
return oldValue;
}
分析：
- 首先對index進行判斷是否在正確的範圍內
- 移除元素使得陣列長度發生了變化，所以modCount++
- 計算需要移動的元素個數
- 呼叫arraycopy()方法進行陣列元素的複製和移動
- 將陣列實際長度的最後一位元素賦值為null，方便GC進行回收
- 最後返回索引位置的元素
不難看出，移除元素實際上也是陣列的複製和移動。
-
indexOf(Object o)
原始碼如下所示：
public int indexOf(Object o) {
if (o == null) {
for (int i = 0; i < size; i++)
if (elementData[i]==null)
return i;
} else {
for (int i = 0; i < size; i++)
if (o.equals(elementData[i]))
return i;
}
return -1;
}
indexOf方法是返回某元素在ArrayList物件裡的下標（索引）。
分析：
-
區分兩種情況
-
查詢元素為null時，使用==運算子進行判斷，返回索引
-
非null元素時，使用equals()方法來判斷（ps:由此處呼叫的equals()方法，可以看出為什麼不支援基本型別的元素）
-
當查詢的元素不存在列表中，返回-1
ArrayList中還有很多方法，篇幅有限，在此不再贅述。
6. 總結
ArrayList是開發中用的最多了一個集合類了，很多時候我們只是停留在使用上面，沒有深入的去學習，分析，為什麼是這樣？為什麼會這樣？有時候遇到問題了，也只能兩眼一抹黑，不知道具體原因是什麼，多看原始碼，多學習，提高解決問題的能力，一點點的進步，就好。