ArrayList分析

ArrayList繼承自AbstractList，實現了List, RandomAccess, Cloneable, java.io.Serializable接口。ArrayList內部是一個動態數組，與Java中的數組相比，它的容量能動態增加。

簡述

ArrayList 是容量可變的非線程安全列表，使用數組實現，集合擴容時會建立更大的數組，把原有數組複製到新數組。支持對元素的快速隨機訪問，但插入與刪除速度很慢。ArrayList 實現了 RandomAcess 標記接口，若是一個類實現了該接口，那麼表示使用索引遍歷比迭代器更快。

elementData是 ArrayList 的數據域，被 transient 修飾，序列化時會調用 writeObject 寫入流，反序列化時調用 readObject 從新賦值到新對象的 elementData。緣由是 elementData 容量一般大於實際存儲元素的數量，因此只需發送真正有實際值的數組元素。

size 是當前實際大小，elementData 大小大於等於 size。

*modCount *記錄了 ArrayList 結構性變化的次數，繼承自 AbstractList。全部涉及結構變化的方法都會增長該值。expectedModCount 是迭代器初始化時記錄的 modCount 值，每次訪問新元素時都會檢查 modCount 和 expectedModCount 是否相等，不相等就會拋出異常。這種機制叫作 fail-fast，全部集合類都有這種機制。

首先了解ArrayList內部的屬性

 1 // 序列化id
 2 private static final long serialVersionUID = 8683452581122892189L;
 3 //ArrayList的初始容量大小
 4 private static final int DEFAULT_CAPACITY = 10;
 5 //空對象數組
 6 private static final Object[] EMPTY_ELEMENTDATA = {};
 7 //空對象數組，若是使用默認構造函數建立，則默認對象內容默認是該值 
 8 private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};
 9 //存放當前數據，不參與序列化
10 transient Object[] elementData;
11 //list大小
12 private int size;
13 //list最大長度
14 private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

elementData：這是個 Object 類型的數組，用於存儲具體元素，其表示的數組的大小。
size：用來記錄 ArrayList 當前元素個數，默認爲 0。

ArrayList構造方法

//默認構造方法，將elementData初始化爲DEFAULTCAPACITY_EMPTY_ELEMENTD（及空數組）
    public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }
    //指定容量的構造方法，傳入參數小於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對象，先調用toArray()方法將Collection對象轉換爲Object[]
    *更新size的值，同時判斷size的大小，若是是size等於0，直接將空對象EMPTY_ELEMENTDATA的地址賦給elementData
    *若是size的值大於0，則執行Arrays.copy方法，把collection對象的內容（能夠理解爲深拷貝）copy到elementData中，代碼註釋toArray可能不是返回Object[]，因此進行深拷貝
    **/
    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;
        }
    }

在初始化時調用了 ArrayList 的構造方法，這個構造方法只作了一件事，將 elementData 初始化爲空數組。
在初次調用 add 方法時，ArrayList 會進行第一次擴容，將 elementData 擴容成容量爲 10 的數組，而後再添加元素。
當 ArrayList 已經達到當前最大容量，會再次第二次擴容，將 elementData 擴容成容量爲 1原有容量的 1.5 倍），而後再添加元素

其中在構造法方法中，DEFAULTCAPACITY_EMPTY_ELEMENTDATA 由前文可知是一個內部常量，值爲空數組，也被用來做爲空數組的標識。在後面調用 add 方法時也是經過這個常量來判斷是否第一次調用。

ArrayList的方法

// 添加元素以前先檢查容量，若容量不足則調用grow()方法，而後將元素添加到隊尾，返回true
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
    /**
    *首先檢查index是否在size範圍以內，確保數組已使用長度（size）加1以後足夠存下一個數據
    *而後將index以後的元素所有向後挪一位，再進行賦值
    **/
    public void add(int index, E element) {
        rangeCheckForAdd(index);
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        System.arraycopy(elementData, index, elementData, index + 1, size - index);
        elementData[index] = element;
        size++;
    }
    /**
    *首先判斷index是否超出範圍，而後返回指定元素值
    **/
    public E get(int index) {
        rangeCheck(index);
        return elementData(index);
    }
    /**
    *首先判斷index是否超出範圍，而後將指定索引的數組元素賦值
    **/
    public E set(int index, E element) {
        rangeCheck(index);
 
        E oldValue = elementData(index);
        elementData[index] = element;
        return oldValue;
    }
    /**
    *首先判斷index是否超出範圍，numMoved 計算移除元素後須要移動的元素個數
    *經過System.arraycopy方法將後面的元素前移一位，並將最後一爲賦值爲null，最後返回移除元素的值
    */
    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; // clear to let GC do its work
 
        return oldValue;
    }
 
    /**
    *須要遍歷整個list去匹配移除元素的值
    */
    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;
    }
 
    /**
    *須要遍歷整個list去匹配元素值，而後返回第一個匹配元素的索引值，不然返回-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;
    }

ArrayList的主要方法

//minCapacity 最小即爲初始容量大小10
    private void ensureCapacityInternal(int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        ensureExplicitCapacity(minCapacity);
    }
 
    //需求長度大於如今長度，則擴充數組長度
    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    /**
    *首先將oldCapacity 右移一位縮小1/2，newCapacity 擴大爲oldCapacity 的1.5倍
    *若是newCapacity不能知足需求，那就直接擴大爲minCapacity大小
    *若是newCapacity超過list最大容量，則返回Interger類型最大值
    *最後更新elementData
    **/
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        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);
    }

ensureCapacityInternal (int miniCapacity): 用於判斷是否第一次調用，經過構造方法裏用來賦值的常量 DEFAULTCAPACITY_EMPTY_ELEMENTDATA 判斷。

第一次調用：將所需最小容量（即 miniCapacity）設置爲 10，而後調用 ensureExplicitCapacity 方法進行擴容
非第一次調用：直接調用 ensureExplicitCapacity 方法進行擴容

ensureExplicitCapacity (int minCapacity): 用於判斷是否須要擴容

modCount 主要是在調用 iterator 方法時用來防止 list 被修改，在這裏能夠忽略不計

grow (int miniCapacity): 實際擴容操做