終於可以開始分析第一個具體的類，我們對ArrayList應該非常面熟了，不管你是否瞭解它是如何實現的，
但是我們到處都使用到它。
　　 宣告如下：

　public class ArrayList extends AbstractList　implements List, RandomAccess, Cloneable, java.io.Serializable

有關AbstractList:http://blog.csdn.net/treeroot/archive/2004/09/14/104743.aspx
有關List: 　　　http://blog.csdn.net/treeroot/archive/2004/09/14/104638.aspx
有關RandomAccess:http://blog.csdn.net/treeroot/archive/2004/09/14/104538.aspx
有關Cloneable :http://blog.csdn.net/treeroot/archive/2004/09/07/96936.aspx
有關java.io.Serializeable:　主要用於物件序列化。

private static final long serialVersionUID = 8683452581122892189L;
版本控制

private transient Object elementData[];
內部結構，原來就是一個數組，這裡不讓它序列化。

private int size;
該列表的大小，也就是元素個數。

public ArrayList(int initialCapacity) {
　　super();
　　if (initialCapacity < 0)
　　　　throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);
　　this.elementData = new Object[initialCapacity];
}

public ArrayList() {
　　this(10);
}
預設初始話內部陣列大小為10,為什麼是10是沒有理由的，可能比較合適吧。

public ArrayList(Collection c) {
　　size = c.size();
　　// Allow 10% room for growth
　　elementData = new Object[(int)Math.min((size*110L)/100,Integer.MAX_VALUE)]; 
　　c.toArray(elementData);
}
通過一個集合來初始話該ArrayList，內部陣列申請的空間比c大，主要是為了提高效率。注意到c.toArray(elementData)
方法的呼叫，這裡肯定不會生成新的陣列，如果用elementData=c.toArray()效率就差不少了。另外這裡呼叫了Math的靜態
方法min來獲得較小值。

public void trimToSize() {
　　modCount++;
　　int oldCapacity = elementData.length;
　　if (size < oldCapacity) {
　　　　Object oldData[] = elementData;
　　　　elementData = new Object[size];
　　　　System.arraycopy(oldData, 0, elementData, 0, size);
　　}
}
這個方法去掉多餘的空間，使內部陣列的大小剛好等於ArrayList的size(),這個方法需要重新分配空間，而已需要一個數組
拷貝過程(arraycopy是一個native方法，用的比較多)，一般情況下這個方法很少被呼叫。

public void ensureCapacity(int minCapacity) {
　　modCount++;
　　int oldCapacity = elementData.length;
　　if (minCapacity > oldCapacity) {
　　　　Object oldData[] = elementData;
　　　　int newCapacity = (oldCapacity * 3)/2 + 1;
　　　　if (newCapacity < minCapacity)
　　　　　　newCapacity = minCapacity;
　　　　elementData = new Object[newCapacity];
　　　　System.arraycopy(oldData, 0, elementData, 0, size);
　　}
}
這個方法來擴大ArrayList的容量，使它至少能容納minCapacity個元素，如果陣列容量大於該值，什麼也不做。否則按某個
演算法(1.5倍加1)增加，如果不夠minCapacity大的話，就設定為minCapacity。這個方法在add和addAll方法中都要呼叫，
這裡為什麼設定為public呢？因為每次重新分配空間都是比較消耗時間的(new操作還要arrayCopy),如果能預計可能的大小
的話，這個方法就有比較的靈活性。雖然該擴容算髮已經比較好，但是還是可以通過自己的控制提高效率，這個方法為程式設計師
帶來的方便。
eg1:
ArrayList al=new ArrayList();
for(int i=0;i<100;i++){
　　Object obj=new Object();
　　al.add(obj);
}
eg2(更高效):
ArrayList al=new ArrayList(100);
for(int i=0;i<100;i++){
　　Object obj=new Object();
　　al.add(obj);
}
或者
ArrayList al=new ArrayList();
al.ensureCapacity(100); 
for(int i=0;i<100;i++){
　　Object obj=new Object();
　　al.add(obj);
}

public int size() {
　　return size;
}
返回大小

public boolean isEmpty() {
　　return size == 0;
}
是否為空

public boolean contains(Object elem) {
　　return indexOf(elem) >= 0;
} 
是否包含指定元素，呼叫的是indexOf()方法。

public int indexOf(Object elem) {
　　if (elem == null) {
　　　　for (int i = 0; i < size; i++)
　　　　　　if (elementData[i]==null)
　　　　　　　　return i;
　　} else {
　　　　for (int i = 0; i < size; i++)
　　　　　　if (elem.equals(elementData[i]))
　　　　　　　　return i;
　　}
　　return -1;
}
這個方法遍歷列表(陣列0..size-1)

public int lastIndexOf(Object elem) {
　　if (elem == null) {
　　　　for (int i = size-1; i >= 0; i--)
　　　　　　if (elementData[i]==null)
　　　　　　　　return i;
　　} else {
　　　　for (int i = size-1; i >= 0; i--)
　　　　　　if (elem.equals(elementData[i]))
　　　　　　　　return i;
　　}
　　return -1;
}
這個方法和上面的基本一樣，順序不一樣而已。

public Object clone() {
　　try { 
　　　　ArrayList v = (ArrayList)super.clone();
　　　　v.elementData = new Object[size];
　　　　System.arraycopy(elementData, 0, v.elementData, 0, size);
　　　　v.modCount = 0;
　　　　return v;
　　} catch (CloneNotSupportedException e) { 
　　// this shouldn't happen, since we are Cloneable
　　　　throw new InternalError();
　　}
}　
覆蓋Object中的clone()方法，實現clone，注意這裡是一個淺拷貝，兩個ArrayList中的陣列中的元素
是相同的，因為System.arraycopy就是淺拷貝。

public Object[] toArray() {
　　Object[] result = new Object[size];
　　System.arraycopy(elementData, 0, result, 0, size);
　　return result;
}
返回ArrayList元素的一個數組，注意這裡雖然生成了一個新的陣列，但是陣列元素和集合中的元素是共享的，
Collection介面中說這個是安全的是不嚴格的,下面的例子演示了這個效果。
eg1: 
ArrayList al=new ArrayList();
al.add(new StringBuffer("hello"));
Object[] a=al.toArray();
StringBuffer sb=(StringBuffer)a[0];
sb.append("changed"); 　　　　　　　　//改變陣列元素同樣也改變了原來的ArrayList中的元素
System.out.println(al.get(0)); 　　　 
這裡不要用String來代替StringBuffer，因為String是常量。

public Object[] toArray(Object a[]) {
　　if (a.length < size)
　　　　a = (Object[])java.lang.reflect.Array.newInstance(a.getClass().getComponentType(), size);
　　 System.arraycopy(elementData, 0, a, 0, size);
　　 if (a.length > size)
　　　　　　a[size] = null;
　　 return a;
}
這個方法有可能不需要生成新的陣列，注意到如果陣列a容量過大，只在size處設定為null。

public Object get(int index) {
　　RangeCheck(index);
　　return elementData[index];
}
可以看隨機訪問效率是很高的，和陣列的索引訪問是一樣的，方式設計到索引值都會先檢查。

public Object set(int index, Object element) {
　　RangeCheck(index);
　　 Object oldValue = elementData[index];
　　elementData[index] = element;
　　return oldValue;
}
更新指定位置的值，並訪問原來的值。

public boolean add(Object o) {
　　ensureCapacity(size + 1); // Increments modCount!!
　　elementData[size++] = o;
　　return true;
} 
新增一個新的元素到末尾,前面說道新增方法都要先呼叫ensureCapacity方法，這裡沒有呼叫add(size,o)方法。

public void add(int index, Object element) {
　　if (index > size || index < 0)
　　　throw new IndexOutOfBoundsException("Index: "+index+", Size: "+size);
　　 ensureCapacity(size+1); // Increments modCount!!
　　System.arraycopy(elementData, index, elementData, index + 1,size - index);
　　elementData[index] = element;
　　size++;
}
在指定位置插入元素，指定元素和後面的元素後移。

public Object remove(int index) {
　　RangeCheck(index);
　　 modCount++;
　　Object oldValue = elementData[index];
　　 int numMoved = size - index - 1;
　　if (numMoved > 0)
　　　　System.arraycopy(elementData, index+1, elementData, index,numMoved);
　　elementData[--size] = null; // Let gc do its work
　　 return oldValue;
}
刪除指定位置的元素，後面的元素前移，返回被刪除的元素，這裡要注意的elementData[--size]=null這條語句，
如果不這樣的話，就有可能造成記憶體洩露，因為該物件其實已經沒有用，但是內部還有一個它的引用，如果不設定
為null，GC就無法回收這個空間，積累多了就有可能造成記憶體洩露，這裡只說有可能，而不是一定。

public void clear() {
　　modCount++;
　　// Let gc do its work
　　for (int i = 0; i < size; i++)
　　　　elementData[i] = null;
　　 size = 0;
}
這段程式碼比較高效，這裡也必須設定為空引用，理由同上。

public boolean addAll(Collection c) {
　　modCount++;
　　int numNew = c.size();
　　ensureCapacity(size + numNew);
　　 Iterator e = c.iterator();
　　for (int i=0; i
　　　　elementData[size++] = e.next();
　　 return numNew != 0;
}
新增集合c中的元素到ArrayList的末尾，新增成功返回true，如果集合c為空，返回false。

public boolean addAll(int index, Collection c) {
　　if (index > size || index < 0)
　　　　throw new IndexOutOfBoundsException("Index: "+index+", Size: "+size);
　　 int numNew = c.size();
　　ensureCapacity(size + numNew); // Increments modCount!!
　　 int numMoved = size - index;
　　　if (numMoved > 0)
　　　　　　System.arraycopy(elementData, index, elementData, index + numNew,numMoved);
　　 Iterator e = c.iterator();
　　　for (int i=0; i
　　　　elementData[index++] = e.next();
　　 size += numNew;
　　　return numNew != 0;
}
在指定位置插入集合中的所有元素，和上面一個方法基本差不多，指定位置元素和以後的都要後移。

protected void removeRange(int fromIndex, int toIndex) {
　　modCount++;
　　int numMoved = size - toIndex;
　　System.arraycopy(elementData, toIndex, elementData, fromIndex,numMoved);
　　 // Let gc do its work
　　int newSize = size - (toIndex-fromIndex);
　　while (size != newSize)
　　elementData[--size] = null;
}
這是一個保護方法，刪除指定位置fromIndex到toIndex的元素，包括前面不包括後面。

private void RangeCheck(int index) {
　　if (index >= size || index < 0)
　　　　throw new IndexOutOfBoundsException("Index: "+index+", Size: "+size);
}
不用解釋。

private synchronized void writeObject(java.io.ObjectOutputStream s)　throws java.io.IOException{
　　// Write out element count, and any hidden stuff
　　s.defaultWriteObject();
　　 // Write out array length
　　s.writeInt(elementData.length);
　　 // Write out all elements in the proper order.
　　for (int i=0; i
　　　　s.writeObject(elementData[i]);
}
private synchronized void readObject(java.io.ObjectInputStream s)　throws 　　　　　　　　　　　　　　java.io.IOException,ClassNotFoundException {
　　// Read in size, and any hidden stuff
　　s.defaultReadObject();
　　// Read in array length and allocate array
　　int arrayLength = s.readInt();
　　elementData = new Object[arrayLength];
　　 // Read in all elements in the proper order.
　　for (int i=0; i
　　　　elementData[i] = s.readObject();
}
這兩個方法是為了實現序列化而寫的，這裡要注意幾點：
1.這兩個方法並不是java.io.Serializable中定義的方法，Serializable只是標記介面。
2.序列化物件的時候會先檢查該物件是否實現了這兩個方法，如果有實現就呼叫他們，如果沒有的化就呼叫預設方法。
至於為什麼可以呼叫該物件的private方法我也不清楚，這個問題確實比較奇怪，如果可以訪問物件的private方法，那
也太不安全了。 
3.因為elementData宣告為transient，所以必須手動序列化化。

總結：
1.ArrayList的方法都沒有同步，所以在多執行緒中是不安全的，必須自己同步，而且ArrayList很多方法宣告對於多執行緒操作
都沒有規定，就是說結果不可預料。
2.toArray()方法返回的是和原列表相同的物件，也就是說:
arrayList.toArray()[0]==arrayList.get(0)返回的是true(假定arrayList不空)。
3.clone()方法是一個淺拷貝。
4.可以通過自己呼叫ensureCapacity()提高效率。

注：

arraycopy方法是java native inteface 的一個方法，好像是記憶體複製，效率比較高。

public static void arraycopy(Object src,int srcPos,Object dest,int destPos,int length); 
src:源陣列； srcPos:源陣列要複製的起始位置； 
dest:目的陣列； destPos:目的陣列放置的起始位置； length:複製的長度