JDK原始碼學習筆記——ArrayList
阿新 • • 發佈：2019-12-31
JDK版本：13
1 類圖
1.1 實現介面
-
java.util.List：提供增刪改查等基本操作 -
java.io.Serializable：標記介面，表示支援序列化 -
java.lang.Cloneable：標記介面，表示支援克隆 -
java.util.RandomAccess：這個介面可能很少注意到，其實也是一個標記介面，表示能夠隨機訪問元素，簡單來說就是底層是陣列實現的集合。參考：RandomAccess 這個空架子有何用？
1.2 繼承
-
java.util.AbstractList：抽象類，從註釋中可以看到，它提供了List介面的基本實現，以最大程度地減少迭代遍歷相關操作的實現。不過ArrayList基本都重寫了AbstractList提供的實現。
2 屬性
-
int elementData：儲存元素的陣列，ArrayList的真實大小 -
int size：elementData中實際存放元素的數量，我們經常呼叫的size()方法返回的也就是它
3 構造方法
3.1 ArrayList(int initialCapacity)
/**
* 空陣列，當初始化容量為0時，將elementData指向它
*/
private static final Object[] EMPTY_ELEMENTDATA = {};
public ArrayList(int initialCapacity) 儘量預估陣列大小，使用該方法建立ArrayList，合理使用記憶體，避免陣列擴容耗費效能。
3.2 ArrayList()
/**
* Default initial capacity.
* 預設初始化容量
*/
private static final int DEFAULT_CAPACITY = 10;
/**
* 使用預設容量時的空陣列。當使用無參構造時，為了節省記憶體（考慮到建立了ArrayList物件但沒使用的情況）
* 做了優化，在首次新增元素時，才將elementData初始化成長度為10的陣列。
* 與EMPTY_ELEMENTDATA區分開，以便在初始化時知道是直接初始化成10。
* 而EMPTY_ELEMENTDATA從0開始按照1.5倍擴容。
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/**
* 使用預設容量10建立ArrayList
*/
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
複製程式碼3.3 ArrayList(Collection<? extends E> c)
/**
* 傳入一個集合來建立ArrayList
*/
public ArrayList(Collection<? extends E> c) {
// 將集合轉為Object陣列
elementData = c.toArray();
// 如果陣列長度不等於0
if ((size = elementData.length) != 0) {
// defend against c.toArray (incorrectly) not returning Object[]
// (see e.g. https://bugs.openjdk.java.net/browse/JDK-6260652)
// 如果elementData不是Object陣列型別，就建立個新的Object型別陣列，
// 並將elementData中的元素賦值進去，最終再把新陣列賦值給elementData
// 是為了修復JDK-626065的BUG，c.toArray不返回Ojbect[]型別陣列
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData,size,Object[].class);
// 如果陣列大小等於0，使用EMPTY_ELEMENTDATA
} else {
this.elementData = EMPTY_ELEMENTDATA;
}
// ？？為什麼一會用this.elementData，一會又不加this.了
}
複製程式碼4 主要方法
4.1 新增一個元素
boolean add(E e) 新增到尾部
/**
* 將一個元素新增到末尾
*/
public boolean add(E e) {
// 定義於父類AbstractList中，用於記錄陣列被修改的次數，+1
modCount++;
add(e,elementData,size);
return true;
}
private void add(E e,Object[] elementData,int s) {
// 如果容量不足，進行擴容
if (s == elementData.length)
elementData = grow();
// 元素放到陣列末尾
elementData[s] = e;
// size +1
size = s + 1;
}
複製程式碼
void add(int index,E element) 新增到指定位置
/**
* 在指定位置插入一個元素
*/
public void add(int index,E element) {
// 檢查index是否在陣列範圍內
rangeCheckForAdd(index);
// 修改次數 +1
modCount++;
final int s;
Object[] elementData;
// 如果容量不夠，進行擴容
if ((s = size) == (elementData = this.elementData).length)
elementData = grow();
// 將index位置及之後的元素向後挪一位
// 陣列複製
System.arraycopy(elementData,// 原陣列
index,// 從原陣列的開始位置
elementData,// 目標陣列
index + 1,// 在目標陣列的開始位置
s - index); // 複製元素的個數
// 將插入元素放在index的位置
elementData[index] = element;
// size + 1
size = s + 1;
}
複製程式碼4.2 擴容
Object[] grow()
private Object[] grow() {
// 擴容後容量至少比以前大1
return grow(size + 1);
}
/**
* @param minCapacity 所需最小擴容後容量
*/
private Object[] grow(int minCapacity) {
// 記錄老的容量
int oldCapacity = elementData.length;
// 如果容量 > 0 或 陣列不是DEFAULTCAPACITY_EMPTY_ELEMENTDATA，計算新的容量大小並擴容
if (oldCapacity > 0 || elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
int newCapacity = ArraysSupport.newLength(oldCapacity,minCapacity - oldCapacity,/* minimum growth 最小擴大量*/
oldCapacity >> 1 /* preferred growth 首選擴大量*/);
// 把元素拷貝到新陣列中
return elementData = Arrays.copyOf(elementData,newCapacity);
/*
ArraysSupport.newLength 計算新陣列大小，取 minimum growth 和
preferred growth 的更大值加上舊的容量。
還涉及到一些陣列最大長度的校驗和處理，這裡不細說。
>> 是移位運運算元，右移一位相當於除以二，也就是說這裡是擴大到1.5倍
如果是從0擴容，0 >> 1 還是0，此時使用minCapacity，也就是1
*/
// 如果是 DEFAULTCAPACITY_EMPTY_ELEMENTDATA，建立新陣列
} else {
// 容量取 預設容量 和 minCapacity 中的更大值
return elementData = new Object[Math.max(DEFAULT_CAPACITY,minCapacity)];
}
}
複製程式碼4.3 新增多個元素
boolean addAll(Collection<? extends E> c) 向末尾新增
/**
* 向末尾新增多個元素
* 呼叫此方法相比一個一個新增元素，可以避免陣列多次擴容
*/
public boolean addAll(Collection<? extends E> c) {
// 轉換成陣列
Object[] a = c.toArray();
// 修改次數+1
modCount++;
// 新加入元素個數
int numNew = a.length;
// 如果個數為0，返回false，ArrayList陣列無變化，但修改次數是增加了的
if (numNew == 0)
return false;
Object[] elementData;
final int s;
// 如果新加入元素不夠放了，則進行擴容，要求擴容後至少能放得下新加入的資料
if (numNew > (elementData = this.elementData).length - (s = size))
elementData = grow(s + numNew);
// 將新陣列複製進elementData的末尾
System.arraycopy(a,0,s,numNew);
// 計算size大小
size = s + numNew;
return true;
}
複製程式碼
boolean addAll(int index,Collection<? extends E> c) 向指定位置新增
public boolean addAll(int index,Collection<? extends E> c) {
// 檢查是否越界
rangeCheckForAdd(index);
Object[] a = c.toArray();
modCount++;
int numNew = a.length;
if (numNew == 0)
return false;
Object[] elementData;
final int s;
// 擴容，至少裝得下新陣列
if (numNew > (elementData = this.elementData).length - (s = size))
elementData = grow(s + numNew);
int numMoved = s - index;
// 如果index位置已有元素，則將它開始及之後的元素向後移出位置來
if (numMoved > 0)
System.arraycopy(elementData,index,index + numNew,numMoved);
// 將新陣列加入elementData指定的位置
System.arraycopy(a,numNew);
size = s + numNew;
return true;
}
複製程式碼4.4 移除單個元素
E remove(int index) 移除指定位置的元素，並返回該元素
public E remove(int index) {
// 校驗 index不能 > size
Objects.checkIndex(index,size);
final Object[] es = elementData;
// 記錄被刪除的值
@SuppressWarnings("unchecked") E oldValue = (E) es[index];
fastRemove(es,index);
// 返回被刪除的值
return oldValue;
}
/**
* 負責刪除的核心邏輯，不關心返回被刪除元素或越界校驗等操作
*/
private void fastRemove(Object[] es,int i) {
// 修改次數+1
modCount++;
final int newSize;
// size是比下標大 1 的，size-1 和 i 比較，其實是在判斷i是不是陣列最後一位
// 如果不是最後一位，要把i後邊的所有元素向前挪一位。
if ((newSize = size - 1) > i) // 注意這裡藏著 size - 1 的操作
System.arraycopy(es,i + 1,es,i,newSize - i);
// 將最後一位置空，幫助 GC
es[size = newSize] = null;
}
複製程式碼
boolean remove(Object o) 移除首個為o的元素，返回是否移除
public boolean remove(Object o) {
final Object[] es = elementData;
final int size = this.size;
// 用於標記找到的第一個 o 的位置
int i = 0;
found: { // 利用break終止程式碼塊執行，使程式碼更簡潔
// 如果 o 是 null
if (o == null) {
for (; i < size; i++)
if (es[i] == null)
break found;
// 如果 o 不是 null
} else {
for (; i < size; i++)
if (o.equals(es[i]))
break found;
}
return false;
}
// 移除
fastRemove(es,i);
return true;
}
複製程式碼4.5 移除多個元素
boolean removeAll(Collection<?> c) 如果元素在集合 c 中就移除
/**
* 刪除多個元素
*/
public boolean removeAll(Collection<?> c) {
// 呼叫了批量刪除方法
return batchRemove(c,false,size);
}
複製程式碼
boolean batchRemove(Collection<?> c,boolean complement,final int from,final int end) 批量移除或保留元素
這個方法有點繞。先來看引數 complement，它表示如果一個元素在集合c中，他是保留還是刪除。結合另一個方法
public boolean retainAll(Collection<?> c) { return batchRemove(c,true,size); }
就很容易理解了，當complement為false時，是移除的邏輯。而為true時，是求兩個集合的交集。
這個方法的大致邏輯是：（以移除為例）先找到第一個要移除的元素索引，記為w，它的下一位記為r。然後從r的位置開始遍歷，如果是要刪除的元素就跳過，如果是要保留的元素，就將它寫到w指向的位置，覆蓋之前的元素，再把w挪向下一位，繼續遍歷判斷。最後再把陣列末尾無用的元素置為null。下文程式碼後我貼了一張手繪圖，可以結合起來理解。或者debug除錯幾次。
/**
* 批量刪除或保留多個元素
* @param c 要刪除的元素集合
* @param complement 如果一個元素再 c 中，是刪除還是保留
* @param from 開始位置
* @param end 結束位置
* @return
*/
boolean batchRemove(Collection<?> c,boolean complement,final int from,final int end) {
// 校驗 c 不是 null
Objects.requireNonNull(c);
final Object[] es = elementData;
int r;
// Optimize for initial run of survivor 優化
// 想在刪除邏輯前線判斷elementData中到底有沒有 c 中的元素，但有不想重複遍歷
// 這裡做的是 找到第一個不符合 complement 的元素的位置 r ，然後結束遍歷
for (r = from;; r++) {
if (r == end)
return false;
if (c.contains(es[r]) != complement)
break;
}
// w 標記 r 的位置，r + 1 指向下一個位置
int w = r++; // 注意，這裡等價於 w = r; r = r + 1; (i++ 和 ++i 的區別）
try {
for (Object e; r < end; r++)
// 如果 r 位置的元素符合 complement ，將 r 位置的元素寫入 w 位置的元素，w 向後挪一位
// 如果不符合，w 不動，進行下次迴圈
if (c.contains(e = es[r]) == complement)
es[w++] = e;
} catch (Throwable ex) {
// Preserve behavioral compatibility with AbstractCollection,
// even if c.contains() throws.
// 如果 cntains()方法丟擲異常，則將 r 位置後的資料寫到 w 位置後
// 這樣我們剩餘沒有遍歷的元素挪過去之後覆蓋了跳過的元素，保證陣列中不會多出來一些奇怪的元素
System.arraycopy(es,r,w,end - r);
w += end - r;
// 把異常繼續丟擲去
throw ex;
} finally {
// 增加修改次數
modCount += end - w;
// 尾部無用元素賦值為null
shiftTailOverGap(es,end);
}
return true;
}
/**
* 在陣列 hi 和 lo 的位置各剪一刀，丟掉 hi 和 lo 中間的部分，然後把 hi 這一頭和
* lo 那一頭連起來
*
* @param es 陣列
* @param lo 開始位置
* @param hi 結束位置
*/
private void shiftTailOverGap(Object[] es,int lo,int hi) {
// 從 hi 位置開始的元素移動到 lo 位置後
System.arraycopy(es,hi,lo,size - hi);
// 將末尾沒用的位置置空
for (int to = size,i = (size -= hi - lo); i < to; i++)
es[i] = null;
}
複製程式碼
批量移除給定範圍內的多個元素 void removeRange(int fromIndex,int toIndex)
/**
* 批量移除 [fromIndex,toIndex) （前閉後開）範圍內的多個元素
*/
protected void removeRange(int fromIndex,int toIndex) {
// 引數不正確
if (fromIndex > toIndex) {
throw new IndexOutOfBoundsException(
outOfBoundsMsg(fromIndex,toIndex));
}
// 修改次數+1
modCount++;
// 該方法見上文
shiftTailOverGap(elementData,fromIndex,toIndex);
}
複製程式碼根據條件移除元素 boolean removeIf(Predicate<? super E> filter)
略...
4.6 查詢單個元素
int indexOf(Object o) 查詢第一個指定元素的索引
public int indexOf(Object o) {
return indexOfRange(o,size);
}
int indexOfRange(Object o,int start,int end) {
Object[] es = elementData;
// o 為null的情況
if (o == null) {
for (int i = start; i < end; i++) {
if (es[i] == null) {
return i;
}
}
// o 不為null的情況
} else {
for (int i = start; i < end; i++) {
if (o.equals(es[i])) {
return i;
}
}
}
// 沒找到返回 -1
return -1;
}
複製程式碼
int indexOf(Object o) 查詢最後一個指定元素的索引
public int lastIndexOf(Object o) {
return lastIndexOfRange(o,size);
}
int lastIndexOfRange(Object o,int end) {
Object[] es = elementData;
if (o == null) {
for (int i = end - 1; i >= start; i--) { // 倒序
if (es[i] == null) {
return i;
}
}
} else {
for (int i = end - 1; i >= start; i--) {
if (o.equals(es[i])) {
return i;
}
}
}
return -1;
}
複製程式碼
int indexOf(Object o) 獲得指定位置的元素
public E get(int index) {
// 校驗
Objects.checkIndex(index,size);
return elementData(index);
}
E elementData(int index) {
return (E) elementData[index];
}
複製程式碼4.7 設定指定位置的元素
E set(int index,E element)
public E set(int index,E element) {
// 校驗
Objects.checkIndex(index,size);
// 記錄舊值
E oldValue = elementData(index);
// 賦值新值
elementData[index] = element;
// 返回舊值
return oldValue;
}
複製程式碼5 其他方法
5.1 轉換為陣列
Object[] toArray() 轉換為Object[]
// ArrayList.java
public Object[] toArray() {
return Arrays.copyOf(elementData,size);
}
// Arrays.java
public static <T> T[] copyOf(T[] original,int newLength) {
return (T[]) copyOf(original,newLength,original.getClass());
}
複製程式碼
Object[] toArray() 轉換為給定泛型的陣列
public <T> T[] toArray(T[] a) {
// 如果傳入的陣列大小沒有 size 大
if (a.length < size)
// Make a new array of a's runtime type,but my contents:
// 直接複製一個新陣列返回
return (T[]) Arrays.copyOf(elementData,a.getClass());
// 把 elementData 的資料複製到 a 中
System.arraycopy(elementData,a,size);
// 如果 a 的長度 大於 size ，就。。把 size 位置設定為 null ？？？
if (a.length > size)
a[size] = null;
return a;
}
複製程式碼對中間a[size] = null的疑惑作者在方法註釋中有寫到：
* <p>If the list fits in the specified array with room to spare
* (i.e.,the array has more elements than the list),the element in
* the array immediately following the end of the collection is set to
* {@code null}. (This is useful in determining the length of the
* list <i>only</i> if the caller knows that the list does not contain
* any null elements.)
複製程式碼如果呼叫者明確知道陣列中沒有空元素，那麼這對於確定list的length很有幫助。emmm...插入null值作為一個標記..或許呼叫者可以在遍歷陣列時判斷元素為空就不再遍歷了？？
5.2 求雜湊值
int hashCode()
public int hashCode() {
// 記錄開始前陣列修改次數
int expectedModCount = modCount;
// 獲取雜湊值
int hash = hashCodeRange(0,size);
// 併發修改校驗
checkForComodification(expectedModCount);
return hash;
}
int hashCodeRange(int from,int to) {
final Object[] es = elementData;
// 校驗
if (to > es.length) {
throw new ConcurrentModificationException();
}
// 計算hash值
int hashCode = 1;
for (int i = from; i < to; i++) {
Object e = es[i];
// 為什麼要乘31，看下文參考資料
hashCode = 31 * hashCode + (e == null ? 0 : e.hashCode());
}
return hashCode;
}
/**
* 併發修改校驗，如果操作前陣列的修改次數和操作後的修改次數不一致，
* 則丟擲異常
*/
private void checkForComodification(final int expectedModCount) {
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
}
複製程式碼參考資料：田小波的技術部落格——科普：String hashCode 方法為什麼選擇數字31作為乘子
5.3 判斷相等
boolean equals(Object o)
public boolean equals(Object o) {
// 與自己本身相比，直接返回 true
if (o == this) {
return true;
}
// 非 List 型別，直接返回 false
if (!(o instanceof List)) {
return false;
}
// 記錄當前陣列修改次數
final int expectedModCount = modCount;
// ArrayList can be subclassed and given arbitrary behavior,but we can
// still deal with the common case where o is ArrayList precisely
// 根據型別是否是ArrayList，選擇不同的比較方式
// ArrayList可以遍歷陣列，效能更優，而其他List只能用迭代器。
boolean equal = (o.getClass() == ArrayList.class)
? equalsArrayList((ArrayList<?>) o)
: equalsRange((List<?>) o,size);
// 併發修改校驗
checkForComodification(expectedModCount);
return equal;
}
private boolean equalsArrayList(ArrayList<?> other) {
// 記錄傳入list的修改次數
final int otherModCount = other.modCount;
final int s = size;
boolean equal;
// 先判斷 size 是否相等
if (equal = (s == other.size)) {
final Object[] otherEs = other.elementData;
final Object[] es = elementData;
// 校驗併發修改
if (s > es.length || s > otherEs.length) {
throw new ConcurrentModificationException();
}
// 遍歷，比較每個對應元素是否相等
for (int i = 0; i < s; i++) {
if (!Objects.equals(es[i],otherEs[i])) {
equal = false; // 如果不相等跳出迴圈
break;
}
}
}
// 校驗傳入list的併發修改
other.checkForComodification(otherModCount);
return equal;
}
boolean equalsRange(List<?> other,int from,int to) {
final Object[] es = elementData;
// 併發修改校驗
if (to > es.length) {
throw new ConcurrentModificationException();
}
// 用迭代器遍歷逐個對比
var oit = other.iterator();
for (; from < to; from++) {
// 如果oit沒有下一個元素或當前元素不相等，直接返回 false
if (!oit.hasNext() || !Objects.equals(es[from],oit.next())) {
return false;
}
}
// 返回oit是否還有剩餘的元素。如果還有當然是不相等的
return !oit.hasNext();
}
複製程式碼5.4 克隆
Object clone()
public Object clone() {
try {
// 呼叫父類克隆方法
ArrayList<?> v = (ArrayList<?>) super.clone();
// 拷貝新陣列
v.elementData = Arrays.copyOf(elementData,size);
// 修改次數置為 0
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
// this shouldn't happen,since we are Cloneable
// 實現Cloneable介面後不會再發生了
throw new InternalError(e); // JVM 意外內部錯誤
}
}
複製程式碼5.5 清空
void clear()
public void clear() {
// 修改次數 + 1
modCount++;
// 遍歷置空 倒序
final Object[] es = elementData;
for (int to = size,i = size = 0; i < to; i++)
es[i] = null;
}
複製程式碼5.6 序列化與反序列化
void writeObject(java.io.ObjectOutputStream s) 序列化
@java.io.Serial
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
int expectedModCount = modCount;
// 序列化 非靜態，非 transient 屬性
s.defaultWriteObject();
// 寫入 size ，為了相容 clone() 方法 ？？？
s.writeInt(size);
// Write out all elements in the proper order.
// 逐個寫入元素
for (int i=0; i<size; i++) {
s.writeObject(elementData[i]);
}
// 併發修改校驗
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
}
複製程式碼elementData是加了transient關鍵字的，序列化時會只序列化size大小的真實使用的陣列，不會序列化elementData預留出的那一部分。節省時間和空間。
void readObject(java.io.ObjectOutputStream s)
@java.io.Serial
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException,ClassNotFoundException {
// 反序列化 非靜態，非 transient 屬性
s.defaultReadObject();
// Read in capacity
// 讀取 size ，但忽略不用了
s.readInt(); // ignored
if (size > 0) {
// like clone(),allocate array based upon size not capacity
// emmm....
SharedSecrets.getJavaObjectInputStreamAccess().checkArray(s,Object[].class,size);
Object[] elements = new Object[size];
// 逐個讀取元素
for (int i = 0; i < size; i++) {
elements[i] = s.readObject();
}
elementData = elements;
} else if (size == 0) {
// size 是 0 的話使用空陣列
elementData = EMPTY_ELEMENTDATA;
} else {
throw new java.io.InvalidObjectException("Invalid size: " + size);
}
}
複製程式碼6 End
省略了一些不常用的或簡單的方法，以及邏輯重點不在ArrayList中的方法（比如sort()排序）。