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倍。
參考: