Arraylist
繼承自AbstractList，實現了List，RandomAccess，Cloneable，和Serializable介面，具有List的特性，提供可隨機訪問，提供自身克隆以及序列化的一個容器類。 特點：執行緒不安全；陣列實現
主要成員變數
- 來自自身的成員變數：
// 序列化ID
private static final long serialVersionUID = 8683452581122892189L;
// 預設初始化容量
private static final int DEFAULT_CAPACITY = 10;
// 空的陣列
private static final Object[] EMPTY_ELEMENTDATA = {};
// 預設容量的空陣列
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
// 真正存放物件的陣列
transient Object[] elementData;
// 容器的大小
private int size;
複製程式碼- 來自父類和介面的成員變數：
// 操作計數
protected transient int modCount = 0;
複製程式碼這些變數都怎麼被用到？接下來看方法
方法
方法的話，分幾個模組來看吧
- 初始化 初始化的建構函式有三個
第一個，無參建構函式ArrayList()，函式直接將DEFAULTCAPACITY_EMPTY_ELEMENTDATA賦值給elementData
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
複製程式碼第二個，帶int形參的建構函式ArrayList(int initialCapacity),函式首先判斷initialCapacity是否為0，如果是0，則將EMPTY_ELEMENTDATA賦值給elementData，如果大於0，就將elementData初始化為一個容量為initialCapacity的物件陣列
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形參的建構函式ArrayList(Collection<? extends E> c)，首先呼叫Collection的toArray()方法，返回的結果賦值給elementData,這裡值得注意的是，有可能返回的結果不是Object[]（有可能是null），所以才會有 if (elementData.getClass() != Object[].class)的判斷,如果判斷成立，呼叫Arrays.copyOf()來將collection中的資料複製到elementData中。其次，如果collection中沒有資料，就將EMPTY_ELEMENTDATA賦值給elementData
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;
}
}
複製程式碼這就是全部的建構函式，有疑問，就是三個建構函式都存在賦值一個空陣列給elementData，但是為什麼無參的賦的是DEFAULTCAPACITY_EMPTY_ELEMENTDATA，剩餘兩個是EMPTY_ELEMENTDATA，帶著疑問進入下面的方法
- 新增
新增元素這個功能涉及到好幾個方法，一個一個來看，首先是最基本的Add方法，把一個元素新增到
elementData中，要做這個之前，要擴容
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
複製程式碼擴容方法，在這裡就看到了DEFAULTCAPACITY_EMPTY_ELEMENTDATA，如果EMPTY_ELEMENTDATA是由DEFAULTCAPACITY_EMPTY_ELEMENTDATA賦值而成，那麼就將擴容的數量minCapacity和DEFAULT_CAPACITY進行比較，然後取其中的最大值，最大值再傳參給ensureExplicitCapacity函式
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
複製程式碼ensureExplicitCapacity(minCapacity)方法，在這個方法中先將運算元記錄值modCount自增，然後根據minCapacity和elementData.length的大小來決定是否需要增加容量
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
複製程式碼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倍的實現
int newCapacity = oldCapacity + (oldCapacity >> 1);
複製程式碼if (newCapacity - minCapacity < 0)的判斷是因為oldCapacity有可能為0，這樣得到的newCapacity也會為0
if (newCapacity - MAX_ARRAY_SIZE > 0)的判斷確保陣列的容量不大於Integer的最大值
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}
複製程式碼最後再返回一個包含原來資料的新容量的陣列
elementData = Arrays.copyOf(elementData, newCapacity);
複製程式碼到這裡上文的DEFAULTCAPACITY_EMPTY_ELEMENTDATA和EMPTY_ELEMENTDATA的選擇問題也就明瞭清晰了
+ 呼叫無參建構函式時建立容器時，當第一次往該容器新增物件時，執行到ensureCapacityInternal,因為這個時候minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity)形參列表中的minCapacity必定是1，所以初始化出來的elementData必定是長度為10的陣列，這就是為什麼網傳預設的ArrayList的容量為10的由來
- 當呼叫剩下兩個建構函式初始化時，即便初始化出來是容量為0的容器，在第一次往容器裡新增物件時，只會讓容量擴充到1
// oldCapacity為0，newCapacity為0，minCapacity為1，
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
複製程式碼個人猜測這個設計的由來是為了容器容量的緩慢增長，避免浪費太多的空間，所以以後編碼遇到容器類需要儲存比較少物件的時候，用帶引數的建構函式有利於節省記憶體
好了，上面就是ArrayList的重頭戲擴容，還有剩餘的幾個add方法也一併過了
public void add(int index, E element) {
rangeCheckForAdd(index);
ensureCapacityInternal(size + 1); // Increments modCount!!
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++;
}
複製程式碼add(int index, E element)方法，根據制定下標開始新增元素，首先會呼叫rangeCheckForAdd方法判斷下標是否有錯，然後再判斷是否需要擴容，然後呼叫
System.arraycopy(elementData, index, elementData, index + 1, size - index);
複製程式碼將index之後的資料往後移一位，最後將element新增到elementData的index，同時size增加
add系列還有
public boolean addAll(Collection<? extends E> c) // 新增集合
public boolean addAll(int index, Collection<? extends E> c) // 往直接下標開始新增集合
複製程式碼具體實現就不再囉嗦了，大同小異，有興趣可以自己翻閱，我們進入下一個模組
-
獲取 ArrayList提供好幾種獲取容器內物件的方法
- 第一種，get，簡單易懂，就不敘述了
public E get(int index) { rangeCheck(index); return elementData(index); } 複製程式碼-
第二種，通過Iterator()返回私有內部類Itr物件(Itr實現了Iterator介面)，然後在迭代器物件基礎上獲取容器內的物件
各種迭代器的方法我就不在敘述了
-
第三種，通過listIterator()或者listIterator(int index)返回私有內部類ListItr物件(ListItr繼承Itr並實現了ListIterator介面)，然後在迭代器物件基礎上獲取容器內的物件
ListIterator繼承於Iterator，在普通的迭代的基礎上增加了往前迭代的操作，因此使用ListIterator迭代ArrayList物件也提供了往前操作物件的方法這裡有一個點注意的是上文中提到的
modcount,就拿ListItr中的previous()方法舉例吧 我們先過一遍這個方法，遊標減1後賦值給i，如果i的值小於0，報錯；然後通過閉包獲取到外部類的elementData，如果i大於elementData的長度，報錯；然後將i賦值給遊標，然後直接獲取到elementData中的值
@SuppressWarnings("unchecked")
public E previous() {
checkForComodification();
int i = cursor - 1;
if (i < 0)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i;
return (E) elementData[lastRet = i];
}
複製程式碼checkForComodification()，就是這個方法用到了modCount我們點進去看下
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
複製程式碼然後再看下程式碼中expectedModCount是什麼東西
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;**
....
}
複製程式碼可以看到expectedModCount就是modCount的一個副本，是***在Itr類物件被建立的時候初始化的，也就是一經建立就不會改變***。而modCount是在每次操作容器內的資料的時候會自增的，那麼什麼時候modCount != expectedModCount呢？沒錯，就是已經通過list物件獲取到一個迭代器物件之後，又對list物件進行了資料物件的操作，為此我做了一個測試
這也是ArrayList執行緒不安全的一個體現，共享變數是沒加鎖的，在多執行緒環境下很容易被修改然後資料就亂套了 其他方法和正常的ListIterator差不多，這裡也不再囉嗦了
- 其他模組 其他的大概就是set，remove,size,indexOf序列化的兩個方法(readObjact(),writeObject())，在搞定了add()的擴容基礎上，前四個也是很小case了，而後兩個是私有方法，我們是無法直接使用，找了找資料說是呼叫ObjectOutInputStream序列化的時候會通過反射呼叫，這裡還沒了解過和測試過，也不自作高明瞭。
後言
看了原始碼才發現原始碼真的就像高中數理化那些基礎一樣，基礎好了，弄很多東西都順手拈來，也是看了原始碼才知道一個類有哪些地方需要注意，甚至是有哪些地方可以優化，而不是一個API工程師