ArrayList詳解-源碼分析

時間  2020-05-21
標籤 arraylist 詳解 源碼 分析 欄目 Java 简体版
原文   原文鏈接

ArrayList詳解-源碼分析

1. 概述

在平時的開發中，用到最多的集合應該就是ArrayList了，本篇文章將結合源代碼來學習ArrayList。java

  • ArrayList是基於數組實現的集合列表
  • 支持任意性的訪問（可根據索引直接獲得你想要的元素）
  • 線程不安全
  • 支持動態擴容
  • 查詢快，增刪慢
  • ...

這些你們應該都很清楚，下面根據源代碼來深刻分析一下ArrayList。數組

2. ArrayList類聲明

源代碼以下所示：安全

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

初步分析：dom

  1. ArrayList類繼承於AbstractList抽象類
  2. ArrayList類實現了List、RandomAccess、Cloneable、Serializable接口

繼續分析一下：源碼分析

  • AbstractList抽象類其實已經實現了Collection接口中大部分方法
  • 實現了RandomAccess接口，因此支持任意性訪問（隨機訪問）
  • 實現了Cloneable接口，說明重寫了 clone()方法，支持拷貝（Cloneable 接口只是個合法調用 clone() 的標識（marker-interface)，一個對象想調用clone()方法，則該類必須實現Cloneable 接口，不然會報錯 CloneNotSupportedException ）
  • 實現了Serializable接口，支持序列化操做

3. 成員變量

源代碼以下所示：學習

private static final long serialVersionUID = 8683452581122892189L;

    /**
     * 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.
     */
    transient Object[] elementData; // non-private to simplify nested class access

    
    private int size;

初步思考：ui

  1. 一共有6個變量，各自的做用？this

  2. 有兩個空數組，只是命名不同，爲何？線程

繼續分析：翻譯

  1. 各個變量的做用：
    • serialVersionUID： 序列化版本號
    • DEFAULT_CAPACITY：默認容量大小
    • EMPTY_ELEMENTDATA：空數組時的引用
    • DEFAULTCAPACITY_EMPTY_ELEMENTDATA：初始化時默認的空數組
    • elementData：實際存儲集合元素的數組
    • size：實際元素的數量（int類型默認值爲0）
  2. 兩個空數組：
    • 分別用於默認初始化和傳入容量時的初始化

4. 構造方法

源代碼以下所示：

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

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

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

初步思考：

  1. 提供了三個構造方法
  2. 分別對應無參構造、指定集合容量的構造以及經過Collection的子類來構造一個ArrayList對象

繼續分析：

  1. 無參構造：

    • 直接將DEFAULTCAPACITY_EMPTY_ELEMENTDATA的空數組賦值給elementData（注意：此時ArrayList的數組長度仍是0）

  2. 指定容量構造：

    • 參數大於0： 建立一個該參數大小的數組，賦值給elementData
    • 參數等於0： 將成員變量EMPTY_ELEMENTDATA數組賦值給elementData
    • 參數小於0： 拋出異常

  3. 傳入Collection子類對象構造：

    public ArrayList(Collection<? extends E> c) {
        /**
        *將傳入的集合轉換爲一個Object類型的數組，並將此數組的引用賦給elementData
        */
        elementData = c.toArray();
        if ((size = elementData.length) != 0) {// 轉換後的數組不爲空時
            /**
            * 判斷轉換後的數組是否是Object[]數組
            * 若是不是的話，就把它複製爲一個Object[]數組，進行賦值
            */
            if (elementData.getClass() != Object[].class)
                elementData = Arrays.copyOf(elementData, size, Object[].class);
        } else {
            // 轉換後的數組爲空，用成員變量EMPTY_ELEMENTDATA來輔助
            this.elementData = EMPTY_ELEMENTDATA;
        }
    }

    toArray()方法源代碼以下:

    public Object[] toArray() {
        return Arrays.copyOf(elementData, size);
    }

    Arrays類的copyOf()方法源代碼以下：

    @SuppressWarnings("unchecked")
    public static <T> T[] copyOf(T[] original, int newLength) {
        // 此處的copyOf()調用了本類的重載方法
        return (T[]) copyOf(original, newLength, original.getClass());
    }

    重載方法源代碼以下所示：

    public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
        @SuppressWarnings("unchecked")
        T[] copy = ((Object)newType == (Object)Object[].class)
            ? (T[]) new Object[newLength]
            : (T[]) Array.newInstance(newType.getComponentType(), newLength);
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
    }

    代碼分析：

    • 使用三元運算符進行判斷傳入數組的類型

    • 若是傳入的數組類型強轉爲Object[]數組爲true，則建立一個Object[newLength]數組賦值給copy

    • 若是爲false，則利用反射獲取到傳入數組的類型，建立一個該類型的指定長度的數組賦值給copy

  • 調用native方法進行賦值

  • 最後返回copy

    調用鏈最後調用到了native方法上：

    public static native void arraycopy(Object src,  int  srcPos,Object dest, int destPos,
                                        int length);
/**
* 參數說明：
* src：源對象 
* srcPos：源數組中的起始位置 
* dest：目標數組對象 
* destPos：目標數據中的起始位置 
* length：要拷貝的數組元素的數量
*/

源代碼中最後都調用到了native方法，只能看到方法名和參數，看不到具體的實現，對native方法作個簡單的介紹吧。

native聲明的接口方法： Java代碼和本地C代碼進行互操做的API，稱爲Java Native Interface (Java本地接口)。也就是說，帶有native標記的方法，都是使用C語言來實現的，讀者瞭解到這裏便可，感興趣的能夠去查閱下相關資料，這裏就很少闡述了。

5. 經常使用方法分析

  • add(E e)

源代碼以下所示：

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

初步分析：

  1. 調用一個ensureCapacityInternal()方法，ensure Capacity Internal 直接谷歌翻譯，意思是確保內部容量，此方法內應該就隱藏着ArrayList動態擴容的方法了！
  2. 將傳入參數e，賦值給elementData[]數組中下標爲size++的元素
  3. 返回true

繼續跟蹤ensureCapacityInternal()方法，該方法相關源代碼以下所示：

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

        ensureExplicitCapacity(minCapacity);
    }

分析：

  1. 先對elementData數組進行空數組判斷，注意：這裏是直接使用 ==運算符來進行判斷的，回顧下前面講到的ArrayList的無參構造方法
public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

發現了沒？若是使用默認的構造方法，調用的是DEFAULTCAPACITY_EMPTY_ELEMENTDATA空數組，執行add()方法以前，ArrayList數組的長度都是零，添加第一個元素後，數組的長度就變爲10了。

  1. 下一個方法是ensureExplicitCapacity()，咱們繼續跟蹤。

該方法源代碼以下所示：

private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

初步分析：

  • 出現了一個前面沒看到的變量modCount
  • 裏面還有一個grow()方法，ArrayList可以動態擴容的緣由就在這個方法裏面了，八九不離十了！grow這個單詞我仍是認識的，哈哈哈~~~

繼續分析：

  1. 通過追蹤，發現modCount是ArrayList 的父類AbstractList的一個成員變量，做用是記錄ArrayList的size變化，添加元素時，該變量會自增一次。
  2. minCapacity變量是要添加元素在elementData數組裏的索引，當該變量值超過elementData數組長度的時候，elementData數組就要進行動態擴容了！

接下來，看下grow()方法的源代碼，立刻就要揭開ArrayList可以動態擴容的根本緣由了，想一想還有些激動，哈哈~

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. 將當前未添加新元素的elementData的數組長度賦值給oldCapacity變量，表示舊數組的容量

  2. 定義一個變量newCapacity，表示新數組的容量，新數組的容量大小爲舊數組容量的1.5倍

    • 此處用到了移位操做，>>是移位運算符，表示帶符號數右移
    • 向右移動n位，等同於除以2的n次方

  3. 此處須要注意一個地方，若是oldCapacity + (oldCapacity >> 1)執行的結果超過了int的最大值，即2的31次方減1，那麼新數組的長度將變爲負數

  4. 下面就是比較新數組容量和舊數組的容量，將較大的容量賦值給新數組

  5. 若是新數組的容量大小超過了定義的MAX_ARRAY_SIZE大小，那麼將調用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;
    }

  • 傳入的容量是負數，考慮到了數值溢出，拋出異常

  • 傳入的容量超過了MAX_ARRAY_SIZE大小，則將Integer.MAX_VALUE的值進行返回，不然返回MAX_ARRAY_SIZE

  1. 最後調用Arrays.copyOf()方法，將舊數組複製到新數組中，至此便完成了數組的動態擴容

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

基於add()方法的分析，分析以下：

  1. 判斷索引是否越界
  2. 複製數組，進行移動
  3. 將傳入參數賦值給指定下標的數組元素
  4. 集合長度加1

rangeCheckForAdd()方法源代碼以下所示：

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

分析以下：

  • 索引的上限是實際元素的長度，下限是0
  • 超過這兩個邊界值就會拋出異常

注意：因爲此處判斷範圍上限取的實際元素的個數，那麼就會形成一個狀況，咱們使用指定容量的構造方法，建立了一個ArrayList對象，而後使用add（int index, E element）方法時，當添加的index不是0時，就會報錯

舉例以下：

public static void main(String[] args) {
		
		List<String> a = new ArrayList<>(12);// 初始化指定了數組的容量爲12
		a.add(5, "element");
		
	}
//結果以下：
//  Exception in thread "main" java.lang.IndexOutOfBoundsException: Index: 5, Size: 0
//	 at java.util.ArrayList.rangeCheckForAdd(ArrayList.java:661)
//	 at java.util.ArrayList.add(ArrayList.java:473)
//	 at test.TestAddArrayList.main(TestAddArrayList.java:11)

  • get(int index)

源代碼以下所示：

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: "+index+", Size: "+size
    • 當index爲負數時的報錯提示信息則是：index，僅僅只是顯示你訪問的index值
  2. 調用elementData()方法，直接返回對應索引位置的元素

  • remove(int index)

源代碼以下所示：

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. 首先對index進行判斷是否在正確的範圍內
  2. 移除元素使得數組長度發生了變化，因此modCount++
  3. 計算須要移動的元素個數
  4. 調用arraycopy()方法進行數組元素的複製和移動
  5. 將數組實際長度的最後一位元素賦值爲null，方便GC進行回收
  6. 最後返回索引位置的元素

不難看出，移除元素實際上也是數組的複製和移動。

  • indexOf(Object o)

源碼以下所示：

public int indexOf(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;
    }

indexOf方法是返回某元素在ArrayList對象裏的下標（索引）。

分析：

  1. 區分兩種狀況

  2. 查詢元素爲null時，使用==運算符進行判斷，返回索引

  3. 非null元素時，使用equals()方法來判斷（ps:由此處調用的equals()方法，能夠看出爲何不支持基本類型的元素）

  4. 當查詢的元素不存在列表中，返回-1

ArrayList中還有不少方法，篇幅有限，在此再也不贅述。

6. 總結

ArrayList是開發中用的最多了一個集合類了，不少時候咱們只是停留在使用上面，沒有深刻的去學習，分析，爲何是這樣？爲何會這樣？有時候遇到問題了，也只能兩眼一抹黑，不知道具體緣由是什麼，多看源碼，多學習，提升解決問題的能力，一點點的進步，就好。

相關文章
相關標籤/搜索
每日一句
    每一个你不满意的现在，都有一个你没有努力的曾经。
本站公眾號
   歡迎關注本站公眾號,獲取更多信息
聯繫我們 最近搜索 最新文章 沪ICP备13005482号-10 MyBatis教程 SQL 教程 MySQL教程 Java 教程 Thymeleaf 教程 Hibernate教程 Spring教程 Redis教程