Java原始碼解析系列（二）ArrayList原始碼解析
備註：以下都是基於JDK8 原始碼分析
ArrayList簡介
ArrayList 是一個數組佇列，相當於 動態陣列。與Java中的陣列相比，它的容量能動態增長。它繼承於AbstractList，實現了List, RandomAccess, Cloneable, java.io.Serializable這些介面。 ArrayList 繼承了AbstractList，實現了List。它是一個數組佇列，提供了相關的新增、刪除、修改、遍歷等功能。
ArrayList 實現了RandmoAccess介面，即提供了隨機訪問功能。RandmoAccess是java中用來被List實現，為List提供快速訪問功能的。在ArrayList中，我們即以O(1)的時間複雜度，通過元素的序號快速獲取元素物件，這就是快速隨機訪問。稍後，我們會比較List的“快速隨機訪問”和“通過Iterator迭代器訪問”的效率。
ArrayList 實現了Cloneable介面，即覆蓋了函式clone()，能被克隆。 ArrayList 實現java.io.Serializable介面，這意味著ArrayList支援序列化，能通過序列化去傳輸。 和Vector不同，ArrayList中的操作不是執行緒安全的！所以，建議在單執行緒中才使用ArrayList，而在多執行緒中可以選擇Vector或者CopyOnWriteArrayList。
因其底層資料結構是陣列，所以可想而知，它是佔據一塊連續的記憶體空間（容量就是陣列的length），所以它也有陣列的缺點，空間效率不高。
由於陣列的記憶體連續，可以根據下標以O1的時間讀寫(改查)
當集合中的元素超出這個容量，便會進行擴容操作。擴容操作也是ArrayList 的一個性能消耗比較大的地方，所以若我們可以提前預知資料的規模，應該通過public ArrayList(int initialCapacity) {}構造方法，指定集合的大小，去構建ArrayList例項，以減少擴容次數，提高效率。
ArrayList屬性
ArrayList屬性主要就是當前陣列長度size，以及存放陣列的物件elementData陣列，除此之外還有一個經常用到的屬性就是從AbstractList繼承過來的modCount屬性，代表ArrayList集合的修改次數。
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
//序列化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;注意：EMPTY_ELEMENTDATA、DEFAULTCAPACITY_EMPTY_ELEMENTDATA都用static修飾，也就是當再次建立預設建構函式或0容量的ArrayList，並不會重新分配記憶體，其內部資料都指向同一個引用，起到快取的作用。
elementData 之所以用transient關鍵字修飾，是因為序列化的時候，其中有一些空資料，並不需要把整個陣列都序列化，只需要序列化實際資料大小的資料即可。
ArrayList建構函式
無參建構函式
如果不傳入引數，則使用預設無參構建方法建立ArrayList物件，如下：
//賦予一個空陣列物件，當第一新增元素時，elementData長度會設定成10
public ArrayList() {this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;}帶int型別的建構函式
如果傳入引數，則代表指定ArrayList的初始陣列長度，傳入引數如果是大於等於0，則使用使用者的引數初始化，如果使用者傳入的引數小於0，則丟擲異常，構造方法如下：
/**
* 傳入指定容量來初始化ArrayList容量，如果大於0使用指定容量。
* 如果等於0則使用快取的空陣列物件。
*
* @param initialCapacity 容量大小
* @throws IllegalArgumentException 如果容量小於0，則丟擲異常
*
*/
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物件的建構函式
1）將collection物件轉換成陣列，然後將陣列的地址的賦給elementData。
2）更新size的值，同時判斷size的大小，如果是size等於0，直接將空物件EMPTY_ELEMENTDATA的地址賦給elementData
3）如果size的值大於0，則執行Arrays.copy方法，把collection物件的內容（可以理解為深拷貝）copy到elementData中。
/**
*
* 傳入一個集合構造ArrayList
*
* @param c 集合資料
* @throws 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;
}
}注意：this.elementData = c.toArray(); 這裡會有一個bug。如果是Arrays.asList呼叫產出的集合，其會保留原始型別，會導致後面加入其它型別的資料，丟擲異常。所以需要判斷其中的型別是否是Object[].class，如果不是則執行深度拷貝，將型別轉為Object[].class。
其測試程式碼如下
public static void test2()
{
List<String> list = Arrays.asList("abc");
// 這裡是 java.util.Arrays$ArrayList
System.out.println(list.getClass());
// 陣列中的實際型別是 [java.lang.String];
Object[] objArray = list.toArray();
System.out.println(objArray.getClass());
objArray[0] = new Object(); // 此處會丟擲 ArrayStoreException
}
add(E e) 方法
add主要的執行邏輯如下：
1）計算陣列已使用長度（size）加1之後，所需的最小容量
2）修改次數modCount 標識自增1，如果當前陣列已使用長度（size）加1後的大於當前的陣列長度，則呼叫grow方法，增長陣列，grow方法會將當前陣列的長度變為原來容量的1.5倍。如果還是小於所需容量，則以所需容量為準。如果大於MAX_ARRAY_SIZE，則使用Integer.MAX_VALUE。備註：陣列作為一個物件，一些機器需要一定的記憶體儲存物件頭資訊，物件頭資訊最大佔用記憶體不可超過8位元組。所以MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8，避免出錯。
3）確保新增的資料有地方儲存之後，則將新元素新增到位於size的位置上。
4）返回新增成功布爾值。
/**
* 在列表末尾新增元素
*
* @param e 元素
* @return true 新增成功返回值
*/
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
//計算新增資料後，所需容量
private static int calculateCapacity(Object[] elementData, int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
return Math.max(DEFAULT_CAPACITY, minCapacity);
}
return minCapacity;
}
//確認容量
private void ensureCapacityInternal(int minCapacity) {
ensureExplicitCapacity(calculateCapacity(elementData, 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);
}add(int index, E element)方法
這個方法其實和上面的add類似，該方法可以按照元素的位置，指定位置插入元素，具體的執行邏輯如下：
1）確保數插入的位置小於等於當前陣列長度，並且不小於0，否則丟擲異常
2）確保陣列已使用長度（size）加1之後足夠存下 下一個資料
3）修改次數（modCount）標識自增1，如果當前陣列已使用長度（size）加1後的大於當前的陣列長度，則呼叫grow方法，增長陣列
4）grow方法會將當前陣列的長度變為原來容量的1.5倍。
5）確保有足夠的容量之後，使用System.arraycopy 將需要插入的位置（index）後面的元素統統往後移動一位。
6）將新的資料內容存放到陣列的指定位置（index）上
/**
* 在List中的指定位置插入元素
*
* @param index 插入的指定座標
* @param element 插入元素
* @throws IndexOutOfBoundsException 越界後拋異常
*/
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++;
}
/**
* 確認下標是否越界
*/
private void rangeCheckForAdd(int index) {
if (index > size || index < 0)
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}get方法
返回指定位置上的元素，
/**
* 返回指定座標下的元素
*
* @param index 指定座標
* @return the element at the specified position in this list
* @throws IndexOutOfBoundsException
*/
public E get(int index) {
rangeCheck(index);
return elementData(index);
}set方法
確保set的位置小於當前陣列的長度（size）並且大於0，獲取指定位置（index）元素，然後放到oldValue存放，將需要設定的元素放到指定的位置（index）上，然後將原來位置上的元素oldValue返回給使用者。
/**
* 替換指定座標下的元素為指定新元素
*
*
* @param index 被替換的下標
* @param element 指定的新元素
* @return the element 老元素
* @throws IndexOutOfBoundsException
*/
public E set(int index, E element) {
rangeCheck(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}contains方法
呼叫indexOf方法，遍歷陣列中的每一個元素作對比，如果找到對於的元素，則返回true，沒有找到則返回false。
/**
*
* 確認List中是否包含指定元素
*
* @param o 指定元素
* @return 如果包含，則返回true
*/
public boolean contains(Object o) {
return indexOf(o) >= 0;
}
/**
* 返回List中，找到的第一個元素的座標，如果不包含則返回-1
*
*
*/
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方法
根據索引remove
1）判斷索引有沒有越界
2）自增修改次數
3）將指定位置（index）上的元素儲存到oldValue
4）將指定位置（index）上的元素都往前移動一位
5）將最後面的一個元素置空，好讓垃圾回收器回收
6）將原來的值oldValue返回
/**
* 刪除指定下標的元素，右邊的元素往左移
*
*
* @param index 指定下標
* @return 返回已刪除的舊元素
* @throws IndexOutOfBoundsException
*/
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;
}根據物件remove
迴圈遍歷所有物件，得到物件所在索引位置，然後呼叫fastRemove方法，執行remove操作，呼叫此方法不會縮減陣列長度
/**
* 移除List中第一個匹配找到的物件
*
* @param o 要刪除的物件
* @return 找到並移除返回true，否則返回false
*/
public boolean remove(Object o) {
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;
}
//移除指定下標元素，並置空
private void fastRemove(int index) {
modCount++;
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
}clear方法
新增操作次數（modCount），將陣列內的元素都置空，等待垃圾收集器收集，不減小陣列容量。
//刪除所有元素，並把陣列內資料置空，等待GC回收記憶體
public void clear() {
modCount++;
// clear to let GC do its work
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;
}sublist方法
我們看到程式碼中是建立了一個ArrayList 類裡面的一個內部類SubList物件，傳入的值中第一個引數時this引數，其實可以理解為返回當前list的部分檢視，真實指向的存放資料內容的地方還是同一個地方，如果修改了sublist返回的內容的話，那麼原來的list也會變動。
/**
* 返回指定區域內的元素List，包含fromIndex，不包含toIndex，如果fromIndex與toIndex相同
* 則返回空List。子List是原List的備份，如果對子List操作都會影響到原List，反之亦然。
*
*
* @throws IndexOutOfBoundsException
* @throws IllegalArgumentException
*/
public List<E> subList(int fromIndex, int toIndex) {
subListRangeCheck(fromIndex, toIndex, size);
return new SubList(this, 0, fromIndex, toIndex);
}trimToSize方法
1）修改次數加1
2）將elementData中空餘的空間（包括null值）去除，例如：陣列長度為10，其中只有前三個元素有值，其他為空，那麼呼叫該方法之後，陣列的長度變為3。
public void trimToSize() {
modCount++;
if (size < elementData.length) {
elementData = (size == 0)
? EMPTY_ELEMENTDATA
: Arrays.copyOf(elementData, size);
}
}iterator方法
interator方法返回的是一個內部類，由於內部類的建立預設含有外部的this指標，所以這個內部類可以呼叫到外部類的屬性。
public Iterator<E> iterator() {
return new Itr();
}一般的話，呼叫完iterator之後，我們會使用iterator做遍歷，這裡使用next做遍歷的時候有個需要注意的地方，就是呼叫next的時候，可能會引發ConcurrentModificationException，當修改次數，與期望的修改次數（呼叫iterator方法時候的修改次數）不一致的時候，會發生該異常.
expectedModCount這個值是在使用者呼叫ArrayList的iterator方法時候確定的，但是在這之後使用者add，或者remove了ArrayList的元素，那麼modCount就會改變，那麼這個值就會不相等，將會引發ConcurrentModificationException異常，這個是在多執行緒使用情況下，比較常見的一個異常。
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;
public boolean hasNext() {
return cursor != size;
}
@SuppressWarnings("unchecked")
public E next() {
checkForComodification();
int i = cursor;
if (i >= size)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1;
return (E) elementData[lastRet = i];
}
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
@Override
@SuppressWarnings("unchecked")
public void forEachRemaining(Consumer<? super E> consumer) {
Objects.requireNonNull(consumer);
final int size = ArrayList.this.size;
int i = cursor;
if (i >= size) {
return;
}
final Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length) {
throw new ConcurrentModificationException();
}
while (i != size && modCount == expectedModCount) {
consumer.accept((E) elementData[i++]);
}
// update once at end of iteration to reduce heap write traffic
cursor = i;
lastRet = i - 1;
checkForComodification();
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}listIterator方法
listInterator方法返回的也是一個內部類，它繼承了Itr內部類，與之不同的是。可以指定從某個位置，向前或向後遍歷元素
/**
*
* 從指定位置開始，返回一個ListIterator
*
*
* @throws IndexOutOfBoundsException
*/
public ListIterator<E> listIterator(int index) {
if (index < 0 || index > size)
throw new IndexOutOfBoundsException("Index: "+index);
return new ListItr(index);
}
/**
* An optimized version of AbstractList.ListItr
*/
private class ListItr extends Itr implements ListIterator<E> {
ListItr(int index) {
super();
cursor = index;
}
public boolean hasPrevious() {
return cursor != 0;
}
public int nextIndex() {
return cursor;
}
public int previousIndex() {
return cursor - 1;
}
@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];
}
public void set(E e) {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.set(lastRet, e);
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
public void add(E e) {
checkForComodification();
try {
int i = cursor;
ArrayList.this.add(i, e);
cursor = i + 1;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
}小結
ArrayList總體來說比較簡單，不過ArrayList還有以下一些特點：
- ArrayList自己實現了序列化和反序列化的方法，因為它自己實現了 private void writeObject(java.io.ObjectOutputStream s)和 private void readObject(java.io.ObjectInputStream s) 方法
- ArrayList基於陣列方式實現，無容量的限制（會擴容）
- 新增元素時可能要擴容（所以最好預判一下），刪除元素時會減少容量（若希望減少容量，trimToSize()），刪除元素時，將刪除掉的位置元素置為null，下次gc就會回收這些元素所佔的記憶體空間。
- 執行緒不安全
- add(int index, E element)：新增元素到陣列中指定位置的時候，需要將該位置及其後邊所有的元素都整塊向後複製一位
- get(int index)：獲取指定位置上的元素時，可以通過索引直接獲取（O(1)）
- remove(Object o)需要遍歷陣列
- remove(int index)不需要遍歷陣列，只需判斷index是否符合條件即可，效率比remove(Object o)高
- contains(E)需要遍歷陣列
- 使用iterator遍歷過程中，如果對ArrayList做修改，可能會引發多執行緒異常
- 增刪改查中， 增導致擴容，則會修改modCount，刪一定會修改。 改和查一定不會修改modCount
- 擴容操作會導致陣列複製，批量刪除會導致 找出兩個集合的交集，以及陣列複製操作，因此，增、刪都相對低效。 而 改、查都是很高效的操作
-
結合特點，在使用中，以Android中最常用的展示列表為例，列表滑動時需要展示每一個Item（element）的陣列，所以 查 操作是最高頻的。相對來說，增操作 只有在列表載入更多時才會用到 ，而且是在列表尾部插入，所以也不需要移動資料的操作。而刪操作則更低頻。 故選用ArrayList作為儲存資料的結構
參考連結