資訊專欄INFORMATION COLUMN
摘要：注意，迭代器的快速失敗行為無法得到保證，快速失敗迭代器會盡最大努力拋出。迭代器的快速失敗行為應該僅用于檢測。
幾個重要接口
首先看方法聲明：
public class ArrayListextends AbstractList implements List , RandomAccess, Cloneable, java.io.Serializable
RandomAccess：
public interface RandomAccess {
}
RandomAccess接口都是給 List所使用的，用來表明其支持快速（通常是固定時間）隨機訪問，為其提供良好的性能。實際經驗證明，如果是下列情況，則 List 實現應該實現此接口，即對于典型的類實例而言，此循環：
for (int i=0, n=list.size(); i < n; i++)
list.get(i);
的運行速度要快于以下循環：
for (Iterator i=list.iterator(); i.hasNext(); )
i.next();
Cloneable：
public interface Cloneable {
}
實現了此接口的類就可以通過重寫 Object.clone（）方法來定制對其進行復制的細節,如果在沒有實現 Cloneable 接口的實例上調用 Object 的 clone 方法，則會導致拋出 CloneNotSupportedException 異常。
兩個變量/** * ArrayList中元素存儲的地方，數組的長度就是它的容量 */ private transient Object[] elementData; /** *ArrayList所包含的元素的大小 */ private int size;構造方法
提供了3種構造方法：
public ArrayList(int initialCapacity) {
super();
if (initialCapacity < 0)
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
this.elementData = new Object[initialCapacity];
}
public ArrayList() {
this(10);
}
public ArrayList(Collection c) {
elementData = c.toArray();
size = elementData.length;
// c.toArray might (incorrectly) not return Object[] (see 6260652)
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
}
可以看到：第一種方法需要一個默認的容量大小，第二個是默認的構造方法，會默認創建一個容量為10的 ArrayList，第三個則傳給一個 Collection，注意，不管 Collection里面是什么類型，最后放進 ArrayList都會上轉為 Object
重要方法 add public boolean add(E e) {
ensureCapacityInternal(size + 1); // Increments modCount!!
elementData[size++] = e;
return true;
}
add方法中使用了 ensureCapacityInternal來控制容量：
private void ensureCapacityInternal(int minCapacity) {
modCount++;
// overflow-conscious code
if (minCapacity - elementData.length > 0)
grow(minCapacity);
}
其中 modCount是用來記錄 list被結構修改的次數，所謂結構上的修改是 指任何添加或刪除一個或多個元素的操作，或者顯式調整底層數組的大小；僅僅設置元素的值不是結構上的修改；在上面的方法中，如果 minCapacity 大于現有數組長度，則執行 grow方法：
private void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = elementData.length;
/*newCapacity 擴展為舊容量的1.5倍左右*/
int newCapacity = oldCapacity + (oldCapacity >> 1);
/*如果這時新容量還小于minCapacity，則新容量為minCapacity*/
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
/*新容量大于 Integer.MAX_VALUE - 8*/
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// 最后將原數組放進新數組，改變長度
elementData = Arrays.copyOf(elementData, newCapacity);
}
如果 newCapacity大于 Integer.MAX_VALUE - 8，則 newCapacity為 Integer.MAX_VALUE，這也是能夠擴充的最大容量
再來看第二種 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++;
}
這種方法是在指定位置插入元素，主要使用了 System.arraycopy（）方法將 index之后的元素向后移動一個位置，將 index位空出來放入新元素
clearclear方法比較簡單，但是注意調用 clear也會使 modCount加1：
public void clear() {
modCount++;
// Let gc do its work
for (int i = 0; i < size; i++)
elementData[i] = null;
size = 0;
}
clone
public Object clone() {
try {
@SuppressWarnings("unchecked")
ArrayList v = (ArrayList) super.clone();
v.elementData = Arrays.copyOf(elementData, size);
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
// this shouldn"t happen, since we are Cloneable
throw new InternalError();
}
}
clone方法只能進行淺復制，并不復制元素本身
removepublic 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;
}
remove方法中，如果要移除的元素為 null，則刪除數組中第一個為 null的元素。如果數組中有超過一個匹配的元素，僅移除第一個
toArraypublic Object[] toArray() {
return Arrays.copyOf(elementData, size);
}
這個方法被很多方法使用，它調用了 Arrays工具類中的方法 copyOf：
public staticT[] copyOf(T[] original, int newLength) { return (T[]) copyOf(original, newLength, original.getClass()); }
