java基礎：ArrayList — 源碼分析

其餘更多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方法和擴容方法的全部流程了。也不算難。大概流程以下，虛線表示須要擴容時纔會走的步驟：

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循環。