ArrayList就是傳說中的動態數組，就是Array的複雜版本，它提供瞭如下一些好處：動態的增加和減少元素、靈活的設置數組的大小......
認真閱讀本文，我相信一定會對你有幫助。比如爲什麼ArrayList裏面提供了一個受保護的removeRange方法？提供了其他沒有被調用過的私有方法？
首先看到對ArrayList的定義：
-
public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable
從ArrayList<E>可以看出它是支持泛型的，它繼承自AbstractList，實現了List、RandomAccess、Cloneable、Java.io.Serializable接口。
AbstractList提供了List接口的默認實現（個別方法爲抽象方法）。
List接口定義了列表必須實現的方法。
RandomAccess是一個標記接口，接口內沒有定義任何內容。
實現了Cloneable接口的類，可以調用Object.clone方法返回該對象的淺拷貝。
通過實現 java.io.Serializable 接口以啓用其序列化功能。未實現此接口的類將無法使其任何狀態序列化或反序列化。序列化接口沒有方法或字段，僅用於標識可序列化的語義。
ArrayList的屬性
ArrayList定義只定義類兩個私有屬性：
-
-
-
-
-
private transient Object[] elementData;
-
-
-
-
-
-
-
private int size;
-
很容易理解，elementData存儲ArrayList內的元素，size表示它包含的元素的數量。
-
-
有個關鍵字需要解釋：transient。
-
-
Java的serialization提供了一種持久化對象實例的機制。當持久化對象時，可能有一個特殊的對象數據成員，我們不想用serialization機制來保存它。爲了在一個特定對象的一個域上關閉serialization，可以在這個域前加上關鍵字transient。
-
ansient是Java語言的關鍵字，用來表示一個域不是該對象串行化的一部分。當一個對象被串行化的時候，transient型變量的值不包括在串行化的表示中，然而非transient型的變量是被包括進去的。
-
-
有點抽象，看個例子應該能明白。
-
public class UserInfo implements Serializable {
-
private static final long serialVersionUID = 996890129747019948L;
-
private String name;
-
private transient String psw;
-
-
public UserInfo(String name, String psw) {
-
this.name = name;
-
this.psw = psw;
-
}
-
-
public String toString() {
-
return "name=" + name + ", psw=" + psw;
-
}
-
}
-
-
public class TestTransient {
-
public static void main(String[] args) {
-
UserInfo userInfo = new UserInfo("張三", "123456");
-
System.out.println(userInfo);
-
try {
-
-
ObjectOutputStream o = new ObjectOutputStream(new FileOutputStream(
-
"UserInfo.out"));
-
o.writeObject(userInfo);
-
o.close();
-
} catch (Exception e) {
-
-
e.printStackTrace();
-
}
-
try {
-
-
ObjectInputStream in = new ObjectInputStream(new FileInputStream(
-
"UserInfo.out"));
-
UserInfo readUserInfo = (UserInfo) in.readObject();
-
-
System.out.println(readUserInfo.toString());
-
} catch (Exception e) {
-
-
e.printStackTrace();
-
}
-
}
-
}
被標記爲transient的屬性在對象被序列化的時候不會被保存。
接着回到ArrayList的分析中......
ArrayList的構造方法
看完屬性看構造方法。ArrayList提供了三個構造方法：
-
-
-
-
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<? extends E> c) {
-
elementData = c.toArray();
-
size = elementData.length;
-
-
if (elementData.getClass() != Object[].class)
-
elementData = Arrays.copyOf(elementData, size, Object[].class);
-
}
第一個構造方法使用提供的initialCapacity來初始化elementData數組的大小。第二個構造方法調用第一個構造方法並傳入參數10，即默認elementData數組的大小爲10。第三個構造方法則將提供的集合轉成數組返回給elementData（返回若不是Object[]將調用Arrays.copyOf方法將其轉爲Object[]）。
ArrayList的其他方法
add(E e)
add(E e)都知道是在尾部添加一個元素，如何實現的呢？
-
public boolean add(E e) {
-
ensureCapacity(size + 1);
-
elementData[size++] = e;
-
return true;
-
}
書上都說ArrayList是基於數組實現的，屬性中也看到了數組，具體是怎麼實現的呢？比如就這個添加元素的方法，如果數組大，則在將某個位置的值設置爲指定元素即可，如果數組容量不夠了呢？
看到add(E e)中先調用了ensureCapacity(size+1)方法，之後將元素的索引賦給elementData[size]，而後size自增。例如初次添加時，size爲0，add將elementData[0]賦值爲e，然後size設置爲1（類似執行以下兩條語句elementData[0]=e;size=1）。將元素的索引賦給elementData[size]不是會出現數組越界的情況嗎？這裏關鍵就在ensureCapacity(size+1)中了。
根據ensureCapacity的方法名可以知道是確保容量用的。ensureCapacity(size+1)後面的註釋可以明白是增加modCount的值（加了倆感嘆號，應該蠻重要的，來看看）。
-
-
-
-
-
-
-
-
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 = Arrays.copyOf(elementData, newCapacity);
-
}
-
}
The number of times this list has been structurally modified.
這是對modCount的解釋，意爲記錄list結構被改變的次數（觀察源碼可以發現每次調用ensureCapacoty方法，modCount的值都將增加，但未必數組結構會改變，所以感覺對modCount的解釋不是很到位）。
增加modCount之後，判斷minCapacity（即size+1）是否大於oldCapacity（即elementData.length），若大於，則調整容量爲max((oldCapacity*3)/2+1,minCapacity)，調整elementData容量爲新的容量，即將返回一個內容爲原數組元素，大小爲新容量的數組賦給elementData；否則不做操作。
所以調用ensureCapacity至少將elementData的容量增加的1，所以elementData[size]不會出現越界的情況。
容量的拓展將導致數組元素的複製，多次拓展容量將執行多次整個數組內容的複製。若提前能大致判斷list的長度，調用ensureCapacity調整容量，將有效的提高運行速度。
可以理解提前分配好空間可以提高運行速度，但是測試發現提高的並不是很大，而且若list原本數據量就不會很大效果將更不明顯。
add(int index, E element)
add(int index,E element)在指定位置插入元素。
-
public void add(int index, E element) {
-
if (index > size || index < 0)
-
throw new IndexOutOfBoundsException(
-
"Index: "+index+", Size: "+size);
-
-
ensureCapacity(size+1);
-
System.arraycopy(elementData, index, elementData, index + 1,
-
size - index);
-
elementData[index] = element;
-
size++;
-
}
首先判斷指定位置index是否超出elementData的界限，之後調用ensureCapacity調整容量（若容量足夠則不會拓展），調用System.arraycopy將elementData從index開始的size-index個元素複製到index+1至size+1的位置（即index開始的元素都向後移動一個位置），然後將index位置的值指向element。
addAll(Collection<? extends E> c)
-
public boolean addAll(Collection<? extends E> c) {
-
Object[] a = c.toArray();
-
int numNew = a.length;
-
ensureCapacity(size + numNew);
-
System.arraycopy(a, 0, elementData, size, numNew);
-
size += numNew;
-
return numNew != 0;
-
}
先將集合c轉換成數組，根據轉換後數組的程度和ArrayList的size拓展容量，之後調用System.arraycopy方法複製元素到elementData的尾部，調整size。根據返回的內容分析，只要集合c的大小不爲空，即轉換後的數組長度不爲0則返回true。
addAll(int index,Collection<? extends E> c)
-
public boolean addAll(int index, Collection<? extends E> c) {
-
if (index > size || index < 0)
-
throw new IndexOutOfBoundsException(
-
"Index: " + index + ", Size: " + size);
-
-
Object[] a = c.toArray();
-
int numNew = a.length;
-
ensureCapacity(size + numNew);
-
-
int numMoved = size - index;
-
if (numMoved > 0)
-
System.arraycopy(elementData, index, elementData, index + numNew,
-
numMoved);
-
-
System.arraycopy(a, 0, elementData, index, numNew);
-
size += numNew;
-
return numNew != 0;
-
}
先判斷index是否越界。其他內容與addAll(Collection<? extends E> c)基本一致，只是複製的時候先將index開始的元素向後移動X（c轉爲數組後的長度）個位置（也是一個複製的過程），之後將數組內容複製到elementData的index位置至index+X。
clear()
-
public void clear() {
-
modCount++;
-
-
-
for (int i = 0; i < size; i++)
-
elementData[i] = null;
-
-
size = 0;
-
}
clear的時候並沒有修改elementData的長度（好不容易申請、拓展來的，憑什麼釋放，留着搞不好還有用呢。這使得確定不再修改list內容之後最好調用trimToSize來釋放掉一些空間），只是將所有元素置爲null，size設置爲0。
clone()
返回此 ArrayList 實例的淺表副本。（不復制這些元素本身。）
-
public Object clone() {
-
try {
-
ArrayList<E> v = (ArrayList<E>) super.clone();
-
v.elementData = Arrays.copyOf(elementData, size);
-
v.modCount = 0;
-
return v;
-
} catch (CloneNotSupportedException e) {
-
-
throw new InternalError();
-
}
-
}
調用父類的clone方法返回一個對象的副本，將返回對象的elementData數組的內容賦值爲原對象elementData數組的內容，將副本的modCount設置爲0。
contains(Object)
-
public boolean contains(Object o) {
-
return indexOf(o) >= 0;
-
}
indexOf方法返回值與0比較來判斷對象是否在list中。接着看indexOf。
indexOf(Object)
-
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;
-
}
通過遍歷elementData數組來判斷對象是否在list中，若存在，返回index（[0,size-1]），若不存在則返回-1。所以contains方法可以通過indexOf(Object)方法的返回值來判斷對象是否被包含在list中。
既然看了indexOf(Object)方法，接着就看lastIndexOf，光看名字應該就明白了返回的是傳入對象在elementData數組中最後出現的index值。
-
public int lastIndexOf(Object o) {
-
if (o == 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 (o.equals(elementData[i]))
-
return i;
-
}
-
return -1;
-
}
採用了從後向前遍歷element數組，若遇到Object則返回index值，若沒有遇到，返回-1。
get(int index)
這個方法看着很簡單，應該是返回elementData[index]就完了。
-
public E get(int index) {
-
RangeCheck(index);
-
-
return (E) elementData[index];
-
}
但看代碼的時候看到調用了RangeCheck方法，而且還是大寫的方法，看看究竟有什麼內容吧。
-
-
-
-
private void RangeCheck(int index) {
-
if (index >= size)
-
throw new IndexOutOfBoundsException(
-
"Index: "+index+", Size: "+size);
-
}
就是檢查一下是不是超出數組界限了，超出了就拋出IndexOutBoundsException異常。爲什麼要大寫呢？？？
isEmpty()
直接返回size是否等於0。
remove(int index)
-
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;
-
return oldValue;
-
}
首先是檢查範圍，修改modCount，保留將要被移除的元素，將移除位置之後的元素向前挪動一個位置，將list末尾元素置空（null），返回被移除的元素。
remove(Object o)
-
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;
-
}
首先通過代碼可以看到，當移除成功後返回true，否則返回false。remove(Object o)中通過遍歷element尋找是否存在傳入對象，一旦找到就調用fastRemove移除對象。爲什麼找到了元素就知道了index，不通過remove(index)來移除元素呢？因爲fastRemove跳過了判斷邊界的處理，因爲找到元素就相當於確定了index不會超過邊界，而且fastRemove並不返回被移除的元素。下面是fastRemove的代碼，基本和remove(index)一致。
-
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;
-
}
removeRange(int fromIndex,int toIndex)
-
protected void removeRange(int fromIndex, int toIndex) {
-
modCount++;
-
int numMoved = size - toIndex;
-
System.arraycopy(elementData, toIndex, elementData, fromIndex,
-
numMoved);
-
-
-
int newSize = size - (toIndex-fromIndex);
-
while (size != newSize)
-
elementData[--size] = null;
-
}
執行過程是將elementData從toIndex位置開始的元素向前移動到fromIndex，然後將toIndex位置之後的元素全部置空順便修改size。
這個方法是protected，及受保護的方法，爲什麼這個方法被定義爲protected呢？
這是一個解釋，但是可能不容易看明白。http://stackoverflow.com/questions/2289183/why-is-javas-abstractlists-removerange-method-protected
先看下面這個例子
-
ArrayList<Integer> ints = new ArrayList<Integer>(Arrays.asList(0, 1, 2,
-
3, 4, 5, 6));
-
-
-
ints.subList(2, 4).clear();
-
System.out.println(ints);
輸出結果是[0,
1, 4, 5, 6]，結果是不是像調用了removeRange(int fromIndex,int toIndex)！哈哈哈，就是這樣的。但是爲什麼效果相同呢？是不是調用了removeRange(int fromIndex,int toIndex)呢？
set(int index,E element)
-
public E set(int index, E element) {
-
RangeCheck(index);
-
-
E oldValue = (E) elementData[index];
-
elementData[index] = element;
-
return oldValue;
-
}
首先檢查範圍，用新元素替換舊元素並返回舊元素。
size()
size()方法直接返回size。
toArray()
-
public Object[] toArray() {
-
return Arrays.copyOf(elementData, size);
-
}
調用Arrays.copyOf將返回一個數組，數組內容是size個elementData的元素，即拷貝elementData從0至size-1位置的元素到新數組並返回。
toArray(T[] a)
-
public <T> T[] toArray(T[] a) {
-
if (a.length < size)
-
-
return (T[]) Arrays.copyOf(elementData, size, a.getClass());
-
System.arraycopy(elementData, 0, a, 0, size);
-
if (a.length > size)
-
a[size] = null;
-
return a;
-
}
如果傳入數組的長度小於size，返回一個新的數組，大小爲size，類型與傳入數組相同。所傳入數組長度與size相等，則將elementData複製到傳入數組中並返回傳入的數組。若傳入數組長度大於size，除了複製elementData外，還將把返回數組的第size個元素置爲空。
trimToSize()
-
public void trimToSize() {
-
modCount++;
-
int oldCapacity = elementData.length;
-
if (size < oldCapacity) {
-
elementData = Arrays.copyOf(elementData, size);
-
}
-
}
由於elementData的長度會被拓展，size標記的是其中包含的元素的個數。所以會出現size很小但elementData.length很大的情況，將出現空間的浪費。trimToSize將返回一個新的數組給elementData，元素內容保持不變，length很size相同，節省空間。
學習Java最好的方式還必須是讀源碼。讀完源碼你纔會發現這東西爲什麼是這麼玩的，有哪些限制，關鍵點在哪裏等等。而且這些源碼都是大牛們寫的，你能從中學習到很多。
下面說說ArrayList與LinkedList的區別：
1.ArrayList是實現了基於動態數組的數據結構，LinkedList基於鏈表的數據結構。
2.對於隨機訪問get和set，ArrayList覺得優於LinkedList，因爲LinkedList要移動指針。
3.對於新增和刪除操作add和remove，LinedList比較佔優勢，因爲ArrayList要移動數據。
ArrayList和LinkedList在性能上各有優缺點，都有各自所適用的地方，總的說來可以描述如下：
1．對ArrayList和LinkedList而言，在列表末尾增加一個元素所花的開銷都是固定的。對ArrayList而言，主要是在內部數組中增加一項，指向所添加的元素，偶爾可能會導致對數組重新進行分配；而對LinkedList而言，這個開銷是統一的，分配一個內部Entry對象。
2．在ArrayList的中間插入或刪除一個元素意味着這個列表中剩餘的元素都會被移動；而在LinkedList的中間插入或刪除一個元素的開銷是固定的。
3．LinkedList不支持高效的隨機元素訪問。
4．ArrayList的空間浪費主要體現在在list列表的結尾預留一定的容量空間，而LinkedList的空間花費則體現在它的每一個元素都需要消耗相當的空間
相關鏈接：
http://blog.csdn.net/jzhf2012/article/details/8540410
http://pengcqu.iteye.com/blog/502676
