ArrayList是Java List型別的集合類中最常使用的，本文基於Java1.8，對於ArrayList的實現原理做一下詳細講解。

一、ArrayList實現原理總結

ArrayList的實現原理總結如下：

①資料儲存是基於陣列實現的，預設初始容量為10；

②新增資料時，首先需要檢查元素個數是否超過陣列容量，如果超過了則需要對陣列進行擴容；插入資料時，需要將插入點k開始到陣列末尾的資料全部向後移動一位。

③陣列的擴容是新建一個大容量（原始陣列大小+擴充容量）的陣列，然後將原始陣列資料拷貝到新陣列，然後將新陣列作為擴容之後的陣列。陣列擴容的操作代價很高，我們應該儘量減少這種操作。

④刪除資料時，需要將刪除點+1位置開始到陣列末尾的資料全部向前移動一位。

⑤獲取資料很快，根據陣列下表可以直接獲取。

二、ArrayList的實現原理詳解

（轉自：http://zhangshixi.iteye.com/blog/674856）

1. ArrayList概述：

   ArrayList是List介面的可變陣列的實現。實現了所有可選列表操作，並允許包括 null 在內的所有元素。除了實現 List 介面外，此類還提供一些方法來操作內部用來儲存列表的陣列的大小。
   每個ArrayList例項都有一個容量，該容量是指用來儲存列表元素的陣列的大小。它總是至少等於列表的大小。隨著向ArrayList中不斷新增元素，其容量也自動增長。自動增長會帶來資料向新陣列的重新拷貝，因此，如果可預知資料量的多少，可在構造ArrayList時指定其容量。在新增大量元素前，應用程式也可以使用ensureCapacity操作來增加ArrayList例項的容量，這可以減少遞增式再分配的數量。
   注意，此實現不是同步的。如果多個執行緒同時訪問一個ArrayList例項，而其中至少一個執行緒從結構上修改了列表，那麼它必須保持外部同步。

2. ArrayList的實現：

   對於ArrayList而言，它實現List介面、底層使用陣列儲存所有元素。其操作基本上是對陣列的操作。下面我們來分析ArrayList的原始碼：

   1) 底層使用陣列實現：

1. privatetransient Object[] elementData;  

    2) 構造方法：
   ArrayList提供了三種方式的構造器，可以構造一個預設初始容量為10的空列表、構造一個指定初始容量的空列表以及構造一個包含指定collection的元素的列表，這些元素按照該collection的迭代器返回它們的順序排列的。

1. public ArrayList() {  
2.     this(10);  
3. }  
4. public ArrayList(int initialCapacity) {  
5.     super();  
6.     if (initialCapacity < 0)  
7.         thrownew IllegalArgumentException("Illegal Capacity: "+ initialCapacity);  
8.     this.elementData = new Object[initialCapacity];  
9. }  
10. public ArrayList(Collection<? extends E> c) {  
11.     elementData = c.toArray();  
12.     size = elementData.length;  
13.     // c.toArray might (incorrectly) not return Object[] (see 6260652)
14.     if (elementData.getClass() != Object[].class)  
15.         elementData = Arrays.copyOf(elementData, size, Object[].class);  
16. }  

    3) 儲存：
   ArrayList提供了set(int index, E element)、add(E e)、add(int index, E element)、addAll(Collection<? extends E> c)、addAll(int index, Collection<? extends E> c)這些新增元素的方法。下面我們一一講解：

1. // 用指定的元素替代此列表中指定位置上的元素，並返回以前位於該位置上的元素。
2. public E set(int index, E element) {  
3.     RangeCheck(index);  
4.     E oldValue = (E) elementData[index];  
5.     elementData[index] = element;  
6.     return oldValue;  
7. }  

1. // 將指定的元素新增到此列表的尾部。
2. publicboolean add(E e) {  
3.     ensureCapacity(size + 1);   
4.     elementData[size++] = e;  
5.     returntrue;  
6. }  

1. // 將指定的元素插入此列表中的指定位置。
2. // 如果當前位置有元素，則向右移動當前位於該位置的元素以及所有後續元素（將其索引加1）。
3. publicvoid add(int index, E element) {  
4.     if (index > size || index < 0)  
5.         thrownew IndexOutOfBoundsException("Index: "+index+", Size: "+size);  
6.     // 如果陣列長度不足，將進行擴容。
7.     ensureCapacity(size+1);  // Increments modCount!!
8.     // 將 elementData中從Index位置開始、長度為size-index的元素，
9.     // 拷貝到從下標為index+1位置開始的新的elementData陣列中。
10.     // 即將當前位於該位置的元素以及所有後續元素右移一個位置。
11.     System.arraycopy(elementData, index, elementData, index + 1, size - index);  
12.     elementData[index] = element;  
13.     size++;  
14. }  

1. // 按照指定collection的迭代器所返回的元素順序，將該collection中的所有元素新增到此列表的尾部。
2. publicboolean addAll(Collection<? extends E> c) {  
3.     Object[] a = c.toArray();  
4.     int numNew = a.length;  
5.     ensureCapacity(size + numNew);  // Increments modCount
6.     System.arraycopy(a, 0, elementData, size, numNew);  
7.     size += numNew;  
8.     return numNew != 0;  
9. }  

1. // 從指定的位置開始，將指定collection中的所有元素插入到此列表中。
2. publicboolean addAll(int index, Collection<? extends E> c) {  
3.     if (index > size || index < 0)  
4.         thrownew IndexOutOfBoundsException(  
5.             "Index: " + index + ", Size: " + size);  
6.     Object[] a = c.toArray();  
7.     int numNew = a.length;  
8.     ensureCapacity(size + numNew);  // Increments modCount
9.     int numMoved = size - index;  
10.     if (numMoved > 0)  
11.         System.arraycopy(elementData, index, elementData, index + numNew, numMoved);  
12.     System.arraycopy(a, 0, elementData, index, numNew);  
13.     size += numNew;  
14.     return numNew != 0;  
15. }  

    4) 讀取：

1. // 返回此列表中指定位置上的元素。
2. public E get(int index) {  
3.     RangeCheck(index);  
4.     return (E) elementData[index];  
5. }  

    5) 刪除：
   ArrayList提供了根據下標或者指定物件兩種方式的刪除功能。如下：

1. // 移除此列表中指定位置上的元素。
2. public E remove(int index) {  
3.     RangeCheck(index);  
4.     modCount++;  
5.     E oldValue = (E) elementData[index];  
6.     int numMoved = size - index - 1;  
7.     if (numMoved > 0)  
8.         System.arraycopy(elementData, index+1, elementData, index, numMoved);  
9.     elementData[--size] = null; // Let gc do its work
10.     return oldValue;  
11. }  

1. // 移除此列表中首次出現的指定元素（如果存在）。這是應為ArrayList中允許存放重複的元素。
2. publicboolean remove(Object o) {  
3.     // 由於ArrayList中允許存放null，因此下面通過兩種情況來分別處理。
4.     if (o == null) {  
5.         for (int index = 0; index < size; index++)  
6.             if (elementData[index] == null) {  
7.                 // 類似remove(int index)，移除列表中指定位置上的元素。
8.                 fastRemove(index);  
9.                 returntrue;  
10.             }  
11. } else {  
12.     for (int index = 0; index < size; index++)  
13.         if (o.equals(elementData[index])) {  
14.             fastRemove(index);  
15.             returntrue;  
16.         }  
17.     }  
18.     returnfalse;  
19. }  

    注意：從陣列中移除元素的操作，也會導致被移除的元素以後的所有元素的向左移動一個位置。
   6) 調整陣列容量：
   從上面介紹的向ArrayList中儲存元素的程式碼中，我們看到，每當向陣列中新增元素時，都要去檢查新增後元素的個數是否會超出當前陣列的長度，如果超出，陣列將會進行擴容，以滿足新增資料的需求。陣列擴容通過一個公開的方法ensureCapacity(int minCapacity)來實現。在實際新增大量元素前，我也可以使用ensureCapacity來手動增加ArrayList例項的容量，以減少遞增式再分配的數量。

1. publicvoid ensureCapacity(int minCapacity) {  
2.     modCount++;  
3.     int oldCapacity = elementData.length;  
4.     if (minCapacity > oldCapacity) {  
5.         Object oldData[] = elementData;  
6.         int newCapacity = (oldCapacity * 3)/2 + 1;  
7.             if (newCapacity < minCapacity)  
8.                 newCapacity = minCapacity;  
9.       // minCapacity is usually close to size, so this is a win:
10.       elementData = Arrays.copyOf(elementData, newCapacity);  
11.     }  
12. }  

   從上述程式碼中可以看出，陣列進行擴容時，會將老陣列中的元素重新拷貝一份到新的陣列中，每次陣列容量的增長大約是其原容量的1.5倍。這種操作的代價是很高的，因此在實際使用時，我們應該儘量避免陣列容量的擴張。當我們可預知要儲存的元素的多少時，要在構造ArrayList例項時，就指定其容量，以避免陣列擴容的發生。或者根據實際需求，通過呼叫ensureCapacity方法來手動增加ArrayList例項的容量。
   ArrayList還給我們提供了將底層陣列的容量調整為當前列表儲存的實際元素的大小的功能。它可以通過trimToSize方法來實現。程式碼如下：

1. publicvoid trimToSize() {  
2.     modCount++;  
3.     int oldCapacity = elementData.length;  
4.     if (size < oldCapacity) {  
5.         elementData = Arrays.copyOf(elementData, size);  
6.     }  
7. }  

   7) Fail-Fast機制：
ArrayList也採用了快速失敗的機制，通過記錄modCount引數來實現。在面對併發的修改時，迭代器很快就會完全失敗，而不是冒著在將來某個不確定時間發生任意不確定行為的風險。具體介紹請參考我之前的文章深入Java集合學習系列：HashMap的實現原理中的Fail-Fast機制。
   8) 關於其他的一些方法的實現都很簡單易懂，讀者可參照API文件和原始碼，一看便知，這裡就不再多說。

/*****************************************************************************************************************************/

ArrayList是List裡面使用率最高的。

　　package collection.lession7;