ArrayList源碼分析

前言：作為一個常用的List接口實現類，日常開發過程中使用率非常高，因此有必要對其原理進行分析。

注：本文jdk源碼版本為jdk1.8.0_172

---

1.ArrayList介紹

ArrayList底層數據結構是數組（數組是一組連續的內存空間），默認容量為10，它具有動態擴容的能力，線程不安全，元素可以為null。

筆者在一次使用ArrayList的時候引起了一次線上OOM，分析傳送門：記一次ArrayList產生的線上OOM問題

java.lang.Object
   ↳     java.util.AbstractCollection<E>
         ↳     java.util.AbstractList<E>
               ↳     java.util.ArrayList<E>

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

2.主要源碼分析

add(e)：

 public boolean add(E e) {
        // 確認容量
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        // 直接將元素添加在數組中
        elementData[size++] = e;
        return true;
}
    
 private void ensureCapacityInternal(int minCapacity) {
    // 進一步確認ArrayList的容量，看是否需要進行擴容
    ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
}

private static int calculateCapacity(Object[] elementData, int minCapacity) {
   // 如果elementData為空，則返回默認容量和minCapacity中的最大值
   if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
        return Math.max(DEFAULT_CAPACITY, minCapacity);
    }
    // 否則直接返回minCapacity
    return 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;
    // 擴容，相當於擴大為原來的1.5倍
    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);
}

    

分析：

其實add方法整體邏輯還是比較簡單。主要注意擴容條件：只要插入數據size比原來大就會進行擴容。因此如果在循環中使用ArrayList時需要特別小心，避免頻繁擴容造成OOM異常。

add(int index, E element)：

public void add(int index, E element) {
        // 越界檢查
        rangeCheckForAdd(index);
        
        // 確認容量
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        // 將index及其之后的元素往后移動一位，將index位置空出來
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        // 在index插入元素
        elementData[index] = element;
        // 元素個數自增
        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];
}

分析：

get操作簡單，理解容易。

remove(index):

public E remove(int index) {
    // 越界檢查
    rangeCheck(index);
    
    // 修改次數自增
    modCount++;
    // 獲取對應index上的元素
    E oldValue = elementData(index);
    
    // 判斷index是否在最后一個位置
    int numMoved = size - index - 1;
    // 如果不是，則需要將index之后的元素往前移動一位
    if (numMoved > 0)
        System.arraycopy(elementData, index+1, elementData, index,
                         numMoved);
    // 將最后一個元素刪除，幫助GC
    elementData[--size] = null; // clear to let GC do its work

    return oldValue;
}

分析：

remove邏輯還是比較簡單，但是這里需要注意一點是ArrayList在remove的時候，並沒有進行縮容。

remove(o):

public boolean remove(Object o) {
    // 如果被移除元素為null
    if (o == null) {
        // 循環遍歷
        for (int index = 0; index < size; index++)
            // 注意這里判斷null是用的“==”
            if (elementData[index] == null) {
                // 快速remove元素
                fastRemove(index);
                return true;
            }
    } else {
        for (int index = 0; index < size; index++)
            // 這里判斷相等是用的equals方法，注意和上面對比
            if (o.equals(elementData[index])) {
                fastRemove(index);
                return true;
            }
    }
    return false;
}

private void fastRemove(int index) {
    // 注意這里並未做越界檢查，畢竟叫fastRemove
    // 修改次數自增
    modCount++;
    // 判斷是否是最后一個元素，這里的操作和remove(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
}

分析：

remove元素的時候分為null和非null，並且是快速remove，並未做越界檢查。

retainAll：求交集

public boolean retainAll(Collection<?> c) {
    // 判空
    Objects.requireNonNull(c);
    // 批量remove complement為true表示保存包含在c集合的元素，這樣就求出交集了
    return batchRemove(c, true);
}

private boolean batchRemove(Collection<?> c, boolean complement) {
        final Object[] elementData = this.elementData;
        // 讀寫指針 讀指針遍歷，寫指針只有在條件符合時才自增，這樣不需要額外的空間
        int r = 0, w = 0;
        boolean modified = false;
        try {
            // 遍歷
            for (; r < size; r++)
                // 如果c集合中包含遍歷元素，則把元素放入寫指針位置(以complement為准)
                if (c.contains(elementData[r]) == complement)
                    elementData[w++] = elementData[r];
        } finally {
            // Preserve behavioral compatibility with AbstractCollection,
            // even if c.contains() throws.
            // 正常情況下，r與size是相等的，這里是對異常的判斷
            if (r != size) {
                // 將未讀的元素拷貝到寫指針后面
                System.arraycopy(elementData, r,
                                 elementData, w,
                                 size - r);
                w += size - r;
            }
            // 將寫指針后的元素全部置空
            if (w != size) {
                // clear to let GC do its work
                for (int i = w; i < size; i++)
                    elementData[i] = null;
                modCount += size - w;
                size = w;
                modified = true;
            }
        }
        return modified;
    }

分析：

將集合與另一個集合求交集，整體邏輯比較簡單的。通過讀寫指針進行操作，不用額外空間。注意complement為true，則將包含在c中的元素寫入相應位置。這樣就求出了交集，這里還要注意finally中的操作，異常與置空操作。

removeAll：求差集，但是這里只保留當前集合不在C中的元素，不保留C中不在當前集合中的元素。

  public boolean removeAll(Collection<?> c) {
        // 判空
        Objects.requireNonNull(c);
        // 批量remove，注意這里complement為false，表示保存不在c中的元素，這樣就求出差集了
        return batchRemove(c, false);
    }

分析：

邏輯和retainAll剛好相反，complement為false，保存不包含在C中的元素，這樣就求出差集了，注意這里是單向差集。

3.總結

以上分析了ArrayList的主要源碼，下面對其進行總結：

#1.ArrayList的底層數據結構為數組（數組是一組連續的內存空間），默認容量為10，線程不安全，可以存儲null值。

#2.ArrayList擴容條件，只要增加容量大於現有容量就會進行擴容，擴容量為原來的1.5倍，但是ArrayList不會進行縮容。

#3.ArrayList中有求交集（retainAll）和求差集（removeAll），注意這里的差集是單向交集。

---

by Shawn Chen，2019.09.14日，下午。