JDK源碼學習筆記——ArrayList
JDK版本：13html
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) {
// 指定容量大於0 建立對應的Object數組
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
// 等於0 使用 EMPTY_ELEMENTDATA
} else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;
// 小於0 拋出異常
} else {
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
複製代碼
儘可能預估數組大小，使用該方法建立ArrayList，合理使用內存，避免數組擴容耗費性能。java
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, elementData, 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,
elementData, index + numNew,
numMoved);
// 將新數組加入elementData指定的位置
System.arraycopy(a, 0, elementData, index, 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, 0, size);
}
複製代碼
boolean batchRemove(Collection<?> c, boolean complement, final int from, final int end) 批量移除或保留元素
這個方法有點繞。先來看參數 complement，它表示若是一個元素在集合c中，他是保留仍是刪除。結合另外一個方法 public boolean retainAll(Collection<?> c) { return batchRemove(c, true, 0, 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, es, w, end - r);
w += end - r;
// 把異常繼續拋出去
throw ex;
} finally {
// 增長修改次數
modCount += end - w;
// 尾部無用元素賦值爲null
shiftTailOverGap(es, w, 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, es, 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)
略...app
4.6 查找單個元素
int indexOf(Object o) 查找第一個指定元素的索引
public int indexOf(Object o) {
return indexOfRange(o, 0, 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, 0, size);
}
int lastIndexOfRange(Object o, int start, 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, size, a.getClass());
// 把 elementData 的數據複製到 a 中
System.arraycopy(elementData, 0, a, 0, size);
// 若是 a 的長度 大於 size ，就。。把 size 位置設置爲 null ？？？
if (a.length > size)
a[size] = null;
return a;
}
複製代碼
對中間a[size] = null的疑惑做者在方法註釋中有寫到：dom
* <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值做爲一個標記..或許調用者能夠在遍歷數組時判斷元素爲空就再也不遍歷了？？post
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, 0, 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()排序）。ui
相關文章
- 1. 從JDK源碼學習Arraylist
- 2. Jdk源碼學習之：ArrayList
- 3. jdk源碼閱讀筆記-ArrayList
- 4. ArrayList學習(源碼解讀筆記)
- 5. ArrayList源碼學習筆記（3）
- 6. jdk源碼-arraylist
- 7. JDK源碼學習筆記——HashMap
- 8. jdk源碼學習筆記--LinkedList
- 9. JDK Logging源碼學習筆記
- 10. JDK源碼學習筆記——Integer
- 更多相關文章...
- • 您已經學習了 XML Schema，下一步學習什麼呢？ - XML Schema 教程
- • 我們已經學習了 SQL，下一步學習什麼呢？ - SQL 教程
- • Tomcat學習筆記（史上最全tomcat學習筆記）
- • 適用於PHP初學者的學習線路和建議
相關標籤/搜索
每日一句
-
每一个你不满意的现在，都有一个你没有努力的曾经。
歡迎關注本站公眾號,獲取更多信息
