ArrayList是java集合框架中比較常用的資料結構，其實底層就是一個陣列的操作實現，但是這個陣列呢可以實現容量大小的動態變化，這就是比較特別的地方吧。另外ArrayList不是執行緒安全的。

框架結構

從圖中可以看出ArrayList類繼承了AbstractList類，實現了List、RandomAccess、Serialzable、Cloneable介面

實現RandomAccess介面：可以通過下標序號快速訪問

實現了Cloneable，能被克隆

實現了Serializable，支援序列化
複製程式碼

成員變數

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 = {};
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
    transient Object[] elementData; // non-private to simplify nested class access
    private int size;
...
}
複製程式碼

• DEFAULT_CAPACITY預設容量是10
• EMPTY_ELEMENTDATA 空集合
• DEFAULTCAPACITY_EMPTY_ELEMENTDATA 預設空集合 （與EMPTY_ELEMENTDATA有點區別，在不同的建構函式中用到），第一個元素新增時會擴容成預設容量10
• elementData真正存放資料的地方
• size 陣列元素個數

建構函式

/**
 * Constructs an empty list with the specified initial capacity.
 *
 * @param  initialCapacity  the initial capacity of the list
 * @throws IllegalArgumentException if the specified initial capacity
 *         is negative
 */
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);
    }
}
複製程式碼

指定初始化長度，當然這個初始化容量長度不能小於0，如果等於0，則賦一個空集合EMPTY_ELEMENTDATA。

   /**
 * Constructs an empty list with an initial capacity of ten.
 */
public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
複製程式碼

這是最常用的預設構造方法，其中使用預設的初始容量大小10，並賦予一個空陣列DEFAULTCAPACITY_EMPTY_ELEMENTDATA。

 /**
 * Constructs a list containing the elements of the specified
 * collection, in the order they are returned by the collection's
 * iterator.
 *
 * @param c the collection whose elements are to be placed into this list
 * @throws NullPointerException if the specified collection is null
 */
public ArrayList(Collection<? extends E> c) {
    elementData = c.toArray();
    if ((size = elementData.length) != 0) {
        // c.toArray might (incorrectly) not return Object[] (see 6260652)
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        // replace with empty array.
        this.elementData = EMPTY_ELEMENTDATA;
    }
}
複製程式碼

使用已有集合來建立ArraList，將集合裡的值複製到ArrayList中。首先把集合轉換成陣列，然後判斷轉換的陣列型別是否為Obejct[]型別，如果是則將陣列的值拷貝到list中，否則或者容量為0，則賦予一個空陣列

常用的操作

新增操作

     public boolean add(E e) {
       ensureCapacityInternal(size + 1);  // Increments modCount!!
       //擴容之後再新增元素
       elementData[size++] = e;
       return true;
      }


     private void ensureCapacityInternal(int minCapacity) {
      ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
   }
    
    //計算容量
    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
         return minCapacity;
    }
    
     private void ensureExplicitCapacity(int minCapacity) {
          modCount++;

          // overflow-conscious code
           if (minCapacity - elementData.length > 0)
                 grow(minCapacity);
       }
 

    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        //新容量為原來容量的二分之三倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //新容量小於需要擴容的容量
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
            
        //新容量大於陣列能申請的最大值  MAX_ARRAY_SIZE=Integer.MAX_VALUE - 8
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        // minCapacity is usually close to size, so this is a win:
        //擴容成功移動資料
        elementData = Arrays.copyOf(elementData, newCapacity);
    }
    
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }
複製程式碼

size表示ArrayList的元素個數。在新增元素之前先要確保陣列有足夠容量。噹噹前陣列需要的空間不夠時，就需要擴容了，並且保證新容量不能比當前需要的容量小，然後調Arrays.copyOf()建立一個新的陣列並將資料拷貝到新陣列中，且把引用賦值給elementData

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++;
}
複製程式碼

指定陣列index位置新增元素。首先會檢查index是否超出陣列的範圍；然後既然要新增元素，就要保證有足夠的陣列空間；當然要在index位置插入元素，得讓index後所有的元素往後移動一位，騰出index位置設定要新增的元素。

新增元素時，都涉及到了對陣列的複製移動，用到了兩種方法

Arrays.copyOf(elementData, newCapacity);
System.arraycopy(elementData, index, elementData, index + 1,size - index);
複製程式碼

第一個方法是生成一個同樣大小的新物件，當然底層也是使用了System.arraycopy方法

public static native void arraycopy(Object src,  int  srcPos,Object dest, int destPos,int length);
複製程式碼

第二個方法是將陣列複製到指定陣列中，還可以選擇複製陣列的長度。使用arraycopy方法 自己複製自己，將陣列要放置的地方的物件移到後面去

實質上都是底層clone來的結果

刪除操作

public E remove(int index) {
    rangeCheck(index);

    modCount++;
    E oldValue = elementData(index);

    int numMoved = size - index - 1;
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    elementData[--size] = null; // clear to let GC do its work

    return oldValue;
}
複製程式碼

刪除指定位置的元素。首先也是檢查index的合法性，然後取得該位置的舊元素，計算需要移動的長度，如果需要移動的，則呼叫System.arraycopy方法將index位置後的元素所有往前移動一位，將陣列最後一位置為null，方便GC工作，最後返回被刪除的元素。

  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)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    elementData[--size] = null; // clear to let GC do its work
}
複製程式碼

刪除指定元素，這裡刪除的是陣列中第一個找到的元素。fastRemove方法移除，這裡沒有進行index範圍檢查

獲取操作

     public E get(int index) {
        rangeCheck(index);

        return elementData(index);
  }


  E elementData(int index) {
    return (E) elementData[index];
}
複製程式碼

獲取指定index位置的元素。這個實現很簡單，首先index範圍檢查，然後直接取陣列中index位置元素返回。

修改操作

  public E set(int index, E element) {
        rangeCheck(index);

        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
}
複製程式碼

修改指定位置的元素，並返回舊值

迭代器

使用集合的都知道，在for迴圈遍歷集合時不可以對集合進行刪除操作，因為刪除會導致集合大小改變，從而導致陣列遍歷時陣列下標越界，嚴重時會拋ConcurrentModificationException異常

使用迭代器遍歷刪除，執行正常

public Iterator<E> iterator() {
    return new Itr();
}

private class Itr implements Iterator<E> {
    int cursor;       // index of next element to return
    int lastRet = -1; // index of last element returned; -1 if no such
    int expectedModCount = modCount;

    Itr() {}

    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++]);
        }
        // update once at end of iteration to reduce heap write traffic
        cursor = i;
        lastRet = i - 1;
        checkForComodification();
    }

    final void checkForComodification() {
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }
}
複製程式碼

從程式碼中可以看出iterator方法返回的是一個Itr()物件。

Itr物件有三個成員變數：

cursor：代表下一個要訪問的陣列下標
lastRet：代表上一個要訪問的陣列下標
expectedModCount：代表ArrayList修改次數的期望值，初始為modeCount
複製程式碼

Itr有三個主要函式：

hasNext：實現簡單，判斷下一個要訪問的陣列下標等於陣列大小，表示遍歷到最後了
next：首先判斷 expectedModCount 和 modCount 是否相等。每呼叫一次 next 方法， cursor 和 lastRet 都會自增 1。
remove ：首先會判斷 lastRet  的值是否小於 0，然後在檢查 expectedModCount 和 modCount 是否相等。然後直接呼叫 ArrayList 的 remove 方法刪除下標為 lastRet 的元素。然後將 lastRet 賦值給 cursor ，將 lastRet 重新賦值為 -1，並將 modCount 重新賦值給 expectedModCount。
複製程式碼

remove方法弊端：

呼叫 remove 之前必須先呼叫 next。因為 remove 開始就對 lastRet 做了校驗。而 lastRet 初始化時為 -1。
next 之後只可以呼叫一次 remove。因為 remove 會將 lastRet 重新初始化為 -1
複製程式碼

總結

ArrayList是一個可以自動擴容的動態陣列。

ArrayList的預設容量大小是10

擴容為原來的1.5倍，如果1.5倍還不夠的話，直接擴容成我們所需要的容量，1.5倍或所需容量太大的話，直接擴容成Integer.MAX_VALUE或MAX_ARRAY_SIZE

擴容之後通過陣列拷貝確保元素的準確性，儘量減少擴容機制

複製和擴容使用了Arrays.copyOf和System.arraycopy方法

ArrayList查詢效率高，插入刪除操作效率相對低

size 為集合實際儲存元素個數

elementData.length 為陣列長度，表示陣列可以儲存多少個元素

如果需要邊遍歷邊 remove ，必須使用 iterator。且 remove 之前必須先 next，next 之後只能用一次 remove。