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_ELEMENTDATA的空數組賦值給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是開發中用的最多了一個集合類了，很多時候我們只是停留在使用上面，沒有深入的去學習，分析，為什么是這樣？為什么會這樣？有時候遇到問題了，也只能兩眼一抹黑，不知道具體原因是什么，多看源碼，多學習，提高解決問題的能力，一點點的進步，就好。