Arraylist原始碼--之那些年的面試題
阿新 • • 發佈：2018-11-16
基於jdk1.8版本
一、本節目錄：
- ArrayList的繼承體系
- Arraylist的重要的屬性
- ArrayList的建構函式
- ArrayList的擴容
- ArrayList的核心方法
- ArrayList的fast fail機制延伸至fast safe
二、繼承體系圖
三、重要屬性：
- modCount
這個引數我們單獨講，與後面講到的fast fail有關聯，同時也與一個著名的以後ConcurrentModificationException有關。 - 預設初始容量值：
private - 盛裝元素的容器：
transient Object[] elementData; // transient 表名當前物件不參與序列化
上面所說的size即便是elementData的size- 初始化容器：
// 如果使用 0 作為初始化容量的時候，ArrayList就會使用這個物件來初始化
private static final Object[] EMPTY_ELEMENTDATA = {};
// 如果使用預設的建構函式的話，就會使用這個物件初始化
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};四、建構函式：
- 預設構造
// 直接使用DEFAULTCAPACITY_EMPTY_ELEMENTDATA來初始化
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
} - 使用指定大小容量的構造
// 當initialCapacity 為0的時候，則會使用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) {
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 {
this.elementData = EMPTY_ELEMENTDATA;
}
}五、擴容機制：
5.1 如果自己來寫這個擴容的思路
我們先自己分析一下思路（本來想畫一個流程圖的，但是後來發現不好命名，所以這個只好自己描述一下），首先只有在往容器裡面新增資料的時候才會有擴容這一說，首先由於我們初始化的方法不同，所以在初次新增元素的時候需要做特別的處理，然後判斷是否超過最大容量，判斷在現有的size+1的基礎上是否需要擴容，然後擴容，拷貝陣列新增元素。
5.2 ArrayList的思路
private void ensureCapacityInternal(int minCapacity) {
/** 如果使用預設的構造引數的話，則選擇minCapacity和DEFAULT_CAPACITY中較大的一個來作為最小的初始容量，
大家可能奇怪，既然判斷了初始化這一說，為何還會有傳入的minCapacity
和DEFAULT_CAPACITY比較這一說，是因為ensureCapacityInternal也會被addAll呼叫
*/
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
// 下面這個完全是基於 **溢位來考慮的**
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}核心的擴容程式碼：
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
int newCapacity = oldCapacity + (oldCapacity >> 1);
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);
}上面的兩面不難，大家應該能看懂，不過上面確實有兩個考點：
- 擴容後的新容量：為原來容量的1.5倍
- x>>y 和 x<
六、核心方法：
- 新增： 從原始碼看ArrayList是可以新增null的同時是可以新增重複元素的
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}- 判斷空和容量，都是基於size這個成員屬性來進行判斷的
public int size() {
return size;
}
public boolean isEmpty() {
return size == 0;
}- indexOf：是返回首個和指定元素相等的索引
public int indexOf(Object o) {
if (o == null) {
for (int i = 0; i < size; i++)
if (elementData[i]==null)
return i;
} else {
for (int i = 0; i < size; i++)
if (o.equals(elementData[i]))
return i;
}
return -1;
}- remove：大家知道陣列的一大優勢是查詢索引快，但是缺點就是對於元素的刪減操作效率比較低，所以與之互補的一個數據結構為連結串列，在java中對應的則是LinkedList
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;
}圖示如下：
還有很多方法，這裡不再一一介紹，因為其他的方法比較常規，所以直接看api文件即可，下面重點來介紹一下一個異常和fast fail的故事。
七：fast fail 與ConcurrentModificationException
先看異常：ConcurrentModificationException
modCount：list每進行一次cud操作，modCount就會+1，而在進行遍歷的時候則會把這個值複製給expectedModCount ，在遍歷的過程中一但這兩個值不相等則說明了在遍歷的過程中，有另外的執行緒對list做了修改（新增、刪除、修改）這樣出現數據不一致的情況是不允許的，所以丟擲ConcurrentModificationException
那如果我不使用Iterator遍歷是不是就不會出現這個情況呢，是的如果我們使用for迴圈就不會出現這個事情，但是也有一點小技巧需要注意，如果我們在for迴圈中遍歷的同時刪除資料，arraylist的size就會發生改變
for(int i = 0 ; i<list.size();i++) // 不會出現問題
int size = list.size();
for(int i = 0 ; i<size ;i++) // 這種則會報空指標異常// 這個是ArrayList的一個內部類，用來快速的遍歷list的
private class Itr implements Iterator<E> {
int cursor; // index of next element to return
int lastRet = -1; // index of last element returned; -1 if no such
int expectedModCount = modCount;
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}現在我們基本上了解了ConcurrentModificationException，下面聊聊fast fail機制：其實ConcurrentModificationException是fast fail的一種響應，當Collection在遍歷的過程中發現了修改就可能產生fast-fail，fast fail 機制並不保證在不同步程式碼的情況下一定會丟擲異常，只是進最大努力丟擲。注意這個機制對大多數的Collection都是有效的
- 出現的場景：
- 在單執行緒中：遍歷的過程中進行修改（使用Iterator遍歷）
- 多執行緒中：一個執行緒修改另外一個執行緒的遍歷的 Collection
解決的方法：
- 對物件加鎖
- 使用java.util.concurrent包中的類來代替ArrayList和Hashmap來達到
fast safe 和fast fail則是相對應的，可能這個地方我並沒有介紹的太清楚，這個點在面試的過程中可能會被問到，做一瞭解即可，詳細的介紹可以看一下這一篇博文https://www.cnblogs.com/shamo89/p/6685216.html