【Java 容器】ArrayList 源碼解析

時間 2020-01-27

標籤 Java 容器 arraylist 源碼解析欄目 Java 简体版

原文原文鏈接

這是 2020 年的第一篇文章！今天，你學習了嗎？html

ArrayList 是最經常使用的 List 實現類，今天咱們從源碼角度來分析一下這個類。java

1、基本結構

首先，咱們來看一下 ArrayList 的繼承關係，這是一個 UML 圖：git

對於 ArrayList，咱們一般是這樣使用的：面試

List<Object> list = new ArrayList<>();
複製代碼

下面咱們簡單看一下接口概要：數組

public class ArrayList<E> extends AbstractList<E> implements List<E>, RandomAccess, Cloneable, java.io.Serializable {
	// ...
}
複製代碼

ArrayList 繼承了 AbstractList 這個抽象類，實現了 List，RandomAccess，Cloneable 和序列化接口。安全

這裏須要注意一下 RandomAccess 接口，這個接口沒有任何方法，實現這個接口即意味着支持快速隨機訪問（下標訪問）。快速隨機訪問速度 > 迭代器遍歷速度。多線程

快速隨機訪問的速度是固定的，好比 ArrayList 的 set(i, e), get(i) 等方法，其時間複雜度都是 O(1)dom

2、屬性

查看 ArrayList 源碼，咱們看到它主要有以下一些屬性，關於這些屬性的描述都標註下面了：ide

// 默認初始化容量
private static final int DEFAULT_CAPACITY = 10;
// 用於空實例的共享空數組實例
private static final Object[] EMPTY_ELEMENTDATA = {};
// 用於默認大小空實例的共享空數組實例，與 EMPTY_ELEMENTDATA 的區別在於前者知道當第一個元素插入時該如何擴充數組
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
// 存儲這個 ArrayList 元素的數組。ArrayList 的容量就是這個數組的長度。任何空 ArrayList，若是其 elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA，則當添加第一個元素時，ArrayList 會擴容到 DEFAULT_CAPACITY 大小。
transient Object[] elementData;
// ArrayList 的大小，指元素的個數
private int size;
// 數組可分配的最大大小
// 某些虛擬機在一個數組裏保留了一些標題字。嘗試分配更大的數組可能會致使 OutOfMemoryError
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
複製代碼

從基本屬性能夠看出， ArrayList 的底層是基於數組的！post

即 Object[] elementData 這個屬性

這裏須要注意一點：

size 是實際元素數量，即 list.size()
elementData.length 是存儲元素的數組的長度，通常是 >= size 的

3、三個構造器

平時使用 ArrayList，我我的習慣這樣構造：

List<Integer> list = new ArrayList<>();
複製代碼

實際上，ArrayList 有三個構造器：默認構造器、帶初始化容量參數的構造器、帶集合參數的構造器

默認構造器

// 使用默認容量 10 構造一個空的 List 
public ArrayList() {
  // 這裏能夠看到使用了屬性 DEFAULTCAPACITY_EMPTY_ELEMENTDATA
	this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
}
複製代碼

帶初始化容量的構造器

public ArrayList(int initialCapacity) {
        if (initialCapacity > 0) {
            // 構建指定容量的數組
            this.elementData = new Object[initialCapacity];
        } else if (initialCapacity == 0) {
            // 使用 EMPTY_ELEMENTDATA
            this.elementData = EMPTY_ELEMENTDATA;
        } else {
            // 負數，拋出 IllegalArgumentException
            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);
        }
    }
複製代碼

帶集合參數的構造器

// 構造一個包含指定集合元素的 list，元素順序按照集合的迭代器返回的順序
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;
    }
}
複製代碼

EMPTY_ELEMENTDATA 與 DEFAULT_EMPTY_ELEMENTDATA

二者的區別在於，使用前者時，當添加第一個元素時，elementData.length = 1；而當使用後者時，會調用 ensureCapacityInternal 方法，使 elmentData.length = DEFAULT_CAPACITY = 10

注意，擴容發生在實際插入元素的時候！使用前兩個構造器，elementData 仍是空數組。

下面重點總結一下 ArrayList 的擴容機制。

4、擴容機制

4.1 爲何要擴容？

我的理解是，當初始化 ArrayList 時，JVM 並不知道程序會存多少數據進去，而數組又必須在初始化時就聲明其容量，這樣就形成一個問題，最遲在第一個元素插入時，必須指定數組容量大小、初始化數組以容納元素。（ArrayList 實際上也正是這麼作的！）

那麼，程序怎麼知道你到底須要多大的容量呢？1 仍是 100w ？

最好的辦法是能夠動態擴容！

ArrayList 就實現了這個擴容功能，咱們能夠調用方法主動擴容，也可讓 ArrayList 本身擴容。下面來說一下 ArrayList 的擴容具體是怎麼實現的。這個講解主要是針對源碼的分析。

4.2 擴容的實現

ArrayList 的擴容是由下面這段代碼實現的，我已經加上了註釋：

// 擴容 ArrayList 實例，使其至少能放下 minCapacity 個元素
    public void ensureCapacity(int minCapacity) {
        int minExpand = (elementData != DEFAULTCAPACITY_EMPTY_ELEMENTDATA)
            // any size if not default element table
            ? 0
            // larger than default for default empty table. It's already
            // supposed to be at default size.
            : DEFAULT_CAPACITY;

        if (minCapacity > minExpand) {
            ensureExplicitCapacity(minCapacity);
        }
    }

    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

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

	// 確保明確的容量
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++; // 注意，這裏遞增了 modCount

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

    // 擴容，以確保該 elementData 數組的大小至少能容納 minCapacity 個元素
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1); // 即擴容到 1.5 倍，等價於 n = o + o/2
        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);
    }

	// 能夠擴容的最大容量，當想要擴容的容量大於 MAX_ARRAY_SIZE 時調用
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }
複製代碼

能夠看到，實際擴容方法是：grow(int minCapacity)。最關鍵的一行代碼是：

int newCapacity = oldCapacity + (oldCapacity >> 1); // 等價於 n = o + o/2
複製代碼

這裏使用位運算，它的速度很是快！

總結，ArrayList 的擴容是每次擴容到原大小的 1.5 倍。

那麼，什麼時候進行擴容呢？

4.3 什麼時候擴容

從 public void ensureCapacity(int minCapacity) 能夠看出，咱們能夠主動調用該方法進行擴容。

此外，在調用 add/addAll 等添加元素的方法時，ArrayList 也會調用內部擴容方法（ensureCapacityInternal）來主動擴容。以 add 方法爲例：

// 追加元素 e 到 list 的末尾
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // 咱們主要，ensureCapacityInternal 這個方法會調用 ensureExplicitCapacity 這個方法，後者中一行代碼 modCount++
        elementData[size++] = e;
        return true;
    }
複製代碼

在上面的擴容方法，以及後面會提到的 add 等方法中，都利用了數組的底層方法。畢竟 ArrayList 是基於數組的嘛！下面咱們來看一下這個數組的底層方法具體是什麼意思？

5、數組底層方法

咱們在 ArrayList 的源碼中能夠看到出現了兩個有關數組複製操做的方法，一個是 Arrays 類中的 Arrays.copyOf 方法，一個是 System.arraycopy 方法，觀察源碼，前者是基於後者的：

5.1 Arrays.copyOf 方法

// 複製指定的數組，截斷或填充 null 值使其達到指定長度
// 返回值與 original 數組具備相同的值
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 方法
        System.arraycopy(original, 0, copy, 0,
                         Math.min(original.length, newLength));
        return copy;
}
複製代碼

5.2 System.arraycopy 方法

public static native void arraycopy(Object src, int srcPos, Object dest, int destPos, int length);
複製代碼

詳細解釋一下：

從原數組指定位置，拷貝數據到目標數組。拷貝從原數組的 srcPos 位置開始，拷貝到目標數組的 destPos 位置，拷貝長度爲 length，即拷貝從原數組的 srcPos 到 srcPos+length-1，拷貝到目標數組的 destPos 到 destPos+length-1
若是原數組和目標數組指向同一個數組對象，則首先拷貝到一個臨時數組，而後把臨時數組拷貝到原數組中
參數：src - 原數組，srcPos - 原數組的拷貝開始位置；dest - 目標數組， destPos - 拷貝到目標數組的開始位置，length - 要拷貝的數組元素的數量

6、一個問題

看敖冰冰的文章，裏面提到了這樣一個問題：使用 public ArrayList(int initialCapacity) 這個構造器構建 ArrayList 時，什麼時候初始化數組？

經過源碼能夠看到，在構造器被調用時，就初始化了數組！

this.elementData = new Object[initialCapacity];
複製代碼

可是，咱們須要注意了！這個時候還不能調用 list.get(i) 和 set(i, e) 方法。

嗯？嗯？嗯？！！

緣由很簡單，list 的 size 此時仍是 0 ！

而 ArrayList 添加元素、獲取元素的操做都會對數組的邊界值（index 和 size 的關係）進行檢查。

好比 get(i) 方法：

public E get(int index) {
    rangeCheck(index);
    return elementData(index);
}
複製代碼

rangCheck 方法會檢查 index 和 size 之間的關係，若是 index >= size，就會拋出異常：

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

好比：

public static void main(String[] args) {
        List<Integer> list = new ArrayList<>(10);
        Integer a = list.get(0);
        System.out.println(a);
}
複製代碼

運行這段代碼，會報如下異常：

Exception in thread "main" java.lang.IndexOutOfBoundsException: Index: 0, Size: 0
	at java.util.ArrayList.rangeCheck(ArrayList.java:657)
	at java.util.ArrayList.get(ArrayList.java:433)
	at com.aegis.MapTest.main(MapTest.java:13)
複製代碼

下面咱們來總結一下 ArrayList 裏的經常使用方法：

7、經常使用方法

下面是 ArrayList 源碼中 public 方法的總結，目前不涉及 JDK 8 相關部分。

7.1 基本

void trimToSize()

修改 ArrayList 實例的容量爲當前 list.size()，即當前元素個數。使用這個方法可使得 ArrayList 容量最小化

public void trimToSize() {
    modCount++;
    if (size < elementData.length) {
        elementData = (size == 0)
          ? EMPTY_ELEMENTDATA
          : Arrays.copyOf(elementData, size);
    }
}
複製代碼

int size()

返回 ArrayList 的大小。指具體元素的大小，而不是 elementData 數組的大小！

public int size() {
	return size;
}
複製代碼

boolean isEmpty()

若是 list 中沒有元素，返回 true

public boolean isEmpty() {
    return size == 0;
}
複製代碼

boolean contains(Object o)

斷定是否包括某個元素；調用了 indexOf 方法來斷定

public boolean contains(Object o) {
        return indexOf(o) >= 0;
}
複製代碼

int indexOf(Object o)

返回指定元素出現的第一個位置 index；若是不存在，則返回 -1

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;
}
複製代碼

int lastIndexOf(Object o)

返回指定元素最後一次出現的位置；若是不存在，就返回 -1
其實是數組的倒序遍歷

public int lastIndexOf(Object o) {
    if (o == null) {
        for (int i = size-1; i >= 0; i--)
            if (elementData[i]==null)
                return i;
    } else {
        for (int i = size-1; i >= 0; i--)
            if (o.equals(elementData[i]))
                return i;
    }
    return -1;
}
複製代碼

Object clone()

返回一個數組的淺拷貝
這裏的淺拷貝不是指 List 自己，而是 List 中的元素。這裏的淺拷貝是 Arrays.copyof 方法形成的。

public Object clone() {
        try {
            ArrayList<?> v = (ArrayList<?>) super.clone();
            v.elementData = Arrays.copyOf(elementData, size);
            v.modCount = 0;
            return v;
        } catch (CloneNotSupportedException e) {
            // 這是不該該發生的，由於 ArrayList 實現了 Clone 接口，即 Cloneable 的
            throw new InternalError(e);
        }
    }
複製代碼

public void clear()

從 list 中刪除全部元素

public void clear() {
    modCount++;

    // clear to let GC do its work
    for (int i = 0; i < size; i++)
        elementData[i] = null;

    size = 0;
}
複製代碼

7.2 toArray

Object[] toArray()

返回包括這個 list 中全部元素的數組，元素的順序以 Iterator 返回的順序爲準。
這個方法是 array 和 collection 相互轉換的橋樑

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

T[] toArray(T[] a)

以指定數組的類型返回包括這個 list 中全部元素的數組
若是數組 a 可以容納這個 list 的元素，則將元素拷貝到這個數組中；不然，拷貝元素到一個新數組，其運行時類型由指定數組肯定。
若是數組 a 大於 list ，則 a[list.size()] = null

public <T> T[] toArray(T[] a) {
	if (a.length < size)
  	// Make a new array of a's runtime type, but my contents:
    return (T[]) Arrays.copyOf(elementData, size, a.getClass());
  System.arraycopy(elementData, 0, a, 0, size);
  if (a.length > size)
  	a[size] = null;
  return a;
}
複製代碼

7.3 get/set/remove

E get(int index)

獲取 list 中指定位置的元素

public E get(int index) {
  	// 範圍檢查，若是 index 超出 list 大小，就拋出 IndexOutOfBoundsException
    rangeCheck(index);

    return elementData(index);
}
複製代碼

E set(int index, E element)

使用指定元素 element 替換指定位置 index 處的元素
返回原來的元素

public E set(int index, E element) {
  	// 檢查邊界
    rangeCheck(index);

  	// 舊的元素
    E oldValue = elementData(index);
    // 設置 index 處爲新元素 element
  	elementData[index] = element;
    return oldValue;
}
複製代碼

boolean add(E e)

在 list 末尾添加元素。若是成功就返回 true

public boolean add(E e) {
    // 檢查容量 - 便是否須要擴容
  	ensureCapacityInternal(size + 1);  // Increments modCount!!
    // 將 size 位置設爲
  	elementData[size++] = e;
    return true;
}
複製代碼

void add(int index, E element)

在指定位置插入元素，並將原來的元素和其後的元素所有後移一位（index++）

public void add(int index, E element) {
  			// 檢查邊界
        rangeCheckForAdd(index);

  			// 檢查容量 - 如須要則擴容
        ensureCapacityInternal(size + 1);  // Increments modCount!!
  			// 將數組中 index 位置開始的數據，拷貝到 index+1 到 size 位置 
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
  			// 將 index 位置設爲新元素
        elementData[index] = element;
        size++;
    }
複製代碼

E remove(int index)

移除指定位置的元素，將後面的元素左移一位（index--）
返回刪除的元素

public E remove(int index) {
  	// 檢查邊界
    rangeCheck(index);

  	// 修改 modCount，以便 fail-fast 機制生效
    modCount++;
  	// 獲取 index 位置的元素 -- 即要被刪除的元素
    E oldValue = elementData(index);

    int numMoved = size - index - 1;
    if (numMoved > 0)
      	// 向左移動元素
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    // 將原先的最後一位設爲 null
    elementData[--size] = null; // clear to let GC do its work

    return oldValue;
}
複製代碼

boolean remove(Object o)

public boolean remove(Object o) {
    if (o == null) {
      	// 要刪除的對象爲 null，則尋找第一個 null 值
        for (int index = 0; index < size; index++)
            if (elementData[index] == null) {
              	// 調用 fastRemove
                fastRemove(index);
                return true;
            }
    } else {
      	// 
        for (int index = 0; index < size; index++)
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}
複製代碼

7.4 集合關聯操做

boolean addAll(Collection<? extends E> c)

將集合中全部元素按照迭代器返回的順序，添加在 list 的末尾
若是 list 被改變，就返回 true

public boolean addAll(Collection<? extends E> c) {
    // 集合轉數組
    Object[] a = c.toArray();
    int numNew = a.length;
    // 確保容量
    ensureCapacityInternal(size + numNew);  // Increments modCount
    // 從數組拷貝元素到 list 中
    System.arraycopy(a, 0, elementData, size, numNew);
    size += numNew;
    return numNew != 0;
}
複製代碼

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

從指定位置開始插入集合 c 中的元素，這些新元素的位置是按照集合的迭代器的返回順序，直到全部元素插入完畢。並將以前的元素後移。

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;
}
複製代碼

boolean removeAll(Collection<?> c)

刪除集合 c 中在 list 中的相同元素。若是 list 發生改變，就返回 true

public boolean removeAll(Collection<?> c) {
    Objects.requireNonNull(c);
    return batchRemove(c, false);
}
複製代碼

boolean retainAll(Collection<?> c)

刪除 list 中不包括在集合 c 中的全部元素

public boolean retainAll(Collection<?> c) {
    Objects.requireNonNull(c);
    return batchRemove(c, true);
}
複製代碼

7.5 迭代器

List 返回的迭代器是 ListIterator 接口，比默認的 Iterator，多出了 hasPrevious 和 previous 方法。

ArrayList 中有兩個 ListIterator 的實現類：ListItr 和 Itr。區別就是前者具備修改元素的 set 和 add 方法

listIterator

返回這個 list 的元素的一個 list 迭代器，元素開始於指定位置。

public ListIterator<E> listIterator(int index) {
    if (index < 0 || index > size)
        throw new IndexOutOfBoundsException("Index: "+index);
    return new ListItr(index);
}
複製代碼

返回這個 list 的元素的一個 list 迭代器，元素從 0 位置開始

public ListIterator<E> listIterator() {
    return new ListItr(0);
}
複製代碼

iterator

返回這個 list 的迭代器

public Iterator<E> iterator() {
    return new Itr();
}
複製代碼

ListItr 和 Itr 內部類

Itr 和 ListItr 的區別就是後者具備修改元素的方法 set 和 add

7.6 subList

返回這個這個 list 的子視圖，[fomIndex, toIndex)
注意，subList 返回的子 list 和原 ArrayList 指向的是同一個數組。即，對子 list 的操做也會同步映射在原 ArrayList 上，反之亦然。

public List<E> subList(int fromIndex, int toIndex) {
    subListRangeCheck(fromIndex, toIndex, size);
    return new SubList(this, 0, fromIndex, toIndex);
}
複製代碼