ArrayList原始碼分析

c5p1ng發表於2021-03-07
原始碼

ArrayList簡介

ArrayList是一個陣列佇列，相當於動態陣列。與Java中的陣列相比，它的容量能動態增長。它的繼承關係如圖所示：

和Vector不同，ArrayList中的操作是非執行緒安全的。

ArrayList屬性

ArrayList屬性主要就是當前陣列長度size，以及存放陣列的物件elementData陣列，除此之外還有一個經常用到的屬性就是從AbstractList繼承過來的modCount屬性，代表集合修改次數。

/**
 * 預設初始的容量
 */
private static final int DEFAULT_CAPACITY = 10;
/**
 * 一個空物件
 */
private static final Object[] EMPTY_ELEMENTDATA = {};
/**
 * 一個空物件，如果使用預設建構函式建立，則預設物件內容就是該值
 */
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
/**
 * 當前資料物件存放地方，該物件不參與序列化
 */
transient Object[] elementData;
/**
 * 當前陣列長度
 */
private int size;
/**
 * 陣列最大長度
 */
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

ArrayList建構函式

帶int型別的建構函式

如果傳入引數小於0，則丟擲異常，否則將使用該長度初始化陣列物件

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

帶Collection物件的建構函式

  • 將collection物件轉換成陣列，然後將陣列的地址賦給elementData。
  • 更新size的值，同時判斷size的大小，如果是size等於0，直接將空物件EMPTY_ELEMENTDA他的地址賦給elementData。
  • 如果size的值大於0，則執行Arrays.copy方法，把collection物件的內容（可以理解為深度拷貝）copy到elementData中。
  • 注意：elementData = c.toArray();這裡執行的簡單賦值是淺拷貝，所以要執行Arrays.copy做深拷貝。
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;
    }
}

Add方法

add(E e)方法

add主要的執行邏輯如下：

  • 修改次數modCount標識自增1，如果當前陣列已使用長度（size）加1之後大於當前陣列長度，則呼叫grow方法，增長陣列，grow方法會將當前陣列的長度變成原來容量的1.5倍。
  • 確保新增的資料有地方儲存之後，則將新元素新增到位於size的位置上。
  • 返回新增成功布林值。
    新增元素方法入口：
public boolean add(E e) {
    ensureCapacityInternal(size + 1);
    elementData[size++] = e;
    return true;
}

確保新增的元素有地方儲存，當第一次新增元素的時候size+1的值為1，所以第一次新增的時候會將當前elementData陣列的長度變成10：

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

將修改次數（modCount）自增1，判斷是否需要擴充陣列長度，判斷條件就是用當前所需的陣列最小長度與陣列的長度對比，如果大於0，則增長陣列長度：

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

如果當前陣列已使用空間（size）加1之後大於陣列長度，則增大陣列容量，擴大為原來的1.5倍：

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

add(int index, E element)方法

這個方法其實和add類似，該方法可以指定位置插入元素，具體的執行邏輯如下：

  • 確保index資料的合法性。
  • 確保陣列已使用長度+1後足夠存下下一個資料。
  • 修改次數標識自增1，如果當前陣列已使用長度（size）+1後大於當前陣列長度，則呼叫grow方法，增長陣列。
  • grow方法會將當前陣列的長度變成原來的1.5倍。
  • 確保有足夠的容量之後，使用System.arraycopy將需要插入的位置（index）後面的元素統統往後移動一位。
  • 將新的資料內容存放到指定位置（index）上。
public void add(int index, E element) {
    rangeCheckForAdd(index);
    ensureCapacityInternal(size + 1);
    System.arraycopy(elementData, index, elementData, index + 1, size - index);
    elementData[index] = element;
    size++;
}

get方法

返回指定位置上的元素：

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

set方法

確保set的位置小於當前陣列的長度（size）並且大於0，設定新元素並且返回久元素內容：

public E set(int index, E element) {
    rangeCheck(index);
    E oldValue = elementData(index);
    elementData[index] = element;
    return oldValue;
}

contains方法

呼叫indexOf方法，遍歷陣列中的每一個元素作對比，找到返回true，否則返回false：

public boolean contains(Object o) {
    return indexOf(o) >= 0;
}

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

remove方法

根據索引remove

  • 判斷索引有沒有越界
  • 自增修改次數
  • 將指定位置（index）上的元素儲存到oldValue
  • 將指定位置（index）上後面的元素都往前移動一位
  • 將最後面的一個元素置空，好讓垃圾回收器回收
  • 將原來的值oldValue返回
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;
    return oldValue;
}

注意：呼叫這個方法不會縮減陣列的長度，只是將最後一個陣列元素置空而已。
根據物件remove
迴圈遍歷所有物件，得到物件所在索引位置，然後呼叫fastRemove方法，執行remove操作，最後返回成功失敗：

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

clear方法

新增操作次數（modCount），將陣列內的元素都置空，等待垃圾收集器收集，不減小陣列容量：

public void clear() {
    modCount++;
    for (int i = 0; i < size; i++)
        elementData[i] = null;
    size = 0;
}

sublist方法

ArrayList類裡面的一個內部類SubList物件，傳入的值中第一個引數是this引數，其實可以理解為返回當前list的部分檢視，真實指向的存放資料內容的地方還是同一個地方，如果修改了sublist返回的內容的話，那麼原來的list也會變動：

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

trimToSize方法

  • 修改次數加1。
  • 將elementData中空餘的空間（包括null值）去除。
public void trimToSize() {
    modCount++;
    if (size < elementData.length) {
        elementData = (size == 0) ? EMPTY_ELEMENTDATA : Arrays.copyOf(elementData, size);
    }
}

iterator方法

interator方法返回的是一個內部類，由於內部類的建立預設含有外部的this指標，所以這個內部類可以呼叫到外部類的屬性。

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

一般的話，呼叫完iterator之後，我們會使用iterator做遍歷，這裡使用next做遍歷的時候有個需要注意的地方，就是呼叫next的時候，可能會引發ConcurrentModificationException，當修改次數，與期望的修改次數（呼叫iterator方法時候的修改次數）不一致的時候，會發生該異常，詳細我們看一下程式碼實現：

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

expectedModCount這個值是在使用者呼叫ArrayList的iterator方法時候確定的，但是在這之後使用者add，或者remove了ArrayList的元素，那麼modCount就會改變，那麼這個值就會不相等，將會引發ConcurrentModificationException異常，這個是在多執行緒使用情況下，比較常見的一個異常。

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

小結

ArrayList總體來說比較簡單，不過它有以下一些特點：

  • ArrayList自己實現了序列化和反序列化的方法，因為它自己實現了 private void writeObject(java.io.ObjectOutputStream s)和 private void readObject(java.io.ObjectInputStream s) 方法。
  • ArrayList基於陣列方式實現，無容量的限制（會擴容）。
  • 新增元素時可能要擴容（所以最好預判一下），刪除元素時不會減少容量（若希望減少容量，trimToSize()），刪除元素時，將刪除掉的位置元素置為null，下次gc就會回收這些元素所佔的記憶體空間。
  • 執行緒不安全。
  • get(int index)：獲取指定位置上的元素時，可以通過索引直接獲取（O(1)）。
  • remove(int index)不需要遍歷陣列，只需判斷index是否符合條件即可，效率比remove(Object o)高。
  • contains(E)需要遍歷陣列。
  • 使用iterator遍歷可能會引發多執行緒異常。

相關文章