public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable{
//類的實現
}
它繼承於AbstractList，實現了List, RandomAccess, Cloneable, java.io.Serializable這些接口。
ArrayList 繼承了AbstractList，實現了List。它是一個數組隊列，提供了相關的添加、刪除、修改、遍歷等功能。
ArrayList 實現了RandmoAccess接口，即提供了隨機訪問功能。RandmoAccess是java中用來被List實現，爲List提供快速訪問功能的。在ArrayList中，我們即可以通過元素的序號快速獲取元素對象；這就是快速隨機訪問。ArrayList 實現了Cloneable接口，即覆蓋了函數clone()，能被克隆。ArrayList 實現java.io.Serializable接口，這意味着ArrayList支持序列化，能通過序列化去傳輸。和Vector不同，ArrayList中的操作不是線程安全的！所以，建議在單線程中才使用ArrayList，而在多線程中可以選擇Vector或者CopyOnWriteArrayList。
// 序列化id
private static final long serialVersionUID = 8683452581122892189L;
// 默認初始的容量
private static final int DEFAULT_CAPACITY = 10;
// 一個空對象
private static final Object[] EMPTY_ELEMENTDATA = new Object[0];
// 一個空對象，如果使用默認構造函數創建，則默認對象內容默認是該值
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = new Object[0];
// 當前數據對象存放地方，當前對象不參與序列化
transient Object[] elementData;
// 當前數組長度
private int size;
// 數組最大長度
private static final int MAX_ARRAY_SIZE = 2147483639;
屬性是以上這些，還有一個modCount屬性，代表ArrayList集合的修改次數。
構造函數：
/**
* Constructs an empty list with the specified initial capacity.
*
* @param initialCapacity the initial capacity of the list
* @throws IllegalArgumentException if the specified initial capacity
* is negative
*/
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);
}
}
EMPTY_ELEMENTDATA 實際上就是一個共享的空的Object數組對象。
/**
* Shared empty array instance used for empty instances.
*/
private static final Object[] EMPTY_ELEMENTDATA = {};
上述代碼理解，如果用戶指定的初始化容量大於0，就new一個相應大小的數組，如果指定的大小爲0，就複製爲共享的那個空的Object數組對象。如果小於0，就直接拋出異常。
/**
* Constructs an empty list with an initial capacity of ten.
*/
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
/**
* Shared empty array instance used for default sized empty instances. We
* distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
* first element is added.
*/
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
剛初始化的時候，會是一個共享的類變量，也就是一個Object空數組，當第一次add的時候，這個數組就會被初始化一個大小爲10的數組。
add(E e) 方法
add主要的執行邏輯如下：
1）確保數組已使用長度（size）加1之後足夠存下 下一個數據
2）修改次數modCount 標識自增1，如果當前數組已使用長度（size）加1後的大於當前的數組長度，則調用grow方法，增長數組，grow方法會將當前數組的長度變爲原來容量的1.5倍。
3）確保新增的數據有地方存儲之後，則將新元素添加到位於size的位置上。
4）返回添加成功布爾值。
public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
確保添加的元素有地方存儲，當第一次添加元素的時候this.size+1 的值是1，所以第一次添加的時候會將當前elementData數組的長度變爲10：
private void ensureCapacityInternal(int minCapacity) {
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
ensureExplicitCapacity(minCapacity);
}
將修改次數（modCount）自增1，判斷是否需要擴充數組長度,判斷條件就是用當前所需的數組最小長度與數組的長度對比，如果大於0，則增長數組長度。
private void ensureExplicitCapacity(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
如果當前的數組已使用空間（size）加1之後 大於數組長度，則增大數組容量，擴大爲原來的1.5倍。
private void grow(int arg0) {
int arg1 = this.elementData.length;
int arg2 = arg1 + (arg1 >> 1);
if (arg2 - arg0 < 0) {
arg2 = arg0;
}
if (arg2 - 2147483639 > 0) {
arg2 = hugeCapacity(arg0);
}
this.elementData = Arrays.copyOf(this.elementData, arg2);
}
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）上
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++;
}
使用該方法的話將導致指定位置後面的數組元素全部重新移動，即往後移動一位。
get:返回指定位置上的元素
public E set(int index, E element) {
rangeCheck(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}
set:確保set的位置小於當前數組的長度（size）並且大於0，獲取指定位置（index）元素，然後放到oldValue存放，將需要設置的元素放到指定的位置（index）上，然後將原來位置上的元素oldValue返回給用戶。
public E set(int index, E element) {
rangeCheck(index);
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}
contains方法
調用indexOf方法，遍歷數組中的每一個元素作對比，如果找到對於的元素，則返回true，沒有找到則返回false。
public boolean contains(Object o) {
return indexOf(o) >= 0;
}
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返回
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操作
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），將數組內的元素都置空，等待垃圾收集器收集，不減小數組容量。
/**
* Removes all of the elements from this list. The list will
* be empty after this call returns.
*/
public void clear() {
modCount++;
// clear to let GC do its work
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;
}
trimToSize方法
1）修改次數加1
2）將elementData中空餘的空間（包括null值）去除，例如：數組長度爲10，其中只有前三個元素有值，其他爲空，那麼調用該方法之後，數組的長度變爲3.
/**
* Trims the capacity of this <tt>ArrayList</tt> instance to be the
* list's current size. An application can use this operation to minimize
* the storage of an <tt>ArrayList</tt> instance.
*/
public void trimToSize() {
modCount++;
if (size < elementData.length) {
elementData = (size == 0)
? EMPTY_ELEMENTDATA
: Arrays.copyOf(elementData, size);
}
}
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遍歷可能會引發多線程異常