在Java給我們提供的各種容器類中，最常用的就是ArrayList了吧，你可能早就把它用爛了，但它內部細節是怎麼實現的，陣列怎麼動態增長的呢？今天我們就來看一下ArrayList的原始碼一探個究竟。
本文分析的ArrayList原始碼基於JDK 1.8
1. ArrayList 的定義
首先開啟ArrayList類，看一下這個類的定義：
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
複製程式碼ArrayList繼承自AbstractList，支援泛型。
然後實現了這些介面：
- List 說明該類是一個有序的序列集合。
- RandomAccess 說明該類支援時間複雜度為O(1)隨機訪問；RandomAccess介面一般只用在實現了List介面的類。
- Cloneable 說明該類支援被克隆。
- Serializable 說明該類支援序列化。
ArrayList還間接實現了Iterable和Collection介面。
2. ArrayList 的屬性
ArrayList 中宣告瞭下面這些屬性：
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
// 序列化ID
private static final long serialVersionUID = 8683452581122892189L;
// ArrayList的預設初始容量
private static final int DEFAULT_CAPACITY = 10;
// 一個空的物件陣列，用來初始化內容為空的ArrayList例項
private static final Object[] EMPTY_ELEMENTDATA = {};
// 資料物件陣列，真正的資料都儲存在這個陣列之中，標了transient關鍵字說明該物件陣列不參與序列化
transient Object[] elementData;
// 當前ArrayList中包含的元素的個數
private int size;
// 當前ArrayList被修改過的次數
protected transient int modCount = 0;
// ...
}
複製程式碼3. ArrayList 的建構函式
ArrayList分別提供了下面三個建構函式，首先來看下我們最常使用的無參建構函式：
public ArrayList() {
super();
this.elementData = EMPTY_ELEMENTDATA;
}
複製程式碼很簡單，呼叫了下父類的建構函式（點進去發現父類建構函式是個空實現），然後將之前宣告的空物件陣列EMPTY_ELEMENTDATA賦值給elementData屬性。
接著看下可以傳初始容量的建構函式：
public ArrayList(int initialCapacity) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
this.elementData = new Object[initialCapacity];
}
複製程式碼也是先呼叫父類建構函式，然後判斷如果傳進來的初始化容量initialCapacity小於0則丟擲異常，否則建立一個大小為initialCapacity的物件陣列並賦值給elementData。
最後還有個可以傳集合的建構函式：
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
size = elementData.length;
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
}
複製程式碼該方法要求傳入實現了Collection介面的類的物件，然後呼叫Collection類中的toArray()方法即可將該集合物件中包含的全部元素轉換為物件陣列。 接著再初始化size。
按道理來說這就應該初始化完畢了吧，可是為什麼後面又緊跟了一句：
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
複製程式碼
原來Collection類的toArray()返回的不一定是Object[]類，舉個例子：
public static void main(String[] args) {
Collection c = Arrays.asList("a", "b", "c");
System.out.println(c.toArray().getClass());
List<Object> list = new ArrayList<>(c);
list.set(0,new Object());
}
複製程式碼執行會發現，列印輸出的是class [Ljava.lang.String;，因此此時ArrayList內部的elementData即為String型別了，這時候呼叫最後一句list.set(0,new Object())則會丟擲ArrayStoreException異常，因為你不能往一個String陣列設定物件。
4. ArrayList 新增資料
4.1 add(E e)
先看下最常用的add(E e)方法：
public boolean add(E e) {
ensureCapacityInternal(size + 1);
elementData[size++] = e;
return true;
}
複製程式碼該方法先呼叫了ensureCapacityInternal()方法，從方法名可以猜測，這個方法應該就是用來對陣列進行動態擴容的，跳轉到該方法：
private void ensureCapacityInternal(int minCapacity) {
if (elementData == EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
複製程式碼該方法的引數minCapacity表示當前要求的最小容量，我們前面傳過來的是size + 1，即最小容量只要比當前元素數量多1就夠了。
如果elementData == EMPTY_ELEMENTDATA，則說明該ArrayList是通過無參建構函式構造的，這時候我們的minCapacity取預設容量(10)的和傳進來最小容量中較大的那一個。
接著又將minCapacity傳給ensureExplicitCapacity()方法：
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
複製程式碼先自增了一下modCount，然後接著的程式碼就好玩了，為什麼不直接
if (minCapacity > elementData.length){
grow(minCapacity);
}
複製程式碼而要做個減法跟0比較呢？然後他這兒還有個註釋，說overflow-conscious code又是怎麼回事呢？
好接著點進grow()方法：
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
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);
elementData = Arrays.copyOf(elementData, newCapacity);
}
複製程式碼
看到這裡，我不禁產生了關掉IDE的衝動。
好的，分情況討論一下。
- 先假設傳進來的minCapacity = 11，物件陣列elementData目前大小是10，即oldCapacity = 10，newCapacity在oldCapacity的基礎上增加一半，即newCapacity = 15；newCapacity - minCapacity = 4 > 0，第一個條件不通過；newCapacity - MAX_ARRAY_SIZE顯然小於0，第二個條件也不通過，所以到下一步newCapacity還是等於15，然後呼叫Arrays.copyOf(elementData, newCapacity)建立了一個長度為15的陣列副本，將原陣列中的資料拷貝到這個陣列副本中，最後將陣列副本賦值給elementData。看一下Arrays.copyOf()方法的原始碼就知道了：
public static <T> T[] copyOf(T[] original, int newLength) {
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;
}
複製程式碼-
現在我們假設minCapacity = 16，物件陣列elementData的大小還是10，那麼跟剛剛唯一的區別就是newCapacity - minCapacity = -1 < 0，第一個條件通過，即newCapacity = 16，剩下還是一樣。
-
接下來就好玩了，如果當前elementData的大小已經超級大了，我是說超級超級大，大到了接近Integer.MAX_VALUE。
我們現在假設elementData的大小為Integer.MAX_VALUE - 100(即2147483547)，則minCapacity = Integer.MAX_VALUE - 99(即2147483548)，那麼此時再計算newCapacity則會溢位，此時newCapacity = -1073741976，變成了負數；此時newCapacity - minCapacity = 1073741772 > 0，不滿足第一個條件；newCapacity - MAX_ARRAY_SIZE = 1073741681 > 0, 通過第二個條件，呼叫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;
}
複製程式碼hugeCapacity方法先判斷minCapacity是不是溢位了，如果溢位了就丟擲OutOfMemoryError，接著如果minCapacity沒有溢位但是比MAX_ARRAY_SIZE大，則返回Integer.MAX_VALUE，否則就返回MAX_ARRAY_SIZE。 在我們舉例的這個情況下，hugeCapacity方法返回MAX_ARRAY_SIZE，因此最終的newCapacity就等於MAX_ARRAY_SIZE。
接下來考慮一下，如果我們把grow方法改寫成下面這樣會發生什麼：
private void grow(int minCapacity) {
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity < minCapacity)
newCapacity = minCapacity;
if (newCapacity > MAX_ARRAY_SIZE)
newCapacity = hugeCapacity(minCapacity);
elementData = Arrays.copyOf(elementData, newCapacity);
}
複製程式碼還是套用我們剛才的資料，oldCapacity = Integer.MAX_VALUE - 100(2147483547)，minCapacity = Integer.MAX_VALUE - 99(即2147483548)，newCapacity = -1073741976。會發現，修改過得程式碼跟原始碼的運作剛好相反，第一個條件通過，第二個條件則不通過，即不會呼叫hugeCapacity方法。這樣的話ArrayList就無法正確地擴容。
到這裡擴容部分的程式碼就結束了，回來看一下我們開始的add方法：
public boolean add(E e) {
ensureCapacityInternal(size + 1);
elementData[size++] = e;
return true;
}
複製程式碼正確擴容後，直接將元素e賦值給物件陣列elementData下標為size的位置，因為此時size就是新增的元素應該在的下標，然後將size自增。
4.2 add(int index, E element)
接下來看下add(int index, E element)方法，在特定的下標index處插入元素：
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++;
}
private void rangeCheckForAdd(int index) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
複製程式碼首先呼叫了rangeCheckForAdd方法檢查下標index是否合法，不合法丟擲異常IndexOutOfBoundsException。
然後是呼叫ensureCapacityInternal方法進行擴容，確保ArrayList容量夠存放size + 1個元素。
接下來的System.arraycopy(elementData, index, elementData, index + 1,size - index)做的是將從index開始的元素全部都往後移動一位，如果原來的元素是[1,2,4,5]，index = 2，element = 3，經過這步會變成[1,2,4,4,5]。
接著就把元素element覆蓋到陣列中index的位置。即變成了[1,2,3,4,5]。
最後將size自增。
該方法最壞的情況是index = 0，因為這樣的話當前ArrayList中全部的元素都得往後移動一位。
4.3 addAll(Collection<? extends E> c)
我們剛看完了新增單個元素，現在來看下如何新增多個元素，ArrayList提供了addAll(Collection<? extends E> c)方法：
public boolean addAll(Collection<? extends E> c) {
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size + numNew); // Increments modCount
System.arraycopy(a, 0, elementData, size, numNew);
size += numNew;
return numNew != 0;
}
複製程式碼該方法的引數也是Collection介面，呼叫Collection提供的toArray方法將Collection中的全部元素轉換為物件陣列a；接著獲取該陣列的大小並賦值給numNew，然後同樣是呼叫ensureCapacityInternal進行擴容。確保ArrayList容量可以存放size + numNew個元素後，直接將物件陣列a中的全部元素從末尾拷貝進elementData。最後正確增加size，如果numNew不為0返回true，否則返回false。
這裡我不理解的是，為什麼不先判斷集合是否為空，如果為空直接返回false就省去了後面的方法呼叫，有知道的朋友麻煩告訴我噢！
4.4 addAll(int index, Collection<? extends E> c)
ArrayList還提供了addAll(int index, Collection<? extends E> c)方法，可以從指定位置index開始插入多個元素：
public boolean addAll(int index, Collection<? extends E> c) {
rangeCheckForAdd(index);
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size + numNew);
int numMoved = size - index;
if (numMoved > 0)
System.arraycopy(elementData, index, elementData, index + numNew,numMoved);
System.arraycopy(a, 0, elementData, index, numNew);
size += numNew;
return numNew != 0;
}
複製程式碼同樣先通過呼叫rangeCheckForAdd方法判斷index是否合法，index合法後接下來還是先調Collection的toArray方法轉換為物件陣列a，然後一樣呼叫ensureCapacityInternal方法。
跟前面的addAll方法不同的是，我們這裡可能要移動一些元素，因此通過size - index先計算要移動的元素個數，如果numMoved大於0則說明需要移動元素，即將index開始的元素統統往後numNew位；否則numMoved等於0，說明直接從末尾新增，無需移動元素。
接下來將物件陣列a中的全部元素從index開始拷貝到elementData中。最後正確增加size。如果numNew不等於0返回true。
5. ArrayList 訪問資料
訪問資料比較簡單，ArrayList提供了get()方法：
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];
}
複製程式碼首先呼叫rangeCheck(int index)方法檢查下標是否超出了範圍，然後通過呼叫封裝好的elementData(int index)方法獲取index對應的元素。
6. ArrayList 查詢資料
6.1 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分兩種情況，如果查詢的物件為null，則通過for迴圈找到第一個為null的元素的位置並返回了；如果查詢的物件不為null，則通過呼叫equals()方法判斷是否同一個元素，找到即返回位置；如果沒找到返回-1。
6.2 lastIndexOf(Object o)
public int lastIndexOf(Object o) {
if (o == null) {
for (int i = size-1; i >= 0; i--)
if (elementData[i]==null)
return i;
} else {
for (int i = size-1; i >= 0; i--)
if (o.equals(elementData[i]))
return i;
}
return -1;
}
複製程式碼lastIndexOf()方法跟indexOf()方法唯一的區別就是它的for迴圈是從後往前的。
6.3 contains(Object o)
public boolean contains(Object o) {
return indexOf(o) >= 0;
}
複製程式碼contains方法是通過呼叫indexOf方法實現的，如果indexOf方法返回的數字大於等於零，說明物件o存在，否則返回-1。
7. ArrayList 刪除資料
7.1 remove(int index)
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;
}
複製程式碼remove方法的操作是，把index後面的元素都往前移一位，然後刪除最後一個元素。
7.2 remove(Object o)
remove(Object o) 可以用來刪除某指定元素
public boolean remove(Object o) {
if (o == null) {
for (int index = 0; index < size; index++)
if (elementData[index] == null) {
fastRemove(index);
return true;
}
} else {
for (int index = 0; index < size; index++)
if (o.equals(elementData[index])) {
fastRemove(index);
return true;
}
}
return false;
}
複製程式碼該方法跟indexOf(Object o)非常相似。remove(Object o)方法找到元素所在位置後，呼叫fastRemove(int index)方法刪除元素：
private void fastRemove(int index) {
modCount++;
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
}
複製程式碼fastRemove(int index)跟remove(int index)方法的區別是，它不檢查index，也不返回刪除的元素。
8. ArrayList 修改資料
ArrayList提供了set(int index, E element)方法來更新某位置的值，也比較簡單：
public E set(int index, E element) {
rangeCheck(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}
複製程式碼先呼叫rangeCheck()方法保證index合法，接下來呼叫elementData()方法獲取index位置的元素並儲存在區域性變數oldValue中，然後將該位置的元素更新為element，最後返回oldValue。
9. 其他
9.1 trimToSize()
trimToSize()方法可以用來將物件陣列的大小壓縮到跟size一樣大：
public void trimToSize() {
modCount++;
if (size < elementData.length) {
elementData = Arrays.copyOf(elementData, size);
}
}
複製程式碼9.2 size()
size()方法返回當前包含的元素大小
public int size() {
return size;
}
複製程式碼9.3 isEmpty()
判斷當前ArrayList內的元素是否為空
public boolean isEmpty() {
return size == 0;
}
複製程式碼9.4 toArray()
返回包含當前ArrayList全部元素的物件陣列
public Object[] toArray() {
return Arrays.copyOf(elementData, size);
}
複製程式碼9.5 clear()
清除當前ArrayList中全部元素
public void clear() {
modCount++;
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;
}
複製程式碼就把物件陣列中每個元素設為null，然後size重置為0。
9.6 sort(Comparator<? super E> c)
根據傳進來的Comparator對ArrayList中的元素進行排序：
public void sort(Comparator<? super E> c) {
final int expectedModCount = modCount;
Arrays.sort((E[]) elementData, 0, size, c);
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
modCount++;
}
複製程式碼具體的排序通過呼叫Arrays中的靜態方法sort(T[] a, int fromIndex, int toIndex,Comparator<? super T> c)。