ArrayList
ArrayList是List介面的 可變陣列的實現。實現了所有可選列表操作，並允許包括 null 在內的所有元素。除了實現 List介面外，此類還提供一些方法來操作內部用來儲存列表的陣列的大小。ArrayList繼承自 AbstractList<E>，這是一個抽象類對一些基礎的list操作做了一些封裝.實現了RandomAccess 標記介面，表明可以實現快速隨機訪問.實現了Cloneable介面的實現表示該容器具有Clone函式操作，Serializable是序列化。
每個ArrayList例項都有一個容量，該容量是指用來儲存列表元素的陣列的大小。它總是至少等於列表的大小。隨著向ArrayList中不斷新增元素，其容量也自動增長。自動增長會帶來資料向新陣列的重新拷貝，因此，如果可預知資料量的大小，就可在構造ArrayList例項時指定其容量。
在新增大量元素前，應用程式也可以使用ensureCapacity操作來增加ArrayList例項的容量，這可以減少遞增式再分配的數量。
注意，此實現不是同步的。如果多個執行緒同時訪問一個ArrayList例項，而其中至少一個執行緒從結構上修改了列表，那麼它必須保持外部同步。
ArrayList這個資料結構比較簡單，總體來說，ArrayList底層結構是陣列，他的很多方法都是從陣列上面演變而來的。
下面我們先來看一下ArrayList中的一些初始值
//通過ArrayList實現的介面可知，其支援隨機訪問，能被克隆，支援序列化
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable
{
//序列版本號
private static final long serialVersionUID = 8683452581122892189L;
//預設初始容量
private static final int DEFAULT_CAPACITY = 10;
//空例項的共享空陣列例項
private static final Object[] EMPTY_ELEMENTDATA = {};
//被用於預設大小的空例項的共享陣列例項。
//與EMPTY_ELEMENTDA他的區別是：當我們向陣列中新增第一個元素時，知道陣列該擴充多少。
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/**
* Object[]型別的陣列，儲存了新增到ArrayList中的元素。ArrayList的容量是該Object[]型別陣列的長度
* 當第一個元素被新增時，任何空ArrayList中的elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA將會被
* 擴充到DEFAULT_CAPACITY（預設容量）。
*/
transient Object[] elementData; //沒有被私有化是為了簡化內部類訪問
// ArrayList的大小（指其所含的元素個數）
private int size;
// 記錄被修改的次數
protected transient int modCount = 0;
// 陣列的最大值
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8
}elementData 是”Object[] 型別的陣列”，它儲存了新增到ArrayList中的元素。實際上，elementData是個動態陣列，我們能通過建構函式 ArrayList(intinitialCapacity)來執行它的初始容量為initialCapacity；如果通過不含引數的建構函式ArrayList()來建立ArrayList，則elementData的容量預設是10。elementData陣列的大小會根據ArrayList容量的增長而動態的增長，具體的增長方式請看這裡
建構函式
ArrayList提供了三種方式的構造器。可以構造一個預設初始容量為10的空列表、構造一個指定初始容量的空列表以及構造一個包含指定collection的元素的列表。
這些元素按照該collection的迭代器返回的順序排列的。
// 構造一個指定初始容量的空列表
public ArrayList(int initialCapacity) {
if (initialCapacity > 0) {
this.elementData = new Object[initialCapacity];
} else if (initialCapacity == 0) {
this.elementData = EMPTY_ELEMENTDATA;
} else { // 如果給定的初始容量為負值
throw new IllegalArgumentException("Illegal Capacity: "+
initialCapacity);
}
}
// 構造一個預設初始容量為10的空列表
public ArrayList() { //這裡並沒有初始化，jdk 1.8之後是在進行add操作後初始化
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
// 構造一個包含指定collection的元素的列表，這些元素按照該collection的迭代器返回的順序排列的
public ArrayList(Collection<? extends E> c) {
elementData = c.toArray();
if ((size = elementData.length) != 0) {
// c.toArray()可能不會正確地返回一個 Object[]陣列，那麼使用Arrays.copyOf()方法
if (elementData.getClass() != Object[].class)
elementData = Arrays.copyOf(elementData, size, Object[].class);
} else { // 如果指定的collection為空
this.elementData = EMPTY_ELEMENTDATA;
}
}使用無參構造器，預設初始容量為什麼是10？
1) 初始時：this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {}; size = 0;
2) 向陣列中新增第一個元素時，add(E e)方法中呼叫了ensureCapacityInternal(size + 1)方法，即ensureCapacityInternal(1)；
3) 在ensureCapacityInternal(int minCapacity)方法中，minCapacity=DEFAULT_CAPACITY=10，然後再呼叫ensureExplicitCapacity(minCapacity)方法，即ensureExplicitCapacity(10)；
4) 在ensureExplicitCapacity(minCapacity)方法中呼叫grow(minCapacity)方法，即grow(10)，此處為真正具體的陣列擴容的演算法，在此方法中，通過elementData = Arrays.copyOf(elementData, 10)具體實現了elementData陣列初始容量為10的構造。
新增元素
// 在陣列末尾加上一個元素
public boolean add(E e) {
ensureCapacityInternal(size + 1); // 進行擴容檢查
elementData[size++] = e;
return true;
}
// 在陣列的指定位置新增元素
public void add(int index, E element) {
rangeCheckForAdd(index); // 檢查index是否越界
ensureCapacityInternal(size + 1); // 進行擴容檢查
// 對資料進行復制操作，空出index位置，並插入element，將源陣列中從index位置開始後的size-index個元素統一後移一位
System.arraycopy(elementData, index, elementData, index + 1,
size - index);
elementData[index] = element;
size++; // 元素個數加1
}
// 按照指定collection集合的迭代器所返回的元素順序，將該collection中的所有元素新增到列表的尾部
public boolean addAll(Collection<? extends E> c) {
Object[] a = c.toArray(); // 將collection轉換為陣列型別
int numNew = a.length; // collection中的元素個數
ensureCapacityInternal(size + numNew); // 進行擴容檢查
System.arraycopy(a, 0, elementData, size, numNew); // 將陣列a[0,...,numNew-1]複製到陣列elementData[size,...,size+numNew-1]
size += numNew;
return numNew != 0;
}
// 按照指定collection集合的迭代器所返回的元素順序，將該collection中的所有元素新增到列表的指定位置
public boolean addAll(int index, Collection<? extends E> c) {
rangeCheckForAdd(index); // 檢查index是否越界
Object[] a = c.toArray();
int numNew = a.length;
ensureCapacityInternal(size + numNew); // 進行擴容檢查
// 將陣列elementData[index,...,index+numMoved-1]複製到elementData[index+numMoved,...,index+2*numMoved-1]
//將源陣列中從index位置開始的後numMoved個元素統一後移numNew位
int numMoved = size - index;
if (numMoved > 0)
System.arraycopy(elementData, index, elementData, index + numNew,
numMoved);
// 將陣列a[0,...,numNew-1]複製到陣列elementData[index,...,index+numNew-1]完成資料的插入
System.arraycopy(a, 0, elementData, index, numNew);
size += numNew;
return numNew != 0;
}擴容相關
// 用於自定義設定ArrayList的容量
public void ensureCapacity(int minCapacity) {
int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
? 0
: DEFAULT_CAPACITY;
if (minCapacity > minExpand) {
ensureExplicitCapacity(minCapacity);
}
}
// 進行擴容檢查
private void ensureCapacityInternal(int minCapacity) {
//第一次add操作初始化，如果為空ArrayList，那麼初始化容量為10
if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
}
//判斷是否需要擴容
ensureExplicitCapacity(minCapacity);
}
//判斷是否需要擴容
private void ensureExplicitCapacity(int minCapacity) {
//modCount這個引數運用到了 fail-fast 機制
modCount++;
if (minCapacity - elementData.length > 0)
grow(minCapacity); // 擴容
}
// 擴容
private void grow(int minCapacity) {
int oldCapacity = elementData.length;
//newCapacity為以前的1.5倍
int newCapacity = oldCapacity + (oldCapacity >> 1);
if (newCapacity - minCapacity < 0)
newCapacity = minCapacity;
//判斷容量是否到達long int 最大臨界值
if (newCapacity - MAX_ARRAY_SIZE > 0)
newCapacity = hugeCapacity(minCapacity);
// 對陣列進行復制處理
elementData = Arrays.copyOf(elementData, newCapacity);
}
// 檢查是否超過最大容量 0x7fffffff ，是否丟擲異常
private static int hugeCapacity(int minCapacity) {
if (minCapacity < 0) // overflow
throw new OutOfMemoryError();
return (minCapacity > MAX_ARRAY_SIZE) ?
Integer.MAX_VALUE :
MAX_ARRAY_SIZE;
}刪除元素
// 刪除指定位置的元素
public E remove(int index) {
rangeCheck(index); //陣列越界檢查
modCount++;
E oldValue = elementData(index);
int numMoved = size - index - 1; //計算陣列需要複製的數量
if (numMoved > 0) //將index後的資料都向前移一位
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size] = null; //help GC
return oldValue;
}
// 刪除指定內容的元素（只刪除第一個匹配成功的）
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;
}
//找到對應的元素後，刪除。刪除元素後的元素都向前移動一位
private void fastRemove(int index) {
modCount++;
int numMoved = size - index - 1;
if (numMoved > 0) // 將index後面的元素整體向前移動一位
System.arraycopy(elementData, index+1, elementData, index,
numMoved);
elementData[--size] = null; // help GC
}
//清空ArrayList，將全部的元素設為null
public void clear() {
modCount++;
for (int i = 0; i < size; i++) // help GC
elementData[i] = null;
size = 0;
}
//刪除ArrayList中從fromIndex到toIndex（區間--左閉右開）之間所有的元素
protected void removeRange(int fromIndex, int toIndex) {
modCount++;
int numMoved = size - toIndex; //需向前移動的元素的個數
System.arraycopy(elementData, toIndex, elementData, fromIndex,
numMoved);
// help GC
int newSize = size - (toIndex-fromIndex);
for (int i = newSize; i < size; i++) {
elementData[i] = null;
}
size = newSize;
}
//刪除ArrayList中包含在指定容器c中的所有元素
public boolean removeAll(Collection<?> c) {
Objects.requireNonNull(c); //檢查指定的物件c是否為空
return batchRemove(c, false);
}
//移除ArrayList中不包含在指定容器c中的所有元素，與removeAll(Collection<?> c)正好相反
public boolean retainAll(Collection<?> c) {
Objects.requireNonNull(c); //檢查指定的物件c是否為空
return batchRemove(c, true);
}
// 根據complement的值刪除元素
private boolean batchRemove(Collection<?> c, boolean complement) {
final Object[] elementData = this.elementData;
int r = 0, w = 0; //讀寫雙指標 w是重新存元素時的索引，r是原來的索引
boolean modified = false;
try {
//遍歷陣列，並檢查這個集合是否包含對應的值，移動要保留的值到陣列前面，w最後值為要保留的元素的數量
//簡單點：若保留，就將相同元素移動到前段；若刪除，就將不同元素移動到前段
for (; r < size; r++)
if (c.contains(elementData[r]) == complement) //判斷指定容器c中是否含有elementData[r]元素
elementData[w++] = elementData[r];
}finally {//確保異常丟擲前的部分可以完成期望的操作，而未被遍歷的部分會被接到後面
//r!=size表示可能出錯了：c.contains(elementData[r])丟擲異常
if (r != size) {
System.arraycopy(elementData, r,elementData, w,size - r);
w += size - r;
}
//如果w==size：表示全部元素都保留了，所以也就沒有刪除操作發生，所以會返回false；反之，返回true，並更改陣列
//而w!=size的時候，即使try塊丟擲異常，也能正確處理異常丟擲前的操作，因為w始終為要保留的前段部分的長度，陣列也不會因此亂序
if (w != size) {
for (int i = w; i < size; i++)
elementData[i] = null;
modCount += size - w;//改變的次數
size = w; //新的大小為保留的元素的個數
modified = true;
}
}
return modified;
}removeAll和retainAll方法：實現刪除或保留ArrayList中包含Collection c中的的元素。
這兩個方法都用到batchRemove方法（boolean complement使得batchRemove方法得到了重用）
下面以removeAll為例，分析batchRemove(c, false)
遍歷elementData
如果集合c中包含elementData的元素e，則c.contains(elementData[r])為true，if不成立，if結束；如果c不包含elementData的元素e，則if成立，將此元素e賦值給elementData[w++] （即elementData保留了c中沒有的元素，也就是刪除了c中存在的所有元素。）
執行finally
finally是不管try中結果如何都會執行的。if(r!=size)，則將elementData未參加比較的元素arraycopy到elementData後面；新索引w加上剛arraycopy的數目；if (w != size)，此時w還不等於size，則將w後的元素移除.只有執行了if (w != size)（事實上只要c中含有elementData的元素，w肯定不等於size），才令modified = true，才說明remove成功，返回true，否則返回false。
ArrayList中還有一個用於節約陣列記憶體空間，縮小容量的方法
// 因為容量常常會大於實際元素的數量。記憶體緊張時，可以呼叫該方法刪除預留的位置，調整容量為元素實際數量。
// 如果確定不會再有元素新增進來時也可以呼叫該方法來節約空間
public void trimToSize() {
modCount++;
// length是陣列長度，size表示陣列內元素個數
// size<length那麼就說明陣列內有空元素，進行縮小容量操作
if (size < elementData.length) {
elementData = (size == 0) ? EMPTY_ELEMENTDATA : Arrays.copyOf(elementData, size);
}
}去掉預留元素的位置。返回一個新陣列，新陣列不含null，陣列的size和elementData.length相等，以節省空間。此函式可避免size很小但elementData.length很大的情況。
ArrayList會每次增長會預申請多一點空間，1.5倍，這樣就會出現當size() = 10的時候，ArrayList已經申請了15空間， trimToSize就是刪除多餘的5，只留10。
或許有人會有疑問：
呼叫Arrays.copyOf複製size長度的元素到elementData，而且由原始碼看應該是從0複製到size處，那麼如果我之前呼叫過add(int index, E element)呢？比如，list={1，2，3，null，null，4，null，null}，如果呼叫trimToSize返回的應該是list={1，2，3，null}（因為size=4）。其實上面這種情況不會發生的，因為呼叫add(int index, E element)時，會檢查index的合法性，所以list的元素肯定是相鄰的，而不會出現上述這種中間出現null的情況。
修改元素
// 將指定位置的元素改為指定的值
public E set(int index, E element) {
rangeCheck(index); // 檢查index是否越界
E oldValue = elementData(index);
elementData[index] = element;
return oldValue;
}查詢元素
//判斷ArrayList中是否包含Object(o)
public boolean contains(Object o) {
return indexOf(o) >= 0;
}
//返回一個值在陣列首次出現的位置，會根據是否為null使用不同方式判斷。不存在就返回-1。時間複雜度為O(N)
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;
}
//返回一個值在陣列最後一次出現的位置，不存在就返回-1。時間複雜度為O(N)
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;
}
//返回指定位置的值，因為是陣列，所以速度特別快
@SuppressWarnings("unchecked")
E elementData(int index) {
return (E) elementData[index];
}
//返回指定位置的值，但是會檢查這個位置數否超出陣列長度
public E get(int index) {
rangeCheck(index);
return elementData(index); //實質上return (E) elementData[index]
}序列化
//儲存陣列例項的狀態到一個流（即它序列化）。寫入過程陣列被更改會丟擲異常
private void writeObject(java.io.ObjectOutputStream s) throws java.io.IOException{
int expectedModCount = modCount;
s.defaultWriteObject(); //執行預設的反序列化/序列化過程。將當前類的非靜態和非瞬態欄位寫入此流
// 寫入大小
s.writeInt(size);
// 按順序寫入所有元素
for (int i=0; i<size; i++) {
s.writeObject(elementData[i]);
}
if (modCount != expectedModCount) {
throw new ConcurrentModificationException();
}
}
//上面是寫，這個就是讀了。
private void readObject(java.io.ObjectInputStream s) throws java.io.IOException, ClassNotFoundException {
elementData = EMPTY_ELEMENTDATA;
// 執行預設的序列化/反序列化過程
s.defaultReadObject();
// 讀入陣列長度
s.readInt();
if (size > 0) {
ensureCapacityInternal(size);
Object[] a = elementData;
//讀入所有元素
for (int i=0; i<size; i++) {
a[i] = s.readObject();
}
}
}為什麼要自定義序列化、反序列化機制呢？
由於ArrayList實質上是一個動態陣列，往往陣列中會有空餘的空間，如果採用預設的序列化機制，那些空餘的空間會作為null寫入本地檔案或者在網路中傳輸，耗費了不必要的資源。所以，ArrayList使用自定義序列化機制，僅寫入索引為【0，size）的有效元素以節省資源
迭代器
//返回ListIterator，開始位置為指定引數
public ListIterator<E> listIterator(int index) {
if (index < 0 || index > size)
throw new IndexOutOfBoundsException("Index: "+index);
return new ListItr(index);
}
//返回ListIterator，開始位置為0
public ListIterator<E> listIterator() {
return new ListItr(0);
}
//返回普通迭代器
public Iterator<E> iterator() {
return new Itr();
}
//通用的迭代器實現
private class Itr implements Iterator<E> {
int cursor; //遊標，下一個元素的索引，預設初始化為0
int lastRet = -1; //上次訪問的元素的位置
int expectedModCount = modCount;//迭代過程不允許修改陣列，否則就丟擲異常
//是否還有下一個
public boolean hasNext() {
return cursor != size;
}
//下一個元素
@SuppressWarnings("unchecked")
public E next() {
checkForComodification();//檢查陣列是否被修改
int i = cursor;
if (i >= size)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i + 1; //向後移動遊標
return (E) elementData[lastRet = i]; //設定訪問的位置並返回這個值
}
//刪除元素
public void remove() {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();//檢查陣列是否被修改
try {
ArrayList.this.remove(lastRet);
cursor = lastRet;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
@Override
@SuppressWarnings("unchecked")
public void forEachRemaining(Consumer<? super E> consumer) {
Objects.requireNonNull(consumer);
final int size = ArrayList.this.size;
int i = cursor;
if (i >= size) {
return;
}
final Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length) {
throw new ConcurrentModificationException();
}
while (i != size && modCount == expectedModCount) {
consumer.accept((E) elementData[i++]);
}
cursor = i;
lastRet = i - 1;
checkForComodification();
}
//檢查陣列是否被修改
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
//ListIterator迭代器實現
private class ListItr extends Itr implements ListIterator<E> {
ListItr(int index) {
super();
cursor = index;
}
public boolean hasPrevious() {
return cursor != 0;
}
public int nextIndex() {
return cursor;
}
public int previousIndex() {
return cursor - 1;
}
@SuppressWarnings("unchecked")
public E previous() {
checkForComodification();
int i = cursor - 1;
if (i < 0)
throw new NoSuchElementException();
Object[] elementData = ArrayList.this.elementData;
if (i >= elementData.length)
throw new ConcurrentModificationException();
cursor = i;
return (E) elementData[lastRet = i];
}
public void set(E e) {
if (lastRet < 0)
throw new IllegalStateException();
checkForComodification();
try {
ArrayList.this.set(lastRet, e);
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
public void add(E e) {
checkForComodification();
try {
int i = cursor;
ArrayList.this.add(i, e);
cursor = i + 1;
lastRet = -1;
expectedModCount = modCount;
} catch (IndexOutOfBoundsException ex) {
throw new ConcurrentModificationException();
}
}
}Iterator與ListIterator的區別：
- Iterator可以應用於所有的集合，Set、List和Map和這些集合的子型別。而ListIterator只能用於List及其子型別；
- Iterator只能實現順序向後遍歷，ListIterator可實現順序向後遍歷和逆向（順序向前）遍歷；
- Iterator只能實現remove操作，ListIterator可以實現remove操作，add操作，set操作。
其他方法
//返回ArrayList的大小（元素個數）
public int size() {
return size;
}
//判斷ArrayList是否為空
public boolean isEmpty() {
return size == 0;
}
//返回此 ArrayList例項的淺拷貝（元素本身沒有被複制，複製過程陣列發生改變會丟擲異常）
public Object clone() {
try {
ArrayList<?> v = (ArrayList<?>) super.clone();
v.elementData = Arrays.copyOf(elementData, size);
v.modCount = 0;
return v;
} catch (CloneNotSupportedException e) {
throw new InternalError(e);
}
}
/*
淺克隆就是我們所看到的Arrays.copyOf， System.arraycopy，陣列是新的，但是裡面N個元素全是引用的舊的。
淺拷貝(影子克隆):只複製基本型別。
深拷貝(深度克隆):基本類+物件。
*/
//返回一個包含ArrayList中所有元素的陣列
public Object[] toArray() {
return Arrays.copyOf(elementData, size);
}
// 返回一個陣列，使用執行時確定型別，該陣列包含在這個列表中的所有元素（從第一到最後一個元素）
// 返回的陣列容量由引數和本陣列中較大值確定
@SuppressWarnings("unchecked")
public <T> T[] toArray(T[] a) {
if (a.length < size)
// Make a new array of a`s runtime type, but my contents:
return (T[]) Arrays.copyOf(elementData, size, a.getClass());
System.arraycopy(elementData, 0, a, 0, size);
if (a.length > size)
a[size] = null;
return a;
}ArrayList相關問題
Integer.MAX_VALUE – 8 這裡為什麼要減去8？
主要是考慮到不同的JVM,有的VM會在加入一些資料頭,當擴容後的容量大於MAX_ARRAY_SIZE,我們會去比較最小需要容量和MAX_ARRAY_SIZE做比較,如果比它大, 只能取Integer.MAX_VALUE,否則是Integer.MAX_VALUE -8。
這個是從jdk1.7開始才有的
jdk1.8的無參建構函式和之前版本的建構函式有什麼區別?
jdk1.6
public ArrayList() {
this(10);
}
jdk1.7
public ArrayList() {
super();
this.elementData = EMPTY_ELEMENTDATA;
}
jdk1.8
public ArrayList() {
this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
} 對比下可以看出：jdk1.6的無參構造方法（預設構造方法）構造的ArrayList的底層陣列elementData大小（容量）預設為10；從1.7開始，無參構造方法構造的ArrayList的底層陣列elementData大小預設為0。
java集合類在jdk1.7版本基本上都有一種改動：懶初始化。懶初始化指的是預設構造方法構造的集合類，佔據儘可能少的記憶體空間（對於ArrayList來說，使用空陣列來佔據儘量少的空間，不使用null是為了避免null判斷），在第一次進行包含有新增語義的操作時，才進行真正的初始化工作。
1.7開始的ArrayList，預設構造方法構造的例項，底層陣列是空陣列，容量為0，在進行第一次add/addAll等操作時才會真正給底層陣列賦非empty的值。如果add/addAll新增的元素小於10，則把elementData陣列擴容為10個元素大小，否則使用剛好合適的大小（例如，第一次addAll新增6個，那麼擴容為10個，第一次新增大於10個的，比如24個，擴容為24個，剛好合適）
1.8版本，預設構造的例項這個行為沒有改變，只是用的陣列名字變了。
jdk1.6中擴容演算法的缺陷
（由於jdk1.7和jdk1.8在擴容演算法方面差別不大，所以下面沒有嚴格區分）
jdk1.6
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);
}
} 從上面的程式碼可以看出jdk1.6的ensureCapacity方法只是簡單進行了邏輯上的操作，沒有過多考慮int型溢位的問題，從1.7開始對這個進行了完善。
而且沒考慮入參minCapacity可能因為int溢位變為負數。這個方法可以外部手動呼叫，手動擴容傳入負數這個肯定是應該攔截掉的。但是自動擴容會因為int溢位產生負數，碰到這種情況時應該特殊處理，而不是什麼都不做，等著後面丟擲一個ArrayIndexOutOfBoundsException。
還有就是下面這句程式碼會造成過早溢位
int newCapacity = (oldCapacity * 3)/2 + 1;雖然上面這行程式碼和1.7開始的oldCapacity + (oldCapacity >> 1) 差不多，都是相當於1.5倍，但實際上是有
區別的。
這裡主要有兩個區別
第一個區別是jdk1.6的乘除運算的數學結果比後面一個大1比如oldCapacity=10，1.6的
演算法得到16，1.7開始的演算法得到15，這個影響不大；
第二個區別就是兩者在數字比較大時運算結果不一樣，比如
oldCapacity=10^9，這個數和Integer.MAX_VALUE位數一樣，用1.6的演算法得到的會是錯誤的-647483647，用
1.7的則是正確的1500000000，這時候明明可以1.5倍擴容，但是jdk1.6卻用的是按需擴容。
ensureCapacity（稱之為手動，是因為此方法是public的，可以外部手動呼叫）。
在1.6版本是隻有這個手動的方法，內部自動操作也是呼叫這個方法，1.7開始進行了區分，並且進一步改進了擴容操作。
- 從1.7開始將內部擴容和外部可以呼叫的擴容方法分開了，通過原始碼可以看出：外部呼叫的手動擴容方法ensureCapacity要多一個判斷條件 minCapacity > minExpand，這個判斷條件攔截掉負數的minCapacity，這樣呼叫內部擴容ensureCapacityInternal方法時，minCapacity一定是正數；內部擴容方法直接就用minCapacity – elementData.length > 0判斷，此條件可以檢測出int型溢位，碰到溢位最後會丟擲一個OOM錯誤。jdk1.7用OOM，這比jdk1.6用ArrayIndexOutOfBoundsException更好，因為此時陣列大小超出了虛擬機器對陣列的限制，虛擬機器無法處理這種情況了，丟擲一個ERROR是合理的。
- 使用這行程式碼
newCapacity = oldCapacity + (oldCapacity >> 1);這行程式碼不僅僅是使用位運算加快執行速度，上面說了，這種做法才是對的，是真正的1.5倍。不僅僅因為那一個大小的差別，更重要的是避免過早出現int溢位的情況，保證了內部自動擴容會盡量按規定的策略執行。同時整個擴容處理流程中多增加了幾處if判斷，對各種情況處理更加完善。
為什麼ArrayList自動容量擴充選擇擴充1.5倍？
這種演算法構造出來的新的陣列長度的增量都會比上一次大( 而且是越來越大) ，避免頻繁newInstance 的情況。
為什麼ArrayList 不適合頻繁插入和刪除操作？
由上面分析的增加刪除方法可以看出在ArrayList中經常會呼叫 System.arraycopy 這個效率很低的操作來複制陣列，所以導致ArrayList在插入和刪除操作中效率不高。