1. 簡介
ArrayList 實現了 List 接口，其底層基於數組實現容量大小動態可變。既然是數組，那么元素存放一定是有序的，並允許包括 null 在內的所有元素。
每個 ArrayList 實例都有一個容量（capacity）。該容量是指用來存儲列表元素的數組的大小。它總是至少等於列表的大小。隨着向 ArrayList 中不斷添加元素，其容量也自動增長。
2. 初始化
// Test::main() 構造一個List實例
List<Integer> list1 = new ArrayList<>();
ArrayList 初始化源碼如下：
// 空數組
private static final Object[] EMPTY_ELEMENTDATA = {};
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
// 保存元素的緩沖數組（存放值的數組）
transient Object[] elementData;
// 集合中包含的元素數量
private int size;
// 構造一個空的數組
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
// 構造一個指定長度的數組
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(Collection<? extends E> c) {
Object[] a = c.toArray();
if ((size = a.length) != 0) {
if (c.getClass() == ArrayList.class) {
elementData = a;
} else {
elementData = Arrays.copyOf(a, size, Object[].class);
}
} else {
// replace with empty array.
elementData = EMPTY_ELEMENTDATA;
}
}
看了源碼之后感覺ArrayList的初始化好簡單，有如下幾種方式：
- 構造一個空數組。
- 構造一個指定長度的數組。
- 將傳入的集合轉成數組，並指向 elementData。
既然創建ArrayList實例是通過new出來的，那我們不妨看一看list1實例在jvm中是如何分布的。
ArrayList.class 被加載時，static修飾的變量，會被加載到方法區。
當我們再創建一個ArrayList實例list2，會是如何分布呢？
通過數據在JVM中的分布，我們可以了解到作者設計的巧妙之處，當我們創建多個list實例時，其實底層都是指向緩存在方法區的Object[]數組。
3. 自動擴容
3.1 第一次添加元素
在看自動擴容之前，我們先了解下當我們第一次給list中添加元素的時候，底層都干了些什么事。
private int size;
// ArrayList::add()
public boolean add(E e) {
ensureCapacityInternal(size + 1);
// 給指定的索引元素賦值 沒啥好說的
elementData[size++] = e;
return true;
}
我們繼續看下ensureCapacityInternal方法。
// 默認的容量長度
private static final int DEFAULT_CAPACITY = 10;
private void ensureCapacityInternal(int minCapacity) {
// 當第一次add的時候 minCapacity = 1，elementData = {}
ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}
// 計算容量值
private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
// 當 elementData = {}時，獲取最大值，即返回10
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// 10 - 0 > 0
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
// 真正的擴容方法
private void grow(int minCapacity) {
// 舊容量 = 0
int oldCapacity = elementData.length;
// 新容量 = 0 + 0 / 2 即：新容量 = 0。右移一位相當於除以2
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
// 0 - 10 < 0。 newCapacity = 10
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// 將elementData的值 copy 到 新容量的數組中
elementData = Arrays.copyOf(elementData, newCapacity);
}
copy過程如下：
// 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);
// native方法，實現值copy
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
從源碼中得知，當我們創建一個空的list，並且第一次給list中添加元素的時候：
- 創建一個長度為
DEFAULT_CAPACITY = 10的數組 - 將
elementData中的值copy到新數組中（當然，這時的elementData為空） - 將初始化好的新數組賦值給
elementData
3.2 如何擴容
當我們了解了arrayList第一次添加元素的邏輯后，我們也基本明白了動態擴容的原理，其實就是創建一個新的數組覆蓋之前的數組，如圖：
但是有兩個問題：
- 何時擴容？
- 擴多大？
我們帶着疑問再去看下源碼：
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// 當 elementData 沒有空閑的位置時，才去擴容
// 即：第一次擴容是發生在 添加第11位元素時 11 - 初始長度10 > 0
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
private void grow(int minCapacity) {
int oldCapacity = elementData.length; // 10
// newCapacity = 10 + 10 / 2。
int newCapacity = oldCapacity + (oldCapacity >> 1); // 15
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);
}
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
// 最大值：2的31次方
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
看到這里，心中的疑惑就解開了：
- 當ArrayList內部的elementData[]沒有空閑位置時，才進行擴容。
- 每次將之前的size擴容1.5倍。
4. 插入元素
我們在前面了解了arrayList是如何添加元素的，都是給尾部追加元素，但是如果給指定位置添加元素是如何實現的呢？
我們先通過源碼分析一下：
public void add(int index, E element) {
// 檢查插入位置是否合法
rangeCheckForAdd(index);
// 確保內部數組容量（上面有講，不再贅述）
ensureCapacityInternal(size + 1);
// copy數組值 實現了index位置后的元素后移
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));
}
是不是看完源碼后對System.arraycopy()還是有點懵。我們在着重看下這個方法
/**
* @param src the source array. 源數組
* @param srcPos starting position in the source array. 在源數組中，開始復制的位置
* @param dest the destination array. 目標數組
* @param destPos starting position in the destination data. 在目標數組中，開始賦值的位置
* @param length the number of array elements to be copied. 被復制的數組元素的數量
*/
public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length);
我這里寫了個list插入和數組執行過程的demo方便大家加深理解：
圖解如下：
5. 移除元素
remove()方法也有兩個版本，一個是remove(int index)刪除指定位置的元素，另一個是remove(Object o)刪除第一個滿足o.equals(elementData[index])的元素。刪除操作是add()操作的逆過程，需要將刪除點之后的元素向前移動一個位置。需要注意的是為了讓GC起作用，必須顯式的為最后一個位置賦null值。
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;
}
參考：