Java集合源碼–ArrayList的解析

ArrayList可以看作是對一個數組的封裝，實現可變數組。
1.ArrayList的基本欄位

//儲存真正元素的數組，這裡可能大家會感到奇怪，為什麼把這數組標記為transient，這
//樣序列化時不能序列化這個數組了。所以之後就只能才能手動序列化儲存ArrayList裡
//的元素值了。雖說數組裡儲存的都是對象的引用，序列化的時候，也會把真正的對象序
//列化儲存起來的。但是如果是直接不用transient修飾這個數組，那麼序列化時，那些
//elementData中為null的空間也會序列化。一句話：我們序列化時，是序
//列化ArrayList裡的真正的元素，而不是elementData這個數組。
private transient Object[] elementData;

//ArrayList元素的個數
private int size;

//這個欄位其實是屬於AbstractList類的，只不過ArrayList繼承了過來。
//當ArrayList的結構發生變化時，這個欄位都增1，比如調用add，remove等
//方法增加一個元素，刪除一個元素時。
protected transient int modCount = 0;

2.ArrayList的構造方法
    public ArrayList(int initialCapacity) {
super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
this.elementData = new Object[initialCapacity];
    }
其實就是根據指定大小initialCapacity建立一個數組。
   public ArrayList() {
this(10);
    }
可見，預設情況下，建立的ArrayList對象數組長度是10.

3.add方法
public boolean add(E e) {
ensureCapacity(size + 1);  // Increments modCount!!
elementData[size++] = e;
return true;
    }
增加一個元素時，第一步是檢查數組空間是否夠大，不夠大，就擴充，就是變長數組的做法，其實就是建立另一個空間大一點的數組，把原來數組裡的元素拷貝過去就是了；第二步就直接儲存元素到數組裡去。
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;
            // minCapacity is usually close to size, so this is a win:
            elementData = Arrays.copyOf(elementData, newCapacity);
}
    }
可以看到，如果在擴充時，新數組是原來數組的1.5倍，為什麼是1.5倍呢，其實，這是一個考慮空間和時間平衡的結果。是個經驗值，其實有些做法是擴充為原來的2倍。

對add方法的分析，如果不擴充數組時，增加一個元素是常量時間，如果擴充數組是，是O（n），但是總的來說，均攤的時間是常量。具體分析可以看相關講解資料結構的書。
所以說，在ArrayList的尾部插入元素是比較快的
。

在ArrayList的指定位置插入元素時，平均時間是O(n)。
因為插入元素後面的元素需要進行移動。
    public void add(int index, E 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++;
    }
4.remove方法
這個方法也比較簡單，平均時間為O(n)
    public E remove(int index) {
RangeCheck(index);

modCount++;
E oldValue = (E) 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;
    }
5.get方法
根據索引值直接得到元素，時間為常量。
   public E get(int index) {
RangeCheck(index);

return (E) elementData[index];
    }
6.contains方法
   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;
    }
可以看到，其實就是順序的檢索，不管成功與否，平均時間和最壞時間都是O(n)