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)