ArrayList詳解，看這篇就夠了

阿新 • • 發佈：2019-01-04

簡介

ArrayList 是 java 集合框架中比較常用的資料結構了。繼承自 AbstractList，實現了 List 介面。底層基於陣列實現容量大小動態變化。允許 null 的存在。同時還實現了 RandomAccess、Cloneable、Serializable 介面，所以ArrayList 是支援快速訪問、複製、序列化的。

成員變數

ArrayList 底層是基於陣列來實現容量大小動態變化的。

/**
* The size of the ArrayList (the number of elements it contains).
*/
private int size;  // 實際元素個數 

transient Object[] elementData;

注意：上面的 size 是指 elementData 中實際有多少個元素，而 elementData.length 為集合容量，表示最多可以容納多少個元素。

預設初始容量大小為 10;

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

這個變數是定義在 AbstractList 中的。記錄對 List 操作的次數。主要使用是在 Iterator，是防止在迭代的過程中集合被修改。

protected transient 
 int modCount = 0;

下面兩個變數是用在建構函式裡面的

/**
* Shared empty array instance used for empty instances.
*/
private static final Object[] EMPTY_ELEMENTDATA = {};

/**
* Shared empty array instance used for default sized empty instances. We
* distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when
* first element is added.
*/ 

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

兩個空的陣列有什麼區別呢？ We distinguish this from EMPTY_ELEMENTDATA to know how much to inflate when first element is added. 簡單來講就是第一次新增元素時知道該 elementData 從空的建構函式還是有參建構函式被初始化的。以便確認如何擴容。

建構函式

無慘建構函式

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

注意：註釋是說構造一個容量大小為 10 的空的 list 集合，但構造函數了只是給 elementData 賦值了一個空的陣列，其實是在第一次新增元素時容量擴大至 10 的。

構造一個初始容量大小為 initialCapacity 的 ArrayList

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);
    }
}

由以上原始碼可見：當使用無參建構函式時是把 DEFAULTCAPACITY_EMPTY_ELEMENTDATA 賦值給 elementData。當 initialCapacity 為零時則是把 EMPTY_ELEMENTDATA 賦值給 elementData。當 initialCapacity 大於零時初始化一個大小為 initialCapacity 的 object 陣列並賦值給 elementData。

使用指定 Collection 來構造 ArrayList 的建構函式

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

將 Collection 轉化為陣列並賦值給 elementData，把 elementData 中元素的個數賦值給 size。如果 size 不為零，則判斷 elementData 的 class 型別是否為 Object[]，不是的話則做一次轉換。如果 size 為零，則把 EMPTY_ELEMENTDATA 賦值給 elementData，相當於new ArrayList(0)。

主要操作方法解析

add 操作

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

private void ensureCapacityInternal(int minCapacity) {
    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    ensureExplicitCapacity(minCapacity);
}

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;
    // overflow-conscious code
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

由此可見：每次新增元素到集合中時都會先確認下集合容量大小。然後將 size 自增 1。ensureCapacityInternal 函式中判斷如果 elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA 就取 DEFAULT_CAPACITY 和 minCapacity 的最大值也就是 10。這就是 EMPTY_ELEMENTDATA 與 DEFAULTCAPACITY_EMPTY_ELEMENTDATA 的區別所在。同時也驗證了上面的說法：使用無慘建構函式時是在第一次新增元素時初始化容量為 10 的。ensureExplicitCapacity 中對 modCount 自增 1，記錄操作次數，然後如果 minCapacity 大於 elementData 的長度，則對集合進行擴容。顯然第一次新增元素時 elementData 的長度為零。那我們來看看 grow 函式。

private void grow(int minCapacity) {
    // 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);
}

很簡單明瞭的一個函式，預設將擴容至原來容量的 1.5 倍。但是擴容之後也不一定適用，有可能太小，有可能太大。所以才會有下面兩個 if 判斷。如果1.5倍太小的話，則將我們所需的容量大小賦值給newCapacity，如果1.5倍太大或者我們需要的容量太大，那就直接拿 newCapacity = (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE 來擴容。然後將原陣列中的資料複製到大小為 newCapacity 的新陣列中，並將新陣列賦值給 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++;
}

public boolean addAll(Collection<? extends E> c) {
    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacityInternal(size + numNew);  // Increments modCount
    System.arraycopy(a, 0, elementData, size, numNew);
    size += numNew;
    return numNew != 0;
}

public boolean addAll(int index, Collection<? extends E> c) {
    rangeCheckForAdd(index);

    Object[] a = c.toArray();
    int numNew = a.length;
    ensureCapacityInternal(size + numNew);  // Increments modCount

    int numMoved = size - index;
    if (numMoved > 0)
        System.arraycopy(elementData, index, elementData, index + numNew, numMoved);

    System.arraycopy(a, 0, elementData, index, numNew);
    size += numNew;
    return numNew != 0;
}

有以上原始碼可知，add(int index, E element)，addAll(Collection

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

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
}

當我們呼叫 remove(int index) 時，首先會檢查 index 是否合法，然後再判斷要刪除的元素是否位於陣列的最後一個位置。如果 index 不是最後一個，就再次呼叫 System.arraycopy() 方法拷貝陣列。說白了就是將從 index + 1 開始向後所有的元素都向前挪一個位置。然後將陣列的最後一個位置空，size - 1。如果 index 是最後一個元素那麼就直接將陣列的最後一個位置空，size - 1即可。當我們呼叫 remove(Object o) 時，會把 o 分為是否為空來分別處理。然後對陣列做遍歷，找到第一個與 o 對應的下標 index，然後呼叫 fastRemove 方法，刪除下標為 index 的元素。其實仔細觀察 fastRemove(int index) 方法和 remove(int index) 方法基本全部相同。

get操作

public E get(int index) {
    rangeCheck(index);
    return elementData(index);
}

由於 ArrayList 底層是基於陣列實現的，所以獲取元素就相當簡單了，直接呼叫陣列隨機訪問即可。
迭代器 iterator

有使用過集合的都知道，在用 for 遍歷集合的時候是不可以對集合進行 remove操作的，因為 remove 操作會改變集合的大小。從而容易造成結果不準確甚至陣列下標越界，更嚴重者還會丟擲 ConcurrentModificationException。

例子.png

foreach 遍歷等同於 iterator。為了搞清楚異常原因，我們還必須過一遍原始碼。

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

原來是直接返回一個 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;

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

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

從原始碼可以看出，ArrayList 定義了一個內部類 Itr 實現了 Iterator 介面。在 Itr 內部有三個成員變數。 cursor：代表下一個要訪問的元素下標。 lastRet：代表上一個要訪問的元素下標。 expectedModCount：代表對 ArrayList 修改次數的期望值，初始值為 modCount。

下面看看 Itr 的三個主要函式。

hasNext 實現比較簡單，如果下一個元素的下標等於集合的大小，就證明到最後了。

next 方法也不復雜，但很關鍵。首先判斷 expectedModCount 和 modCount 是否相等。然後對 cursor 進行判斷，看是否超過集合大小和陣列長度。然後將 cursor 賦值給 lastRet ，並返回下標為 lastRet 的元素。最後將 cursor 自增 1。開始時，cursor = 0，lastRet = -1；每呼叫一次 next 方法， cursor 和 lastRet 都會自增 1。

remove 方法首先會判斷 lastRet 的值是否小於 0，然後在檢查 expectedModCount 和 modCount 是否相等。接下來是關鍵，直接呼叫 ArrayList 的 remove 方法刪除下標為 lastRet 的元素。然後將 lastRet 賦值給 cursor ，將 lastRet 重新賦值為 -1，並將 modCount 重新賦值給 expectedModCount。

下面我們一步一步來分析 Itr 的操作。如圖一所示，開始時 cursor 指向下標為 0 的元素，lastRet 指向下標為 -1 的元素，也就是 null。每呼叫一次 next，cursor 和lastRet 就分別會自增 1。當 next 返回 “C” 時，cursor 和 lastRet 分別為 3 和 2 [圖二]。

此時呼叫 remove，注意是 ArrayList 的 remove，而不是 Itr 的 remove。會將 D E 兩個元素直接往前移動一位，最後一位置空，並且 modCount 會自增 1。從 remove 方法可以看出。[圖三]。

此時 cursor = 3，size = 4，沒有到陣列末尾，所以迴圈繼續。來到 next 方法，因為上一步的 remove 方法對 modCount 做了修改，致使 expectedModCount 與 modCount 不相等，這就是 ConcurrentModificationException 異常的原因所在。從例子.png中也可以看出異常出自 ArrayList 中的內部類 Itr 中的 checkForComodification 方法。

異常的解決：

直接呼叫 iterator.remove() 即可。因為在該方法中增加了 expectedModCount = modCount 操作。但是這個 remove 方法也有弊端。

1、只能進行remove操作，add、clear 等 Itr 中沒有。
2、呼叫 remove 之前必須先呼叫 next。因為 remove 開始就對 lastRet 做了校驗。而 lastRet 初始化時為 -1。
3、next 之後只可以呼叫一次 remove。因為 remove 會將 lastRet 重新初始化為 -1

總結

ArrayList 底層基於陣列實現容量大小動態可變。擴容機制為首先擴容為原始容量的 1.5 倍。如果1.5倍太小的話，則將我們所需的容量大小賦值給 newCapacity，如果1.5倍太大或者我們需要的容量太大，那就直接拿 newCapacity = (minCapacity > MAX_ARRAY_SIZE) ? Integer.MAX_VALUE : MAX_ARRAY_SIZE 來擴容。擴容之後是通過陣列的拷貝來確保元素的準確性的，所以儘可能減少擴容操作。 ArrayList 的最大儲存能力：Integer.MAX_VALUE。 size 為集合中儲存的元素的個數。elementData.length 為陣列長度，表示最多可以儲存多少個元素。如果需要邊遍歷邊 remove ，必須使用 iterator。且 remove 之前必須先 next，next 之後只能用一次 remove。

這裡寫圖片描述

ArrayList詳解，看這篇就夠了

簡介

成員變數

建構函式

主要操作方法解析

總結

ArrayList詳解，看這篇就夠了

Java執行緒池詳解，看這篇就夠了！

【本人禿頂程式設計師】Java執行緒池詳解，看這篇就夠了！

學習Java JDBC，看這篇就夠了

入門Webpack，看這篇就夠了

Map總結，看這篇就夠了

入門 Webpack，看這篇就夠了

Elasticsearch Query DSL 整理總結（二）—— 要搞懂 Match Query，看這篇就夠了

Python Web怎麼學，看這篇就夠了！

Python Web怎麽學，看這篇就夠了！

繼萬字諫言後，Python Web 怎麼學，看這篇就夠了！

Python 中的 or，and 運算，看這篇就夠了

Python 中的 or and 運算，看這篇就夠了

10大經典排序演算法動圖演示，看這篇就夠了！（配相應程式碼）

Java 動態代理，看這篇就夠了

mybatis 快取的使用，看這篇就夠了

搞定計算機網路面試，看這篇就夠了

Elasticsearch Query DSL 整理總結（二）—— 要搞懂 Match Query，看這篇就夠了

jdk安裝與環境變數配置，看這篇就夠了

Python 3 入門，看這篇就夠了

ArrayList詳解，看這篇就夠了

簡介

成員變數

建構函式

主要操作方法解析

總結

相關推薦