三峽集團長江干流第 100 臺機組，白鶴灘水電站 4 號機組正式併網發電
阿新 • • 發佈：2021-11-20
ArrayList原始碼分析
以下程式碼都是基於java8的版本
ArrayList簡介
原始碼：
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
//......
}
ArrayList與Collection的關係如下圖，實現代表繼承，虛線代表實現介面：
- ArrayList是一個陣列佇列，相當於動態陣列。與Java中的陣列相比，它的容量能動態增長。它繼承於AbstractList，實現了List，RandomAccess，Cloneable，java.io.Serializable這些介面。
- ArrayList繼承了AbstractList，實現了List。它是一個數組佇列，提供了相關的新增、刪除、修改、遍歷等功能。
- ArrayList實現了RandmoAccess介面，即提供了隨機訪問的功能。RandmoAccess是java中用來被List實現，為List提供快速訪問功能的。在ArrayList中，我們即可以通過元素的序號快速獲取元素物件；這就是快速隨機訪問。
- ArrayList實現了Cloneable介面，即覆蓋了函式clone()，能被克隆。
- ArrayList實現了java.io.Serializable介面，這意味著ArrayList支援序列化，能通過序列化去傳輸。
注意：ArrayList中的操作不是執行緒安全的！所以，建議在單執行緒中使用，多執行緒情況下可以選擇
CopyOnWriteArrayList或者使用Collections.synchronizedList方法將其包裝成一個執行緒安全的List。
ArrayList的API
// Collection中定義的API boolean add(E object) boolean addAll(Collection<? extends E> collection) void clear() boolean contains(Object object) boolean containsAll(Collection<?> collection) boolean equals(Object object) int hashCode() boolean isEmpty() Iterator<E> iterator() boolean remove(Object object) boolean removeAll(Collection<?> collection) boolean retainAll(Collection<?> collection) int size() <T> T[] toArray(T[] array) Object[] toArray() // AbstractCollection中定義的API void add(int location, E object) boolean addAll(int location, Collection<? extends E> collection) E get(int location) int indexOf(Object object) int lastIndexOf(Object object) ListIterator<E> listIterator(int location) ListIterator<E> listIterator() E remove(int location) E set(int location, E object) List<E> subList(int start, int end) // ArrayList新增的API Object clone() void ensureCapacity(int minimumCapacity) void trimToSize() void removeRange(int fromIndex, int toIndex)
ArrayList的屬性
ArrayList的主要屬性如下程式碼所示:
//序列化id
private static final long serialVersionUID = 8683452581122892189L;
//容器預設初始化大小
private static final int DEFAULT_CAPACITY = 10;
//一個空物件
private static final Object[] EMPTY_ELEMENTDATA = {};
//一個空物件，如果使用預設建構函式建立ArrayList，則預設物件內容是該值
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
//ArrayList存放物件的容器，後面的新增、刪除等操作都是基於該屬性來進行操作
transient Object[] elementData;
//當前列表已使用的長度
private int size;
//陣列最大長度（2147483639），
//這裡為什麼是Integer.MAX_VALUE - 8是因為有些虛擬機器在陣列中保留了一些頭部資訊，防止記憶體溢位
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
//這個是從AbstractList繼承過來的，代表ArrayList集合修改的次數
protected transient int modCount = 0;
建構函式
無參建構函式
如果不傳入引數，則使用預設無參構造方法建立ArrayLisy物件，如下：
/**
* Constructs an empty list with an initial capacity of ten.
構造一個初始容量為 10 的空列表
*/
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
注意：此時我們建立的ArrayList物件中的elementData中的長度是0，size是0，當進行第一次add的時候，elementDate將會變成預設的長度：10。後文會講到
帶int型別的建構函式
如果傳入引數，則代表指定ArrayList的初始陣列長度；傳入引數如果是大於0，則使用使用者的引數初始化；如果引數等於0，則用內部的空物件EMPTY_ELEMENTDATA的地址直接賦值給elementData；否則丟擲異常，如下：
/**
構造一個具有指定初始容量的空列表。
引數：initialCapacity – 列表的初始容量
丟擲：IllegalArgumentException – 如果指定的初始容量為負
*/
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);
}
}
帶Collection物件的建構函式
- 將Collection物件轉換成陣列，然後將陣列的地址賦值給elementData。
- 更新size的值，如果size的值等於0直接將內部空物件EMPTY_ELEMENTDATA的地址賦值給elementData。
- 如果size的值大於0，則執行Arrays.copy方法，把Collection物件的內容copy(可以理解為深拷貝)到elementData中，並且這些元素是按照該collection的迭代器返回它們的順序排列的。
/**
按照集合的迭代器返回的順序構造一個包含指定集合元素的列表。
引數：c – 其元素將被放入此列表的集合
丟擲：NullPointerException – 如果指定的集合為空
*/
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;
}
}
System.arraycopy和Arrays.copy
這裡介紹下System.arraycopy和Arrays.copy方法，因為後分析原始碼時會經常用到。
System.arraycopy方法：它就是從指定的源陣列將元素中複製到目標陣列，複製從指定的位置開始，到設定的複製長度結束，然後從目標陣列的指定起始位置依次插入。最終會呼叫native本地方法。
// src 源陣列
// srcPos 源陣列要複製的起始位置
// dest 要賦值到的目標陣列
// destPos 目標陣列放置的起始位置
// length 複製的長度
// 使用了native關鍵字，說明呼叫的是其他語言寫的底層函式
public static native void arraycopy(Object src, int srcPos,
Object dest, int destPos,
int length);
Arrays.copy方法：它新建了一個數組並且將原陣列的內容拷貝到長度為newLength的新陣列中，並且返回該新陣列。
// original 要複製的陣列
// newLength 要返回副本的長度
// newwType 要返回的副本型別
// 內部呼叫了System.arraycopy方法
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;
}
區別：
- System.arraycopy
需要目標陣列，將原陣列拷貝到目標數組裡，而且可以選擇拷貝的起點和長度以及放入新陣列中的位置。 - Arrays.copyof是系統
自動在內部新建一個數組最為目標陣列，呼叫System.arraycopy將原陣列的內容拷貝到長度為newLength的目標陣列中，並返回新建的目標陣列。
新增元素
ArrayList提供了add(E e)、add(int index, E element)、addAll(Collection<? extends E> c)、addAll(int index, Collection<? extends E> c)、set(int index, E element)這個五個方法來實現ArrayList增加。
add(E e)
/**
將指定的元素附加到此列表的末尾。
引數：e - 要附加到此列表的元素
返回：true （由Collection.add指定）
*/
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
接下來我們看ensureCapacityInternal方法，以及它內部呼叫的方法。
/**
*這個方式是判斷當前陣列是否是個空陣列，
*如果是就返回預設長度10，否則就返回size+1;
*也就是說如果你是用無參建構函式初始化ArrayList，那麼在第一次呼叫add方法時，預設長度會變成10
*/
private void ensureCapacityInternal(int minCapacity) {
// 1.這個方式是判斷當前陣列是否是個空陣列
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
// 2.如果是就返回預設長度10
//也就是說如果用 new ArrayList<>()那麼，在第一次呼叫add方法時，預設長度會變成10
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
接下來我們看ensureExplicitCapacity方法，以及它內部呼叫的方法。
// 記錄修改次數和判斷是否需要擴容
private void ensureExplicitCapacity(int minCapacity) {
// 這個方法首先將集合修改次數加1，modCount欄位在AbstractList類裡，
modCount++;
// overflow-conscious code
//然後判斷陣列的長度是否能存入下一個元素
if (minCapacity - elementData.length > 0)
// 如果長度不夠會呼叫grow方法進行擴容
grow(minCapacity);
}
接下來我們看grow方法，以及它內部呼叫的方法。
//這個方法首先定義陣列新的長度為原來陣列長度的1.5倍，
//如果新長度減去所需陣列的最小長度小於0，那麼新長度就等於所需陣列最小長度；
//再下面的判斷是如果新長度大於MAX_ARRAY_SIZE(ArrayList內部定義MAX_ARRAY_SIZE的值是：2147483639)就呼叫
//hugeCapacity方法，最後呼叫Arrays.copyOf將擴容後的新陣列地址賦值給elementData
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
//這個方法首先定義陣列新的長度為原來陣列長度的1.5倍，
int newCapacity = oldCapacity + (oldCapacity >> 1);
//如果新長度減去所需陣列的最小長度小於0，那麼新長度就等於所需陣列最小長度；
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
//再下面的判斷新的長度是否大於MAX_ARRAY_SIZE(ArrayList內部定義MAX_ARRAY_SIZE的值是：2147483639)
if (newCapacity - MAX_ARRAY_SIZE > 0)
// 呼叫hugeCapacity方法，設定新的長度
newCapacity = hugeCapacity(minCapacity);
// minCapacity is usually close to size, so this is a win:
// 最後呼叫Arrays.copyOf將擴容後的新陣列地址賦值給elementData
elementData = Arrays.copyOf(elementData, newCapacity);
}
接下來我們看hugeCapacity方法，以及它內部呼叫的方法。
// 設定新的長度
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
// 如果擴容長度超過MAX_ARRAY_SIZE，則設定長度為Integer.MAX_VALUE
// 但不是百分百成功的，這取決於虛擬機器。
//（如果我們在某些虛擬機器上可以避免OutOfMemory，我們將另外分配Integer.MAX_VALUE，
// 如果你很幸運（取決於虛擬機器），我們將成功）
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
最後總結一下add方法的邏輯：
- 確保陣列已使用長度（size）加1後可以存入下一個元素。
- 修改次數modCount標識自增1，如果當前陣列元素個數+1後大於當前陣列長度，則呼叫grow方法，擴容陣列，grow方法會將當前陣列的容量變為原來容量的1.5倍。
- 確保新加的元素有地方儲存後，則將新元素新增到位於size++的位置上。
- 返回新增成功的布林值。
add(int index, E element)
這個方法和上面的add類似，該方法可以按照元素的位置，指定新元素位置插入。
public void add(int index, E element) {
//1.判斷索引位置是否正確
rangeCheckForAdd(index);
//2.擴容檢測
ensureCapacityInternal(size + 1); // Increments modCount!!
//3.對源陣列進行復制處理（位移），從index + 1到size - index
//相當於index和後面的元素往後移動一位
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
//4.在指定的位置賦值
elementData[index] = element;
size++;
}
接下來我們看rangeCheckForAdd方法，以及它內部呼叫的方法。
// 該方法首先呼叫rangeCheckForAdd方法判斷指定的位置小於當前陣列的長度並且大於0，否則丟擲異常。
private void rangeCheckForAdd(int index) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
第二步呼叫的ensureCapacityInternal方法和上面的add方法邏輯一樣。
第三步呼叫System.arraycopy方法把指定下標以及後面的元素全部往後移一位。
最後將新的元素放到指定位置（index）上，並將size+1。
addAll(Collection<? extends E> c)
//按照指定的Collection迭代器所返回的順序，依次插入到列表尾部。
public boolean addAll(Collection<? extends E> c) {
// 將c轉換為陣列
Object[] a = c.toArray();
int numNew = a.length;
//擴容處理，大小為size + numNew
ensureCapacityInternal(size + numNew); // Increments modCount
System.arraycopy(a, 0, elementData, size, numNew);
size += numNew;
return numNew != 0;
}
該方法首先傳過來的Collection集合轉換為陣列，然後做擴容處理，接著使用System.arraycopy把轉換後的陣列複製到列表尾部。
addAll(int index, Collection<? extends E> c)
public boolean addAll(int index, Collection<? extends E> c) {
//判斷索引位置是否正確
rangeCheckForAdd(index);
// 將c轉換為陣列
Object[] a = c.toArray();
int numNew = a.length;
//擴容處理，大小為size + numNew
ensureCapacityInternal(size + numNew); // Increments modCount
//如果插入索引小於列表長度，則將當前索引等於index和大於index的元素往後移numMoved個位置
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 != 80;
}
set(int index, E element)
public E set(int index, E element) {
//判斷插入位置是否正確，如果大於列表長度會丟擲異常
rangeCheck(index);
//獲取插入位置的當前元素
E oldValue = elementData(index);
//將新的元素替換當前插入位置的元素
elementData[index] = element;
//返回插入位置老的值
return oldValue;
}
接下來我們看rangeCheck方法，以及它內部呼叫的方法。
// 判斷索引位置是否正確
private void rangeCheck(int index) {
if (index >= size)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
接下來我們看elementData方法，以及它內部呼叫的方法。
E elementData(int index) {
return (E) elementData[index];
}
刪除元素
ArrayList提供了外界remove(int index)、remove(Object o)、removeAll(Collection<?> c)、clear()四個方法進行元素的刪除。
remove(int index)
/**
移除此列表中指定位置的元素。 將任何後續元素向左移動（從它們的索引中減去一個）。
引數：index – 要刪除的元素的索引
返回：從列表中刪除的元素
丟擲：IndexOutOfBoundsException –
*/
public E remove(int index) {
//判斷刪除位置是否正確，如果大於列表長度會丟擲異常
rangeCheck(index);
//將集合修改次數加1
modCount++;
//獲取當前刪除位置上的元素
E oldValue = elementData(index);
//判斷是否刪除的是最後一個元素，
int numMoved = size - index - 1;
if (numMoved > 0)
// 將刪除位置後方的元素向左移numMoved個位置
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
//將列表最後的元素置為null，等待垃圾收集器收集
elementData[--size] = null; // clear to let GC do its work
//返回刪除位置老的值
return oldValue;
}
刪除主要流程：檢查索引是否正確，取到索引對應的數值，將陣列複製縮容，最後位置置為null，返回剛剛索引對應的數值。
remove(Object o)
/**
從此列表中刪除第一次出現的指定元素（如果存在）。 如果列表不包含該元素，則它保持不變。 更正式地，刪除具有最低索引i的元素，使得(o==null ? get(i)==null : o.equals(get(i))) （如果這樣的元素存在）。 如果此列表包含指定的元素（或等效地，如果此列表因呼叫而更改），則返回true 。
引數：o - 要從此列表中刪除的元素（如果存在）
返回：如果此列表包含指定的元素，則為tru
*/
public boolean remove(Object o) {
//因為ArrayList允許存在null，所以需要進行null判斷
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;
}
接下來我們看fastRemove方法，以及它內部呼叫的方法。
/**
該方法和remove(int index) 基本一樣，只不過該方法跳過邊界檢查並且不返回移除的值，而且是私有方法
*/
private void fastRemove(int index) {
//將集合修改次數加1
modCount++;
//判斷是否刪除的是最後一個元素，
int numMoved = size - index - 1;
if (numMoved > 0)
//如果不是將刪除位置後的元素向左移numMoved個位置
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
//將列表最後的元素置為null，等待垃圾收集器收集
elementData[--size] = null; // clear to let GC do its work
}
removeAll(Collection<?> c)
/**
從此列表中刪除包含在指定集合中的所有元素。
引數：
c – 包含要從此列表中刪除的元素的集合
返回：
如果此列表因呼叫而更改，則為true
丟擲：
ClassCastException – 如果此列表的元素的類與指定的集合不相容（可選）
NullPointerException – 如果此列表包含空元素並且指定的集合不允許空元素（可選），或者指定的集合為空
也可以看看：
Collection.contains(Object)
*/
public boolean removeAll(Collection<?> c) {
//進行判斷，如果c為null丟擲異常
Objects.requireNonNull(c);
return batchRemove(c, false);
}
// 接下來我們看batchRemove方法，以及它內部呼叫的方法。
private boolean batchRemove(Collection<?> c, boolean complement) {
final Object[] elementData = this.elementData;
int r = 0, w = 0;
boolean modified = false;
try {
//遍歷陣列，並檢查這個集合是否包含對應的值，
//移動要保留的值到陣列前面，w最後值為要保留的元素的數量,
for (; r < size; r++)
if (c.contains(elementData[r]) == complement)
elementData[w++] = elementData[r];
} finally {
// 確保異常丟擲前的部分可以完成期望的操作，而被遍歷的部分會被接到後面
//r不等於size表示可能出錯了
if (r != size) {
System.arraycopy(elementData, r,
elementData, w,
size - r);
w += size - r;
}
//如果w等於size，表示全部元素都保留了，所以也就沒有刪除操作發生，所以會返回false；反之，返回true，並更改陣列
//而w不等於size的時候，即使try塊丟擲異常，也能正確處理異常丟擲前的操作，因為w始終為要保留的前段部分的長度，陣列也不會因此亂序
if (w != size) {
// clear to let GC do its work
// 下標大於等於w的元素都是需要刪除的，因為上面try塊中將需要保留的元素都移到的陣列前段，也就是下標小於w的那些元素被保留了
for (int i = w; i < size; i++)
elementData[i] = null;
// 記錄陣列修改次數，
modCount += size - w;
// 設定陣列最新元素個數
size = w;
// 返回刪除成功
modified = true;
}
}
return modified;
}
clear()
public void clear() {
//將集合修改次數加1
modCount++;
//迴圈將列表中的所有元素置為null，等待垃圾收集器收集
// clear to let GC do its work
for (int i = 0; i < size; i++)
elementData[i] = null;
//將列表長度設為0
size = 0;
}
查詢元素
ArrayList提供了get(int index)用讀取ArrayList中的元素。由於ArrayList是動態陣列，所以我們完全可以根據下標來獲取ArrayList中的元素，而且速度還比較快。
public E get(int index) {
//判斷刪除位置是否正確，如果大於列表長度會丟擲異常
rangeCheck(index);
//直接返回列表中下標等於index的元素
return elementData(index);
}
判斷元素是否存在列表中
ArrayList提供了contains(Object o)用於判斷元素是否存在於列表中。
注意：contains方法會遍歷ArrayList。
public boolean contains(Object o) {
//呼叫indexOf方法判斷需要查詢的元素在列表中的下標是否大於等於0，小於0則不存在
return indexOf(o) >= 0;
}
// 查詢元素下標，和remove(Object o) 類似
public int indexOf(Object o) {
//因為ArrayList允許存在null，所以需要進行null判斷
if (o == null) {
//遍歷列表，如果列表存在null值的元素，直接返回其下標位置
for (int i = 0; i < size; i++)
if (elementData[i]==null)
return i;
} else {
//遍歷列表，使用equals判斷是否有相等的元素，有的話直接返回其下標位置
for (int i = 0; i < size; i++)
if (o.equals(elementData[i]))
return i;
}
//列表中不能存在傳進來的元素，返回-1
return -1;
}
最小化ArrayList的實際儲存量
ArrayList提供了trimToSize()方法用於將底層陣列的容量調整為當前列表儲存的實際元素的大小
public void trimToSize() {
//將集合修改次數加1
modCount++;
//如果當前ArrayList的實際長度小於內部維護的陣列的長度，將內部陣列超過size後的空餘的空間（包括null值）去除，呼叫Arrays.cppyof方法拷貝elementData，長度為size
if (size < elementData.length) {
elementData = (size == 0)
? EMPTY_ELEMENTDATA
: Arrays.copyOf(elementData, size);
}
}
擷取ArrayList部分內容
ArrayList提供了subList(int fromIndex, int toIndex)方法來實現部分資料的擷取。
可以從原始碼中看到其實是建立了一個SubList的內部物件，可以理解為是返回當前ArrayList的部分檢視，其實指向的存放資料的還是一個地方。如果修改了subList返回的內容的話，原來的內容也會被修改。
因為sublist的get和set方法什麼的 都是直接改的引用。
public List<E> subList(int fromIndex, int toIndex) {
//檢查需要擷取的下標位置是否正確
subListRangeCheck(fromIndex, toIndex, size);
return new SubList(this, 0, fromIndex, toIndex);
}
static void subListRangeCheck(int fromIndex, int toIndex, int size) {
if (fromIndex < 0)
throw new IndexOutOfBoundsException("fromIndex = " + fromIndex);
if (toIndex > size)
throw new IndexOutOfBoundsException("toIndex = " + toIndex);
if (fromIndex > toIndex)
throw new IllegalArgumentException("fromIndex(" + fromIndex +
") > toIndex(" + toIndex + ")");
}
// 是ArrayList的內部類
SubList(AbstractList<E> parent,
int offset, int fromIndex, int toIndex) {
this.parent = parent;
this.parentOffset = fromIndex;
this.offset = offset + fromIndex;
this.size = toIndex - fromIndex;
this.modCount = ArrayList.this.modCount;
}
小結
ArrayList自己實現了序列化和反序列化，因為它實現了writeObject和readObject方法。
ArrayList基於陣列實現，會自動擴容。
新增元素時會自己判斷是否需要擴容，最好指定一個大概的大小，防止後面多次擴容帶來的記憶體消耗；刪除元素時不會減少容量，刪除元素時，將刪除掉的位置元素置為null，下次gc就會自動回收這些元素所佔的空間。
ArrayList是執行緒不安全的。