ArrayList繼承自AbstractList，實現了List, RandomAccess, Cloneable, java.io.Serializable接口。ArrayList內部是一個動態數組，與Java中的數組相比，它的容量能動態增長。
簡述
ArrayList 是容量可變的非線程安全列表，使用數組實現，集合擴容時會創建更大的數組，把原有數組複製到新數組。支持對元素的快速隨機訪問，但插入與刪除速度很慢。ArrayList 實現了 RandomAcess 標記接口，如果一個類實現了該接口，那麼表示使用索引遍歷比迭代器更快。
elementData是 ArrayList 的數據域，被 transient 修飾，序列化時會調用 writeObject 寫入流，反序列化時調用 readObject 重新賦值到新對象的 elementData。原因是 elementData 容量通常大於實際存儲元素的數量，所以只需發送真正有實際值的數組元素。
size 是當前實際大小，elementData 大小大於等於 size。
*modCount *記錄了 ArrayList 結構性變化的次數，繼承自 AbstractList。所有涉及結構變化的方法都會增加該值。expectedModCount 是迭代器初始化時記錄的 modCount 值，每次訪問新元素時都會檢查 modCount 和 expectedModCount 是否相等，不相等就會拋出異常。這種機制叫做 fail-fast，所有集合類都有這種機制。
首先了解ArrayList內部的屬性
1 // 序列化id
2 private static final long serialVersionUID = 8683452581122892189L;
3 //ArrayList的初始容量大小
4 private static final int DEFAULT_CAPACITY = 10;
5 //空對象數組
6 private static final Object[] EMPTY_ELEMENTDATA = {};
7 //空對象數組，如果使用默認構造函數創建，則默認對象內容默認是該值
8 private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
9 //存放當前數據，不參與序列化
10 transient Object[] elementData;
11 //list大小
12 private int size;
13 //list最大長度
14 private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;elementData：這是個 Object 類型的數組，用於存儲具體元素，其表示的數組的大小。
size：用來記錄 ArrayList 當前元素個數，默認為 0。
ArrayList構造方法
//默認構造方法，將elementData初始化為DEFAULTCAPACITY_EMPTY_ELEMENTD（及空數組）
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
//指定容量的構造方法，傳入參數小於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對象，先調用toArray()方法將Collection對象轉換為Object[]
*更新size的值，同時判斷size的大小，如果是size等於0，直接將空對象EMPTY_ELEMENTDATA的地址賦給elementData
*如果size的值大於0，則執行Arrays.copy方法，把collection對象的內容（可以理解為深拷貝）copy到elementData中，代碼註釋toArray可能不是返回Object[]，所以進行深拷貝
**/
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;
}
}在初始化時調用了 ArrayList 的構造方法，這個構造方法只做了一件事，將 elementData 初始化為空數組。
在初次調用 add 方法時，ArrayList 會進行第一次擴容，將 elementData 擴容成容量為 10 的數組，然後再添加元素。
當 ArrayList 已經達到當前最大容量，會再次第二次擴容，將 elementData 擴容成容量為 1原有容量的 1.5 倍），然後再添加元素
其中在構造法方法中，DEFAULTCAPACITY_EMPTY_ELEMENTDATA 由前文可知是一個內部常量，值為空數組，也被用來作為空數組的標識。在後面調用 add 方法時也是通過這個常量來判斷是否第一次調用。
ArrayList的方法
// 添加元素之前先檢查容量，若容量不足則調用grow()方法，然後將元素添加到隊尾，返回true
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
/**
*首先檢查index是否在size範圍之內，確保數組已使用長度（size）加1之後足夠存下一個數據
*然後將index之後的元素全部向後挪一位，再進行賦值
**/
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++;
}
/**
*首先判斷index是否超出範圍，然後返回指定元素值
**/
public E get(int index) {
rangeCheck(index);
return elementData(index);
}
/**
*首先判斷index是否超出範圍，然後將指定索引的數組元素賦值
**/
public E set(int index, E element) {
rangeCheck(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}
/**
*首先判斷index是否超出範圍，numMoved 計算移除元素後需要移動的元素個數
*通過System.arraycopy方法將後面的元素前移一位，並將最後一為賦值為null，最後返回移除元素的值
*/
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;
}
/**
*需要遍歷整個list去匹配移除元素的值
*/
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;
}
/**
*需要遍歷整個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;
}ArrayList的主要方法
//minCapacity 最小即為初始容量大小10
private void ensureCapacityInternal(int minCapacity) {
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);
}
/**
*首先將oldCapacity 右移一位縮小1/2，newCapacity 擴大為oldCapacity 的1.5倍
*如果newCapacity不能滿足需求，那就直接擴大為minCapacity大小
*如果newCapacity超過list最大容量，則返回Interger類型最大值
*最後更新elementData
**/
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);
}ensureCapacityInternal (int miniCapacity): 用於判斷是否第一次調用，通過構造方法裏用來賦值的常量 DEFAULTCAPACITY_EMPTY_ELEMENTDATA 判斷。
第一次調用：將所需最小容量（即 miniCapacity）設置為 10，然後調用 ensureExplicitCapacity 方法進行擴容
非第一次調用：直接調用 ensureExplicitCapacity 方法進行擴容
ensureExplicitCapacity (int minCapacity): 用於判斷是否需要擴容
modCount 主要是在調用 iterator 方法時用來防止 list 被修改，在這裏可以忽略不計
grow (int miniCapacity): 實際擴容操作
