手撕ArrayList底層，透徹分析源碼

ArrayList概述

Hello大家好，今天就來介紹一下ArrayList，說到ArrayList，很多人都知道它的底層是使用數組實現的，線程不安全的，說到它的特點，都會說查找快，增刪慢，因爲面試題大家都是這麼背過來的。今天就來說說它的底層源碼吧。

ArrayList更準確的說是動態數組去實現的，這裏使用動態兩字，是爲了能夠充分體現它的特點。

再者就是ArrayList不是線程安全的，所以效率比較高，但是否這個是絕對的呢？答案是否定的。

ArrayList底層源碼

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable{

private static final long serialVersionUID = 8683452581122892189L;

private static final int DEFAULT_CAPACITY = 10;

private static final Object[] EMPTY_ELEMENTDATA = {};

private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

transient Object[] elementData; // non-private to simplify nested class access

private int size;

}

(1) ArrayList繼承AbstractList抽象類，實現了RandomAccess、Cloneable、Serializable接口，RandomAccess使其擁有快速訪問的能力。

(2) Cloneable其實就是一個標記接口，只有實現這個接口後，然後在類中重寫Object中的clone方法，然後通過類調用clone方法才能克隆成功，如果不實現這個接口，則會拋出CloneNotSupportedException(克隆不被支持)異常。

(3) Serializable是序列化接口，支持序列化和反序列化。

(4) DEFAULT_CAPACITY 是ArrayList默認的初始化集合的大小。

(5) EMPTY_ELEMENTDATA是一個空對象數組，用於空實例的共享空數組實例。

(6) DEFAULTCAPACITY_EMPTY_ELEMENTDATA 是使用默認構造函數創建集合的時候使用該對象

(7) elementData用於存放當前數據的數組對象。

(8) size是集合的大小。

(9) 當集合中的元素超出數組規定的長度時，數組就會進行擴容操作，擴容操作就是ArrayList存儲操作緩慢的原因，尤其是當數據量較大的時候，每次擴容消耗的時間會越來越多。

ArrayList的構造方法源碼

ArrayList(int initialCapacity)

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

(1) 該構造函數很簡單，直接判斷傳進來的數值大小，要是大於零，直接初始一個該長度的數組對象，並賦值給elementData，要是等於零，將空數組對象EMPTY_ELEMENTDATA賦給elementData，否則，直接拋出異常。

(2) 該構造函數一般使用在要初始化一個比較大數據量的的集合的時候使用。

ArrayList()

public ArrayList() {
    this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}

(1) 將DEFAULTCAPACITY_EMPTY_ELEMENTDATA空數組對象賦給elementData

ArrayList(Collection c)

public ArrayList(Collection<? extends E> c) {

    elementData = c.toArray();

    if ((size = elementData.length) != 0) {
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    } else {
        this.elementData = EMPTY_ELEMENTDATA;
    }
}

這裏主要做了兩件事:
(1) 先將集合c轉化爲數組，然後賦值給elementData數組對象。

(2) 然後判斷size和是否相等並且不等於0，是則執行數據的賦值並重新賦值給數組對象elementData，否則直接將空數組對象賦值給elementData。

ArrayList的方法源碼分析

add()方法

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

(1) 執行ensureCapacityInternal方法，判斷原有的數組對象是否需要擴容。

(2) 將e對象添加到elementData數組對象中。

接下來我們來看看ensureCapacityInternal方法的源碼。

private void ensureCapacityInternal(int minCapacity) {
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

在ensureCapacityInternal 中調用了ensureExplicitCapacity 方法和 calculateCapacity 方法，我們來看下calculateCapacity 方法

private static int calculateCapacity(Object[] elementData, int minCapacity) {

    if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    return minCapacity;
}

(1) 這裏的任務主要是計算容量的大小，先判斷elementData數組對象是否有初始化大小，若沒有就取DEFAULT_CAPACITY或 minCapacit中的較大者爲容量的大小，若已經初始化了就minCapacity爲容量大小。

接着來看看ensureExplicitCapacity的源碼：

private void ensureExplicitCapacity(int minCapacity) {

    modCount++;

    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

(1) 執行modCount自增，modCount爲當前列表結構被修改次數。

(2) 判斷minCapacity要是大於elementData.length就執行擴容，否則，直接退出此方法，進行添加元素的操作。

接着我們來看看grow方法的源碼：

private void grow(int minCapacity) {

    int oldCapacity = elementData.length;

    int newCapacity = oldCapacity + (oldCapacity >> 1);

    if (newCapacity - minCapacity < 0)
        newCapacity = minCapacity;

    if (newCapacity - MAX_ARRAY_SIZE > 0)
        newCapacity = hugeCapacity(minCapacity);

    elementData = Arrays.copyOf(elementData, newCapacity);
}

(1) 這裏先拿到原來數據elementData的長度賦給一個變量oldCapacity，然後將原來的長度擴大1.5倍並付給oldCapacity。

(2) 判斷minCapacity 是否大於newCapacity，成立則將minCapacity賦給newCapacity，爲什麼要這麼做呢？因爲從前的一層層的方法進行解析之後來看，minCapacity是允許擴容後的最小長度，也就是實際存有數據的最小長度，要是你擴容後的長度還比minCapacity要小，那麼只能將minCapacity作爲容器的長度。

(3) 然後判斷容器新長度newCapacity是否大於容器所允許的最大長度MAX_ARRAY_SIZE，成立則將擴容長度設置爲最大可用長度。

(4) 拷貝，擴容，構建一個新的數組。

接着我們來看看grow方法調用的hugeCapacity的源碼：

private static int hugeCapacity(int minCapacity) {

    if (minCapacity < 0) // overflow
        throw new OutOfMemoryError();

    return (minCapacity > MAX_ARRAY_SIZE) ?
        Integer.MAX_VALUE :
    MAX_ARRAY_SIZE;
}

(1) 直接判斷minCapacity是否小於零，成立拋出異常，然後比較容器所允許的最小長度值是否大於MAX_ARRAY_SIZE，成立則將Integer的最大值賦值給minCapacity作爲容器的最大長度。

add(int index, E element)方法

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

(1) 這裏主要做三件事，第一件就是判斷下標是否越界，如果是則拋出IndexOutOfBoundsException異常。

(2) 然後就是判斷是否需要擴容，這個方法和上面的一樣，已經說過了，就不再贅述了。

(3) 最後就是執行數組對象index後的對象後移一位，將元素添加到指定位置。

接下來我們來看看rangeCheckForAdd的源碼

private void rangeCheckForAdd(int index) {
    if (index > size || index < 0)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

(1) 直接就是判斷index > size或者index < 0條件，成立就直接拋出數組下標越界異常。

addAll(Collection c)方法

public boolean addAll(Collection<? extends E> c) {
    return addAll(this.size, c);
}

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

    rangeCheckForAdd(index);

    int cSize = c.size();

    if (cSize==0)
        return false;

    checkForComodification();

    parent.addAll(parentOffset + index, c);

    this.modCount = parent.modCount;

    this.size += cSize;
    return true;
}

private void checkForComodification() {
    if (ArrayList.this.modCount != this.modCount)
        throw new ConcurrentModificationException();
}

(1) addAll(Collection c)方法裏面直接調用addAll(this.size, c)，在addAll(this.size, c)裏面第一件事就是判斷是否下標越界。

(2) 然後判斷c的大小是否大於0，如果等於0 返回 false。

(3) 檢查修改的次數是否相等，若不相等直接則拋出ConcurrentModificationException（併發修改）異常，這個也就是當我們用迭代器循環list的時候，在其中用list的方法新增/刪除元素，就會出現這個錯誤。

(4) 將元素插入到數組中，將修改次數賦值給 modCount，最後size大小加一

(5) 在進行 add 操作時先判斷下標是否越界，是否需要擴容，如果需要擴容，就複製數組，默認擴容一半，如果擴容一半不夠的話，就用目標的size作爲擴容後的容量，然後設置對應的下標元素值。

get()方法

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

private void rangeCheck(int index) {
    if (index >= size)
        throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}

E elementData(int index) {
    return (E) elementData[index];
}

(1) 這個就很簡單了直接就是先判斷是否下標越界，越界就拋出異常，最後返回指定index位置的元素值。

set()方法

public E set(int index, E element) {
    rangeCheck(index);

    E oldValue = elementData(index);
    elementData[index] = element;
    return oldValue;
}

(1) 先判斷是否越界，然後取出原來index位置的值爲oldValue，將新的值element設置到index位置，最後將舊的值oldValue返回。

remove()方法

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

(1) 判斷是否越界，然後將修改次數modCount值加1，然後就是獲得原來index位置的舊值。

(2) 然後是計算index位置後面有多少個元素，接着將index位置後的元素向前移動一位，最後將舊值返回。

remove(Object o)方法

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
}

(1) 這個根據對象刪除的方法比較簡單，首先判斷o對象是否爲null對象，爲null就遍歷集合中的元素，是否存在null值，存在執行刪除，刪除指定對象的方法是fastRemove，原理就是計算index位置後的元素個數，然後將index後的元素都往前移動一位，最後將最後的一位賦值爲null值。

(2) 若o對象是不爲null對象的時候，執行的邏輯是一樣的，那麼爲什麼要分開寫呢？很簡單，因爲它後面要調用o.equals(elementData[index]方法進行判斷，要是爲null，不就報空指針異常了。

Iterator迭代器

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

private class Itr implements Iterator<E> {
    int cursor; 
    int lastRet = -1;
    int expectedModCount = modCount;
    Itr() {}

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

(1) 迭代器中有幾個屬性比較重要，int cursor是下一個要返回的元素的索引， int lastRet = -1 是返回的最後一個元素的索引，默認爲-1，就是沒有的情況。

(2) hasNext方法判斷是否存在下一個元素，通過判斷以下一個下標是否爲數組大小。

(3) next方法獲取下一個元素，首先先調用checkForComodification方法檢查修改的次數是否一致，然後定義下一個元素的下標，判斷下標，如果下標大於ArrayList包含的元素個數，拋出 NoSuchElementException （沒有這樣的元素異常）異常，接着拿到ArrayList中的elementData數據對象，再次判斷下標，如果此次判斷不一致則說明數組被修改過，最後將cursor +1，指向下一個元素的下標，最後將lastRet定義爲返回的元素的下標，然後返回下標對應的值。

(4) remove移除當前元素，首先判斷最後一個元素的下標lastRet 是否小於0，成立則不存在該元素，拋出異常，然後又調用 checkForComodification，判斷修改次數是否一致，接着調用ArrayList的remove方法，最後重新更新cursor 、 lastRet、expectedModCount的值。

手撕ArrayList底層，透徹分析源碼

ArrayList概述

ArrayList底層源碼

ArrayList的構造方法源碼

ArrayList(int initialCapacity)

ArrayList()

ArrayList(Collection c)

ArrayList的方法源碼分析

add()方法

add(int index, E element)方法

addAll(Collection c)方法

get()方法

set()方法

remove()方法

remove(Object o)方法

Iterator迭代器

[轉帖]使用NMT和pmap解決JVM資源泄漏問題原創

Python實現大麥網搶票的四大關鍵技術點解析

Python 安裝庫指令大全

salesforce零基礎學習（一百三十八）零碎知識點小總結（十）

一款開源的.NET程序集反編譯、編輯和調試神器

關於接口協議，你必須要知道這些！

2020年上半年數據庫系統工程師考試

基於 Milvus + LlamaIndex 實現高級 RAG

【2024-05-21】以茶會友

被面試官質疑分佈式系統的項目經驗，當場給他把分佈式事務掰扯清楚

【SpringBoot】多種環境自由切換，只需要配置文件這麼寫

推薦一款國內首個開源全鏈路壓測平臺 1. 什麼是生產環境全鏈路壓測? 2. 我們爲什麼需要做生產環境的性能測試 2. 性能測試演變的四個階段 3. Takin介紹 4. Takin安裝及使用

號稱"不限速"的阿里網盤，官宣要停止了，壽命僅僅1年

太強了！Github大佬從零實現一個操作系統內核（附源碼）！畢設/項目經驗不愁了~

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結