（一）ArrayList原始碼解析

ArrayList定義

publicclassArrayList<E> extendsAbstractList<E> implementsList<E>, RandomAccess, Cloneable, java.io.Serializable

ArrayList 是一個陣列佇列，相當於 動態陣列。與Java中的陣列相比，它的容量能動態增長。它繼承於AbstractList，實現了List, RandomAccess,Cloneable, java.io.Serializable這些介面。

ArrayList 繼承了AbstractList

，實現了List。它是一個數組佇列，提供了相關的新增、刪除、修改、遍歷等功能。
ArrayList 實現了RandmoAccess介面，即提供了隨機訪問功能。RandmoAccess是java中用來被List實現，為List提供快速訪問功能的。在ArrayList中，我們即可以通過元素的序號快速獲取元素物件；這就是快速隨機訪問。稍後，我們會比較List的“快速隨機訪問”和“通過Iterator迭代器訪問”的效率。

ArrayList 實現了Cloneable介面，即覆蓋了函式clone()，能被克隆。

ArrayList 實現java.io.Serializable介面，這意味著ArrayList

支援序列化，能通過序列化去傳輸。

和Vector不同，ArrayList中的操作不是執行緒安全的！所以，建議在單執行緒中才使用ArrayList，而在多執行緒中可以選擇Vector或者CopyOnWriteArrayList。

ArrayList屬性

顧名思義哈，ArrayList就是用陣列實現的List容器，既然是用陣列實現，當然底層用陣列來儲存資料啦

// 儲存ArrayList中資料的陣列

privatetransient Object[]elementData;

//ArrayList中實際資料的數量

privateint size;

ArrayList包含了兩個重要的物件：elementData

和 size。

(1) elementData 是"Object[]型別的陣列"，它儲存了新增到ArrayList中的元素。實際上，elementData是個動態陣列，我們能通過建構函式 ArrayList(intinitialCapacity)來執行它的初始容量為initialCapacity；如果通過不含引數的建構函式ArrayList()來建立ArrayList，則elementData的容量預設是10。elementData陣列的大小會根據ArrayList容量的增長而動態的增長，具體的增長方式，請參考原始碼分析中的ensureCapacity()函式。

(2) size 則是動態陣列的實際大小。

ArrayList建構函式

//ArrayList帶容量大小的建構函式。

publicArrayList(intinitialCapacity) {

super();

if(initialCapacity < 0)

thrownewIllegalArgumentException("IllegalCapacity: "+initialCapacity);

// 新建一個數組

this.elementData= newObject[initialCapacity];

}

//ArrayList建構函式。預設容量是10。

publicArrayList() {

this(10);

}

// 構造一個包含指定元素的list，這些元素的是按照Collection的迭代器返回的順序排列的

publicArrayList(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[]）。

API方法摘要

ArrayList原始碼解析(基於JDK1.6.0_45)

增加

/**

 * 新增一個元素

     */

publicbooleanadd(E e) {

// 進行擴容檢查

       ensureCapacity( size + 1);  //Increments modCount

// 將e增加至list的資料尾部，容量+1

        elementData[size ++] = e;

returntrue;

    }

/**

     * 在指定位置新增一個元素

     */

publicvoidadd(int index, Eelement) {

// 判斷索引是否越界，這裡會丟擲多麼熟悉的異常。。。

if (index> size || index < 0)

thrownewIndexOutOfBoundsException(

"Index:"+index+",Size: " +size);

// 進行擴容檢查

       ensureCapacity( size+1);  //Increments modCount 

// 對陣列進行復制處理，目的就是空出index的位置插入element，並將index後的元素位移一個位置

       System. arraycopy(elementData, index,elementData, index + 1,

                      size - index);

// 將指定的index位置賦值為element

        elementData[index] = element;

// list容量+1

        size++;

    }

/**

     * 增加一個集合元素

     */

publicbooleanaddAll(Collection<?extends E> c) {

//將c轉換為陣列

       Object[] a = c.toArray();

int numNew =a.length ;

//擴容檢查

       ensureCapacity( size + numNew);  //Increments modCount

//將c新增至list的資料尾部

        System. arraycopy(a, 0,elementData, size, numNew);

//更新當前容器大小

        size += numNew;

return numNew !=0;

    }

/**

     * 在指定位置，增加一個集合元素

     */

publicbooleanaddAll(int index,Collection<? extends E> c) {

if (index> size || index < 0)

thrownewIndexOutOfBoundsException(

"Index:" + index + ",Size: " + size);

       Object[] a = c.toArray();

int numNew =a.length ;

       ensureCapacity( size + numNew);  //Increments modCount

// 計算需要移動的長度（index之後的元素個數）

int numMoved= size - index;

// 陣列複製，空出第index到index+numNum的位置，即將陣列index後的元素向右移動numNum個位置

if (numMoved> 0)

           System. arraycopy(elementData, index,elementData, index + numNew,

                          numMoved);

// 將要插入的集合元素複製到陣列空出的位置中

        System. arraycopy(a, 0,elementData, index, numNew);

        size += numNew;

return numNew !=0;

    }

/**

     * 陣列容量檢查，不夠時則進行擴容

     */

publicvoidensureCapacity( intminCapacity) {

        modCount++;

// 當前陣列的長度

intoldCapacity = elementData .length;

// 最小需要的容量大於當前陣列的長度則進行擴容

if(minCapacity > oldCapacity) {

           Object oldData[] = elementData;

// 新擴容的陣列長度為舊容量的1.5倍+1

intnewCapacity = (oldCapacity * 3)/2 + 1;

// 如果新擴容的陣列長度還是比最小需要的容量小，則以最小需要的容量為長度進行擴容

if(newCapacity < minCapacity)

              newCapacity = minCapacity;

//minCapacity is usually close to size, so this is a win:

// 進行資料拷貝，Arrays.copyOf底層實現是System.arrayCopy()

            elementData = Arrays.copyOf(elementData, newCapacity);

       }

    }

刪除

/**

     * 根據索引位置刪除元素

     */

public E remove( int index) {

// 陣列越界檢查

       RangeCheck(index);

        modCount++;

// 取出要刪除位置的元素，供返回使用

       E oldValue = (E) elementData[index];

// 計算陣列要複製的數量

int numMoved= size - index - 1;

// 陣列複製，就是將index之後的元素往前移動一個位置

if (numMoved> 0)

           System. arraycopy(elementData,index+1,elementData, index,

                          numMoved);

// 將陣列最後一個元素置空（因為刪除了一個元素，然後index後面的元素都向前移動了，所以最後一個就沒用了），好讓gc儘快回收

// 不要忘了size減一

        elementData[--size ] = null; // Let gcdo its work

return oldValue;

    }

/**

     * 根據元素內容刪除，只刪除匹配的第一個

     */

publicbooleanremove(Object o){

// 對要刪除的元素進行null判斷

// 對資料元素進行遍歷查詢，知道找到第一個要刪除的元素，刪除後進行返回，如果要刪除的元素正好是最後一個那就慘了，時間複雜度可達O(n) 。。。

if (o == null) {

for (int index = 0; index< size; index++)

// null值要用==比較

if(elementData [index] == null) {

                  fastRemove(index);

returntrue;

              }

       } else {

for (int index = 0; index< size; index++)

// 非null當然是用equals比較了

if(o.equals(elementData [index])) {

                  fastRemove(index);

returntrue;

              }

        }

returnfalse;

    }

/*

     * Private remove method that skips boundschecking and does not

     * return the value removed.

     */

privatevoidfastRemove(int index) {

        modCount++;

// 原理和之前的add一樣，還是進行陣列複製，將index後的元素向前移動一個位置，不細解釋了，

int numMoved= size - index - 1;

if (numMoved> 0)

            System. arraycopy(elementData,index+1,elementData, index,

                             numMoved);

        elementData[--size ] = null; // Let gcdo its work

    }

/**

     * 陣列越界檢查

     */

privatevoidRangeCheck(int index) {

if (index>= size )

thrownewIndexOutOfBoundsException(

"Index:"+index+",Size: " +size);

    }

增加和刪除方法到這裡就解釋完了，程式碼是很簡單，主要需要特別關心的就兩個地方：1.陣列擴容，2.陣列複製，這兩個操作都是極費效率的，最慘的情況下(新增到list第一個位置，刪除list最後一個元素或刪除list第一個索引位置的元素)時間複雜度可達O(n)。

還記得上面那個坑嗎（為什麼提供一個可以指定容量大小的構造方法 ）？看到這裡是不是有點明白了呢，簡單解釋下：如果陣列初試容量過小，假設預設的10個大小，而我們使用ArrayList的主要操作時增加元素，不斷的增加，一直增加，不停的增加，會出現上面後果？那就是陣列容量不斷的受挑釁，陣列需要不斷的進行擴容，擴容的過程就是陣列拷貝System.arraycopy的過程，每一次擴容就會開闢一塊新的記憶體空間和資料的複製移動，這樣勢必對效能造成影響。那麼在這種以寫為主（寫會擴容，刪不會縮容）場景下，提前預知性的設定一個大容量，便可減少擴容的次數，提高了效能。

上面兩張圖分別是陣列擴容和陣列複製的過程，需要注意的是，陣列擴容伴隨著開闢新建的記憶體空間以建立新陣列然後進行資料複製，而陣列複製不需要開闢新記憶體空間，只需將資料進行復制。

上面講增加元素可能會進行擴容，而刪除元素卻不會進行縮容，如果在已刪除為主的場景下使用list，一直不停的刪除而很少進行增加，那麼會出現什麼情況？再或者陣列進行一次大擴容後，我們後續只使用了幾個空間，會出現上面情況？當然是空間浪費啦啦啦，怎麼辦呢？

/**

     * 將底層陣列的容量調整為當前實際元素的大小，來釋放空間。

     */

publicvoidtrimToSize() {

        modCount++;

// 當前陣列的容量

intoldCapacity = elementData .length;

// 如果當前實際元素大小小於 當前陣列的容量，則進行縮容

if (size< oldCapacity) {

            elementData = Arrays.copyOf(elementData, size );

       }

更新

/**

     * 將指定位置的元素更新為新元素

     */

public E set( int index, Eelement) {

   // 陣列越界檢查(幾乎每次操作都要先進行陣列越界檢查)

       RangeCheck(index);

// 取出要更新位置的元素，供返回使用

       E oldValue = (E) elementData[index];

// 將該位置賦值為行的元素

        elementData[index] = element;

// 返回舊元素

return oldValue;

    }

查詢

/**

     * 查詢指定位置上的元素

     */

public E get( int index) {

       RangeCheck(index);

return (E)elementData [index];

}

//是否包含指定元素

publicbooleancontains(Object o){

returnindexOf(o) >= 0;

    }

publicintindexOf(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;

    }

publicintlastIndexOf(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;

    }

contains主要是檢查indexOf，也就是元素在list中出現的索引位置也就是陣列下標，再看indexOf和lastIndexOf程式碼是不是很熟悉，沒錯，和public boolean remove(Objecto) 的程式碼一樣，都是元素null判斷，都是迴圈比較，不多說了。。。但是要知道，最差的情況（要找的元素是最後一個）也是很慘的。。。

容量判斷

/**

     * Returns the number of elements in thislist.

     */

publicintsize() {

return size ;

    }

/**

     * Returns <tt>true</tt> ifthis list contains no elements.

     */

publicbooleanisEmpty() {

return size == 0;

    }

由於使用了size進行計數，發現list大小獲取和判斷真的好容易。

總結：
(01) ArrayList 實際上是通過一個數組去儲存資料的。當我們構造ArrayList時；若使用預設建構函式，則ArrayList的預設容量大小是10。
(02) 當ArrayList容量不足以容納全部元素時，ArrayList會重新設定容量：新的容量=“(原始容量×3)/2 + 1”。
(03) ArrayList的克隆函式，即是將全部元素克隆到一個數組中。
(04) ArrayList實現java.io.Serializable的方式。當寫入到輸出流時，先寫入“容量”，再依次寫入“每一個元素”；當讀出輸入流時，先讀取“容量”，再依次讀取“每一個元素”。

ArrayList遍歷方式

ArrayList支援3種遍歷方式
(01) 第一種，通過迭代器遍歷。即通過Iterator去遍歷。

Integervalue = null;

Iteratoriter = list.iterator();

while(iter.hasNext()) {

    value = (Integer)iter.next();

}

(02) 第二種，隨機訪問，通過索引值去遍歷。
由於ArrayList實現了RandomAccess介面，它支援通過索引值去隨機訪問元素。

Integervalue = null;

int size =list.size();

for (int i=0;i<size; i++) {

    value = (Integer)list.get(i);       

}

(03) 第三種，for迴圈遍歷。如下：

Integervalue = null;

for (Integerinteg:list) {

    value = integ;

}

下面通過一個例項，比較這3種方式的效率，例項程式碼(ArrayListRandomAccessTest.java)如下：

importjava.util.*;

importjava.util.concurrent.*;

/*

 * @desc ArrayList遍歷方式和效率的測試程式。

 *

 * @author skywang

 */

publicclassArrayListRandomAccessTest {

publicstaticvoidmain(String[]args) {

        List list = newArrayList();

for (int i=0; i<100000; i++)

            list.add(i);

//isRandomAccessSupported(list);

        iteratorThroughRandomAccess(list) ;

        iteratorThroughIterator(list) ;

        iteratorThroughFor2(list) ;

    }

privatestaticvoidisRandomAccessSupported(Listlist) {

if (list instanceofRandomAccess) {

            System.out.println("RandomAccessimplemented!");

        } else {

            System.out.println("RandomAccessnot implemented!");

        }

    }

publicstaticvoiditeratorThroughRandomAccess(Listlist) {

longstartTime;

long endTime;

        startTime = System.currentTimeMillis();

for (int i=0;i<list.size(); i++) {

            list.get(i);

        }

        endTime = System.currentTimeMillis();

long interval= endTime - startTime;

        System.out.println("iteratorThroughRandomAccess：" +interval+" ms");

    }

publicstaticvoiditeratorThroughIterator(Listlist) {

longstartTime;

long endTime;

        startTime = System.currentTimeMillis();

for(Iteratoriter = list.iterator(); iter.hasNext(); ) {

            iter.next();

        }

        endTime = System.currentTimeMillis();

long interval= endTime - startTime;

        System.out.println("iteratorThroughIterator：" +interval+" ms");

    }

publicstaticvoiditeratorThroughFor2(Listlist) {

longstartTime;

long endTime;

        startTime = System.currentTimeMillis();

for(Objectobj:list)

          ;

        endTime = System.currentTimeMillis();

long interval= endTime - startTime;

        System.out.println(

相關推薦