java基礎：ArrayList — 原始碼分析

Hiway發表於2018-12-16
Java原始碼

其他更多java基礎文章：
java基礎學習(目錄)

學習資料
ArrayList集合實現RandomAccess介面有何作用？

概述

ArrayList是可以動態增長和縮減的索引序列，它是基於陣列實現的List類。

public class ArrayList<E> extends AbstractList<E>
        implements List<E>, RandomAccess, Cloneable, java.io.Serializable
複製程式碼
  • ArrayList 繼承了AbstractList抽象類 為什麼要先繼承AbstractList，而讓AbstractList先實現List？而不是讓ArrayList直接實現List？這裡是有一個思想，介面中全都是抽象的方法，而抽象類中可以有抽象方法，還可以有具體的實現方法，正是利用了這一點，讓AbstractList是實現介面中一些通用的方法，而具體的類，如ArrayList就繼承這個AbstractList類，拿到一些通用的方法，然後自己在實現一些自己特有的方法，這樣一來，讓程式碼更簡潔，就繼承結構最底層的類中通用的方法都抽取出來，先一起實現了，減少重複程式碼。所以一般看到一個類上面還有一個抽象類，應該就是這個作用。
  • ArrayList 實現了List介面 這裡有個題外話。明明父類AbstractList也實現了List介面，那為什麼子類ArrayList還是去實現一遍呢？我在stackOverFlow中找到了答案，這裡其實很有趣。 Why does LinkedHashSet extend HashSet and implement Set。開發這個collection 的作者Josh說：這其實是一個mistake，因為他寫這程式碼的時候覺得這個以後會有用處，但是其實並沒什麼用，而且又因為沒什麼影響，JDK維護人員並不認為這是值得以後放棄的，就一直留到了現在。
  • ArrayList 實現了RandomAccess介面 這個是一個標記性介面，RandomAccess介面這個空架子的存在，是為了能夠更好地判斷集合選擇更優的遍歷方式，提高效能！實現了該介面的話，那麼使用普通的for迴圈來遍歷，效能更高，例如arrayList。而沒有實現該介面的話，使用Iterator來迭代，這樣效能更高，例如linkedList。所以這個標記性只是為了讓我們知道我們用什麼樣的方式去獲取資料效能更好。ArrayList集合實現RandomAccess介面有何作用？
  • ArrayList 實現了Cloneable介面： 實現了該介面，就可以使用Object.Clone()方法了。
  • ArrayList 實現了Serializable介面 實現該序列化介面，表明該類可以被序列化。

儲存結構

ArrayList的底層資料結構是一個Object陣列：

transient Object[] elementData;
複製程式碼

說明：底層的資料結構就是陣列，陣列元素型別為Object型別，即可以存放所有型別資料。我們對ArrayList類的例項的所有的操作底層都是基於陣列的。

基礎欄位

// 序列化時使用的版本號
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;
//elementData中已存放的元素的個數，注意：不是elementData的容量
private int size;
// 最大陣列容量
private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
複製程式碼

上面的elementData屬性採用了transient來修飾，表明其不使用Java預設的序列化機制來例項化，但是該屬性是ArrayList的底層資料結構，在網路傳輸中一定需要將其序列化，之後使用的時候還需要反序列化，那不採用Java預設的序列化機制，我們怎麼序列化它呢? 那就是使用writeObject和readObject方法。 這屬於序列化的知識，簡單說一下，如果目標類中沒有定義私有的writeObject或readObject方法，那麼序列化和反序列化的時候將呼叫預設的方法來根據目標類中的屬性來進行序列化和反序列化，而如果目標類中定義了私有的writeObject或readObject方法，那麼序列化和反序列化的時候將呼叫目標類指定的writeObject或readObject方法來實現。

方法細節

構造方法

    /**
     * Constructs an empty list with an initial capacity of ten.
     */
    public ArrayList() {
        //EMPTY_ELEMENTDATA：是個空的Object[]， 將elementData初始化，
        //空的Object[]會給預設大小10，會在add的時候賦值
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

  //根據傳入的容量建立ArrayList
    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);
        }
    }

    //建立一個ArrayList，資料為Collection的資料
    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;
        }
    }
複製程式碼

add方法

add方法是ArrayList的重點方法之一

public boolean add(E e) {    
    //確定內部容量是否夠了，size是陣列中資料的個數，因為要新增一個元素，所以size+1，
    //先判斷size+1的個數，這個陣列能否放得下
        ensureCapacityInternal(size + 1);  // Increments modCount!!
     //在資料中正確的位置上放上元素e，並且size++
        elementData[size++] = e;
        return true;
    }

//插入具體某個位置
public void add(int index, E element) {
        rangeCheckForAdd(index);//檢查index也就是插入的位置是否合理。

//跟上面的分析一樣，具體看上面
        ensureCapacityInternal(size + 1);  // Increments modCount!!
//這個方法就是用來在插入元素之後，要將index之後的元素都往後移一位，
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
//在目標位置上存放元素
        elementData[index] = element;
        size++;//size增加1
    }
複製程式碼

很明顯，ensureCapacityInternal方法是一個判斷陣列的長度是否滿足新增後size的方法，讓我們跟進看一下：

private void ensureCapacityInternal(int minCapacity) {
        if (elementData == EMPTY_ELEMENTDATA) { //看，判斷初始化的elementData是不是空的陣列，也就是沒有長度
          //判斷是否新建立陣列，如果是則設為預設容量10
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
    //這個方法才是真正的判斷elementData是否夠用
        ensureExplicitCapacity(minCapacity);
    }
複製程式碼

繼續跟進ensureExplicitCapacity方法

    private void ensureExplicitCapacity(int minCapacity) {
        modCount++; //這個引數用於判斷資料結構變化
        //判斷需要的最小容量是否比目前陣列的長度length大，如果是，則擴容ArrayList陣列
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
複製程式碼

繼續跟進grow方法

    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
       //擴容為當前容量的1.5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        //這句話就是適應於elementData就空陣列的時候，length=0，那麼oldCapacity=0，newCapacity=0，所以這個判斷成立，在這裡就是真正的初始化elementData的大小了，就是為10.前面的工作都是準備工作。
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);

        elementData = Arrays.copyOf(elementData, newCapacity);
    }
複製程式碼

簡單看下hugeCapacity方法

//如果minCapacity都大於MAX_ARRAY_SIZE，那麼就Integer.MAX_VALUE返回，反之將MAX_ARRAY_SIZE返回。因為maxCapacity是三倍的minCapacity，可能擴充的太大了，就用minCapacity來判斷了。
//Integer.MAX_VALUE:2147483647   MAX_ARRAY_SIZE：2147483639  也就是說最大也就能給到第一個數值。還是超過了這個限制，就要溢位了。相當於arraylist給了兩層防護。
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }
複製程式碼

到此，就是ArrayList的add方法和擴容方法的所有流程了。也不算難。大概流程如下，虛線表示需要擴容時才會走的步驟：

add+擴容流程

remove方法

public E remove(int index) {
        rangeCheck(index);//檢查index的合理性

        modCount++;//這個作用很多，比如用來檢測快速失敗的一種標誌。
        E oldValue = elementData(index);//通過索引直接找到該元素

        int numMoved = size - index - 1;//計算要移動的位數。
        if (numMoved > 0)
//這個方法也已經解釋過了，就是用來移動元素的。
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
//將--size上的位置賦值為null，讓gc(垃圾回收機制)更快的回收它。
        elementData[--size] = null; // clear to let GC do its work
//返回刪除的元素。
        return oldValue;
    }

//通過判斷Object是否相同來刪除
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;
    }
複製程式碼

跟remove有關的方法中，重點講一下batchRemove這個方法，這個方法的呼叫只有在removeAll()和retainAll()兩個方法中。

//在removeAll中
batchRemove(c, false);
//在retainAll中
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++)
                //遍歷所有元素，根據傳入的complement不同，儲存不同的結果。
                //removeAll中儲存elementData中刪去Collection<?> c中的元素後的陣列
                //retainAll中儲存elementData和Collection<?> c的交集
                if (c.contains(elementData[r]) == complement)
                    elementData[w++] = elementData[r];
        } finally {
            //如果contains方法使用過程報異常
            //將剩下的元素都賦值給集合A，
            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;
    }
複製程式碼

關於最後if (w != size) {}程式碼塊的邏輯，我在這裡解釋一下：

  • 此時如果是removeAll，w表示elementData刪去c後的陣列長度，size為原陣列長度。
    1. 如果刪去後的陣列長度與原陣列長度相同，則表示沒有remove元素，removeAll返回false。
    2. 如果刪去後的陣列長度與原陣列長度不同，舉例elementData為[1,2,3,4,5]，c為[1,2]。通過上面的迴圈得到的新elementData為[3,4,5,4,5]，所以此時就需要把size-w這段區間內的陣列設為null。最後結果為[3,4,5,null,null]，返回true
  • 此時如果是retainAll，w表示elementData與c交集後的陣列長度，size為原陣列長度。
    1. 如果交集後的陣列長度與原陣列長度相同，則表示沒有交集元素，retainAll返回false。
    2. 如果交集後的陣列長度與原陣列長度不同，舉例elementData為[1,2,3,4,5]，c為[2,3]。通過上面的迴圈得到的新elementData為[2,3,3,4,5]，所以此時就需要把size-w這段區間內的陣列設為null。最後結果為[2,3,null,null,null]，返回true

總結

  1. arrayList可以存放null。
  2. arrayList本質上就是一個elementData陣列。
  3. arrayList區別於陣列的地方在於能夠自動擴充套件大小，其中關鍵的方法就是gorw()方法。
  4. arrayList由於本質是陣列，所以它在資料的查詢方面(get)會很快，而在插入(add)刪除(remove)這些方面，效能下降很多，要移動陣列其他元素才能達到應有的效果
  5. arrayList實現了RandomAccess，所以在遍歷它的時候推薦使用for迴圈。

相關文章