容器類原始碼解析系列（一） ArrayList 原始碼分析——基於最新Android9.0原始碼

ArrayList 原始碼分析——基於最新Android9.0原始碼

前言

ArrayList 既是開發人員在日常開發過程中經常會用到的資料處理容器，也是面試場景中經常會被問到的點。包括LinkedList,HashMap,SparseArray等。因此對這些個資料結構的原始碼，還是很有必要了解一下的。其他的幾種容器，在後面的文章再做講解。RT，本文主要講解ArrayList。

要點

1. ArrayList和Vector很像，內部都是基於陣列來實現資料持久化儲存。不同的是Vector的資料操作方法加了synchronized關鍵字，來保證同步，是執行緒安全的；而ArrayList是非執行緒安全的。在多執行緒併發環境下需要加鎖來保證同步或者通過Collections.synchronizedList(new ArrayList(...)) 方法來建立一個synchronized的List。
2. ArrayList是可以儲存NULL值。
3. ArrayList的set、get操作，效率很高，因為是陣列實現的，時間複雜度是O(1)。
4. ArrayList內部實現了"fail-fast"機制，當判斷條件 "modCount != expectedModCount" 的時候會出現ConcurrentModificationException。當多個執行緒對同一個集合的內容進行操作時，就可能會產生fail-fast事件。若在多執行緒環境下使用fail-fast機制的集合，建議使用“java.util.concurrent包下的類”去取代“java.util包下的類”。
5. 因為ArrayList的內部是用陣列實現資料儲存的，所以會大量出現Arrays.copyOf、System.arraycopy這個兩個方法，來做資料移位處理。

構造

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

    /**
     * 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 = {};

    /**
     * The array buffer into which the elements of the ArrayList are stored.
     * The capacity of the ArrayList is the length of this array buffer. Any
     * empty ArrayList with elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA
     * will be expanded to DEFAULT_CAPACITY when the first element is added.
     */
    // Android-note: Also accessed from java.util.Collections
    transient Object[] elementData; // non-private to simplify nested class access

    /**
     * The size of the ArrayList (the number of elements it contains).
     *
     * @serial
     */
    private int size;
複製程式碼

ArrayList預設的capacity是10，elemenData是重點，他就是用來儲存資料的；EMPTY_ELEMENTDATA和DEFAULTCAPACITY_EMPTY_ELEMENTDATA它們是區別是一個size是0，一個是10.在看ArrayList的建構函式時就可以清晰的感受到它們的區別。

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

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

通過上面的程式碼，瞭解到，如果沒有設定capacity引數的話，會把DEFAULTCAPACITY_EMPTY_ELEMENTDA他的引用傳給elementData。如果傳進來的capacity的大小為0的話，則EMPTY_ELEMENTDATA會被賦給elementData。

擴容機制

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

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

前兩個方法我就不說了，邏輯很簡單，一看就知道。grow這個方法是擴容的核心方法，當需要擴容的時候，先記錄之前的陣列大小，新的陣列大小是之前的1.5倍，"oldCapacity >> 1"表示右移一位，是除2操作。緊接著是兩個條件判斷來決定最終的擴容後的大小。但是一般這個兩個條件不會走進去的。除非呼叫了ensureCapacity(int minCapacity)，這個方法來自行決定擴容後的大小，那麼就很有可能走進if (newCapacity - minCapacity < 0)條件裡。然後就是通過

Arrays.copyOf

方法，建立一個新的陣列指向elementData。這就是ArrayList的擴容機制，比較簡單。

常用操作

public E get(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));

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

public E set(int index, E element) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));

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

上面是ArrayList的get，set操作，是不是很簡單，因為是用的資料這個結構來儲存資料，所以，get、set操作，賊方便和迅速。

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

    /**
     * Inserts the specified element at the specified position in this
     * list. Shifts the element currently at that position (if any) and
     * any subsequent elements to the right (adds one to their indices).
     *
     * @param index index at which the specified element is to be inserted
     * @param element element to be inserted
     * @throws IndexOutOfBoundsException {@inheritDoc}
     */
    public void add(int index, E element) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(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) {
        if (index > size || index < 0)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(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系列的操作，在插入資料之前都需要先進行一個是否需要擴容的判斷，如果需要的話，就走之前我們分析的擴容邏輯。接著呢，如果需要插入指定位置的，也就是需要進行資料移位操作的，通過System.arraycopy方法，來移動資料，接著在指定位置上直接設定進去就好了。大家可以根據上面的程式碼邏輯，自己在腦海裡想象或者在紙上筆畫一下就明白了。

public E remove(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));

        modCount++;
        E oldValue = (E) 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;
    }

    /**
     * Removes the first occurrence of the specified element from this list,
     * if it is present.  If the list does not contain the element, it is
     * unchanged.  More formally, removes the element with the lowest index
     * <tt>i</tt> such that
     * <tt>(o==null&nbsp;?&nbsp;get(i)==null&nbsp;:&nbsp;o.equals(get(i)))</tt>
     * (if such an element exists).  Returns <tt>true</tt> if this list
     * contained the specified element (or equivalently, if this list
     * changed as a result of the call).
     *
     * @param o element to be removed from this list, if present
     * @return <tt>true</tt> if this list contained the specified element
     */
    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 remove method that skips bounds checking and does not
     * return the value removed.
     */
    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系列的操作，主要是先通過迴圈遍歷，定位到要刪除物件的index，然後再通過arraycopy方法，來做資料移動，最後把資料的最後一位數給置為null，方便GC回收。

Fail-Fast機制

1.定義：

通過ArrayList的iterator()，listIterator()等方法返回的迭代器，這些返回的iterator的方法是fail-fast，即這些iterator被建立了（這是前提），然後如果iterator對應的list發生了結構性的修改，比如：add、remove方法。那麼就會導致ConcurrentModificationException。

---

可能一開始看這個定義有點不是很理解，我們來分析分析這個定義。上面的定義我們抓住了一個主語，iterator，這是主要核心，然後修飾iterator的是：通過ArrayList的iterator()，listIterator()建立的iterator，這是一個點，接著一個注意的點是：是iterator對應的list發生結構性修改，這個含義是，呼叫了ArrayList的add，remove等方法，並不是iterator的remove，next等方法。

我們先看第一個點：

/**
     * Returns a list iterator over the elements in this list (in proper
     * sequence).
     *
     * <p>The returned list iterator is <a href="#fail-fast"><i>fail-fast</i></a>.
     *
     * @see #listIterator(int)
     */
    public ListIterator<E> listIterator() {
        return new ListItr(0);
    }

    /**
     * Returns an iterator over the elements in this list in proper sequence.
     *
     * <p>The returned iterator is <a href="#fail-fast"><i>fail-fast</i></a>.
     *
     * @return an iterator over the elements in this list in proper sequence
     */
    public Iterator<E> iterator() {
        return new Itr();
    }

複製程式碼

上面兩個方法，是定義中，ArrayList的兩個建立iterator的方法，我們看看建立出來的iterator到底有什麼特殊，為啥子，只要建立了iterator，就很有可能出現ConcurrentModificationException，即fail-fast現象。

private class Itr implements Iterator<E> {
        // Android-changed: Add "limit" field to detect end of iteration.
        // The "limit" of this iterator. This is the size of the list at the time the
        // iterator was created. Adding & removing elements will invalidate the iteration
        // anyway (and cause next() to throw) so saving this value will guarantee that the
        // value of hasNext() remains stable and won't flap between true and false when elements
        // are added and removed from the list.
        protected int limit = ArrayList.this.size;

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

        @SuppressWarnings("unchecked")
        public E next() {
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
            int i = cursor;
            if (i >= limit)
                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();
            if (modCount != expectedModCount)
                throw new ConcurrentModificationException();

            try {
                ArrayList.this.remove(lastRet);
                cursor = lastRet;
                lastRet = -1;
                expectedModCount = modCount;
                limit--;
            } 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;

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

這個是建立出來的iterator，類比較小，就把程式碼全貼了，這個類裡面我們看到不少拋ConcurrentModificationException異常的程式碼。丟擲這個異常的條件是什麼呢？

有兩個，一個是：

if (modCount != expectedModCount)
                throw new ConcurrentModificationException();
複製程式碼

一個是：

if (i >= elementData.length) {
                throw new ConcurrentModificationException();
            }
複製程式碼

我們看第一個條件，modCount是ArrayList的成員變數，expectedModCount是Itr的成員變數，當Itr被建立的時候，expectedModCount被賦值為此時的modCount的值，僅在執行Itr的remove方法時會被再次賦值，其他場景不在變化。但是modCount是ArrayList的成員變數，在ArrayList進行資料結構上的修改的時候就會發生變化，例如：

public E remove(int index) {
        if (index >= size)
            throw new IndexOutOfBoundsException(outOfBoundsMsg(index));

        modCount++;
        E oldValue = (E) 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;
    }
複製程式碼

modCount++在上面的程式碼我們很明顯的看到，那麼這就會出現問題，假如我們在建立好iterator了，此刻modCount是5，那expectedModCount當然也是5，然後，我們執行了ArrayList的remove或者add等會讓modCount的值發生修改的方法，然後modCount值改變了，但是expectedModCount值沒變，那下次再執行Itr(迭代器)裡面的方法就會出現modCount!=expectedModCount的情況，也就會丟擲了ConcurrentModificationException異常。

第二個條件呢，是elementData.length發生的變化，和第一個條件原理是一致，表現在稍有不同，就不在細說，可自行分析。

2.注意的點

• fail-fast問題不僅僅會出現在多執行緒併發的場景下，單執行緒的情況下也會出現。上面的分析可以發現這一點。之所以說這個是因為有的人可能會認為只有在多執行緒才可能發生這種情況，那是沒有真正搞懂原因。其實，不盡然。
• fail-fast的出現時機是不確定性的，不可以拿這個作為開發流程中的一個判斷條件。
• 併發場景，要做同步，可以採用java.util.concurrent下的容器類。

3.解決fail-fast問題

既然知道了出現ConcurrentModificationException異常的原因，那解決的方法就是不滿足這個條件就可以了，解決的方法是開放，多樣的。比如可以用Itr(迭代器)內部的remove，next等修改結構的方法達到處理資料的目的。

容器類原始碼解析系列（二）—— LinkedList 集合原始碼分析(最新版)

---

掃碼加入我的個人微信公眾號：Android開發圈 ，一起學習Android知識！！