源碼分析之ArrayList

BNVJayson 7年前發布 | 15K 次閱讀源碼分析 Java開發

ArrayList 是我們常用的集合類，是基于數組實現的。不同于數組的是 ArrayList 可以動態擴容。

類結構

ArrayList 是 Java 集合框架 List 接口的一個實現類。提供了一些操作數組元素的方法。

實現 List 接口同時，也實現了 RandomAccess , Cloneable , java.io.Serializable 。

ArrayList 繼承與 AbstractList 。

類成員

elementData

transient Object[] elementData;

elementData 是用于保存數據的數組，是 ArrayList 類的基礎。

elementData 是被關鍵字 transient 修飾的。我們知道被 transient 修飾的變量，是不會參與對象序列化和發序列化操作的。而我們知道 ArrayList 實現了 java.io.Serializable ，這就表明 ArrayList 是可序列化的類，這里貌似出現了矛盾。

ArrayList 在序列化和反序列化的過程中，有兩個值得關注的方法： writeObject 和 readObject ：

privatevoidwriteObject(java.io.ObjectOutputStream s)
    throws java.io.IOException{
    // Write out element count, and any hidden stuff
    int expectedModCount = modCount;
    s.defaultWriteObject();

    // Write out size as capacity for behavioural compatibility with clone()
    s.writeInt(size);

    // Write out all elements in the proper order.
    for (int i=0; i<size; i++) {
        s.writeObject(elementData[i]);
    }

    if (modCount != expectedModCount) {
        throw new ConcurrentModificationException();
    }
}

privatevoidreadObject(java.io.ObjectInputStream s)
    throws java.io.IOException, ClassNotFoundException {
    elementData = EMPTY_ELEMENTDATA;

    // Read in size, and any hidden stuff
    s.defaultReadObject();

    // Read in capacity
    s.readInt(); // ignored

    if (size > 0) {
        // be like clone(), allocate array based upon size not capacity
        ensureCapacityInternal(size);

        Object[] a = elementData;
        // Read in all elements in the proper order.
        for (int i=0; i<size; i++) {
            a[i] = s.readObject();
        }
    }
}

writeObject 會將 ArrayList 中的 size 和 element 數據寫入 ObjectOutputStream 。 readObject 會從 ObjectInputStream 讀取 size 和 element 數據。

之所以采用這種序列化方式，是出于性能的考量。因為 ArrayList 中 elementData 數組在 add 元素的過程，容量不夠時會動態擴容，這就到可能會有空間沒有存儲元素。采用上述序列化方式，可以保證只序列化有實際值的數組元素，從而節約時間和空間。

size

private int size;

size 是 ArrayList 的大小。

DEFAULT_CAPACITY

/**
 * Default initial capacity.
 */
private static final int DEFAULT_CAPACITY = 10;

ArrayList 默認容量是10。

構造函數

ArrayList 提供了2個構造函數 ArrayList(int initialCapacity) 和 ArrayList() 。

使用有參構造函數初始化 ArrayList 需要指定初始容量大小，否則采用默認值10。

add()方法

publicbooleanadd(E e){
    ensureCapacityInternal(size + 1);  // Increments modCount!!
    elementData[size++] = e;
    return true;
}

在 add 元素之前，會調用 ensureCapacityInternal 方法，來判斷當前數組是否需要擴容。

privatevoidensureCapacityInternal(intminCapacity){
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        // 如果elementData為空數組，指定elementData最少需要多少容量。
        // 如果初次add，將取默認值10；
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    ensureExplicitCapacity(minCapacity);
}

privatevoidensureExplicitCapacity(intminCapacity){
    modCount++;

    // overflow-conscious code
    // elementData容量不足的情況下進行擴容
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

privatevoidgrow(intminCapacity){
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);
    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;
    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);
}

從 grow 方法中可以看出， ArrayList 的 elementData 數組如遇到容量不足時，將會把新容量 newCapacity 設置為 oldCapacity + (oldCapacity >> 1) 。二進制位操作 >> 1 等同于 /2 的效果，擴容導致的 newCapacity 也就設置為原先的1.5倍。
如果新的容量大于 MAX_ARRAY_SIZE 。將會調用 hugeCapacity 將 int 的最大值賦給 newCapacity 。不過這種情況一般不會用到，很少會用到這么大的 ArrayList 。

在確保有容量的情況下，會將元素添加至 elementData 數組中。

add(int index, E element) 方法

publicvoidadd(intindex, E element){
    rangeCheckForAdd(index);

    ensureCapacityInternal(size + 1);  // Increments modCount!!
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    elementData[index] = element;
    size++;
}

帶有 index 的 add 方法相對于直接 add 元素方法會略有不同。

首先會調用 rangeCheckForAdd 來檢查，要添加的 index 是否存在數組越界問題；
同樣會調用 ensureCapacityInternal 來保證容量；
調用 System.arraycopy 方法復制數組，空出 elementData[index] 的位置；
賦值并增加 size ；

remove(int index) 方法

publicEremove(intindex){
    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;
}

ArryList 提供了兩個刪除 List 元素的方法，如上所示，就是根據 index 來刪除元素。

檢查 index 是否越界；
取出原先值的，如果要刪除的值不是數組最后一位，調用 System.arraycopy 方法將待刪除的元素移動至 elementData 最后一位。
將 elementData 最后一位賦值為null。

remove(Object o) 方法

publicbooleanremove(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;
}

remove(Object o) 是根據元素刪除的，相對來說就要麻煩一點：

當元素 o 為空的時候，遍歷數組刪除空的元素。
當元素 o 不為空的時候，遍歷數組找出于 o 元素的 index ，并刪除元素。
如果以上兩步都沒有成功刪除元素，返回 false 。

modCount

在 add 、 remove 過程中，經常發現會有 modCount++ 或者 modCount-- 操作。這里來看下 modCount 是個啥玩意。

modCount 變量是在 AbstractList 中定義的。

protected transient int modCount = 0;

modCount 是一個 int 型變量，用來記錄 ArrayList 結構變化的次數。

modCount 起作用的地方是在使用 iterator 的時候。 ArrayList 的 iterator 方法。

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

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

    publicbooleanhasNext(){
        return cursor != size;
    }

    @SuppressWarnings("unchecked")
    publicEnext(){
        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];
    }

    publicvoidremove(){
        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")
    publicvoidforEachRemaining(Consumer<?superE> 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();
    }

    finalvoidcheckForComodification(){
        if (modCount != expectedModCount)
            throw new ConcurrentModificationException();
    }
}

iterator 方法會返回私有內部類 Itr 的一個實例。這里可以看到 Itr 類中很多方法，都會調用 checkForComodification 方法。來檢查 modCount 是夠等于 expectedModCount 。如果發現 modCount != expectedModCount 將會拋出 ConcurrentModificationException 異常。

這里寫一個小例子來驗證體會下 modCount 的作用。簡單介紹一下這個小例子：準備兩個線程 t1 、 t2 ，兩個線程對同一個 ArrayList 進行操作， t1 線程將循環向 ArrayList 中添加元素， t2 線程將把 ArrayList 元素讀出來。

Test 類：

public classTest{

    List<String> list = new ArrayList<String>();


    publicTest(){

    }


    publicvoidadd(){

        for (int i = 0; i < 10000; i++) {
            list.add(String.valueOf(i));
        }

    }

    publicvoidread(){

        Iterator iterator = list.iterator();
        while (iterator.hasNext()) {
            System.out.println(iterator.next());
        }

    }

t1 線程：

public classTest1ThreadimplementsRunnable{

    private Test test;

    publicTest1Thread(Test test){
        this.test = test;
    }

    publicvoidrun(){

        test.add();

    }

t2 線程：

public classTest2ThreadimplementsRunnable{

    private Test test;

    publicTest2Thread(Test test){
        this.test = test;
    }


    publicvoidrun(){
        test.read();
    }
}

main 類

publicstaticvoidmain(String[] args)throwsInterruptedException{

    Test test = new Test();
    Thread t1  = new Thread(new Test1Thread(test));
    Thread t2  = new Thread(new Test2Thread(test));

    t1.start();
    t2.start();

}

執行這個 mian 類就會發現程序將拋出一個 ConcurrentModificationException 異常。

由異常可以發現拋出異常點正處于在調用 next 方法的 checkForComodification 方法出現了異常。這里也就出現上文描述的 modCount != expectedModCount 的情況，原因是 t2 線程在讀數據的時候， t1 線程還在不斷的添加元素。

這里 modCount 的作用也就顯而易見了，用 modCount 來規避多線程中并發的問題。由此也可以看出 ArrayList 是非線程安全的類。

來自：http://lishuo.me/2017/04/12/源碼分析之ArrayList/

本文由用戶 BNVJayson 自行上傳分享，僅供網友學習交流。所有權歸原作者，若您的權利被侵害，請聯系管理員。

轉載本站原創文章，請注明出處，并保留原始鏈接、圖片水印。

本站是一個以用戶分享為主的開源技術平臺，歡迎各類分享！

本文地址：http://www.baiduhome.net/lib/view/open1492054514619.html

源碼分析 Java開發

源碼分析之ArrayList

類結構

類成員

相關經驗

相關資訊

相關文檔

目錄