Java中的ArrayList的初始容量和容量分配

List接口的大小可變數組的實現。實現了全部可選列表操做，並容許包括 null 在內的全部元素。
ArrayList繼承於List接口，除繼承過來的方法外，還提供一些方法來操做內部用來存儲列表的數組的大小。
每一個ArrayList實例都有一個容量。該容量是指用來存儲列表元素的數組的大小。它老是至少等於列表的大小。隨着向ArrayList中不斷添加元素，其容量也自動增加。並未指定增加策略的細節，由於這不僅是添加元素會帶來分攤固定時間開銷那樣簡單。

 

ArrayList是常常會被用到的，通常狀況下，使用的時候會像這樣進行聲明：
List arrayList = new ArrayList();
若是像上面這樣使用默認的構造方法，初始容量被設置爲10。當ArrayList中的元素超過10個之後，會從新分配內存空間，使數組的大小增加到16。
能夠經過調試看到動態增加的數量變化：10->16->25->38->58->88->...

 

也可使用下面的方式進行聲明：
List arrayList = new ArrayList(4);
將ArrayList的默認容量設置爲4。當ArrayList中的元素超過4個之後，會從新分配內存空間，使數組的大小增加到7。
能夠經過調試看到動態增加的數量變化：4->7->11->17->26->...

 

那麼容量變化的規則是什麼呢？請看下面的公式：
((舊容量 * 3) / 2) + 1
注：這點與C#語言是不一樣的，C#當中的算法很簡單，是翻倍。

 

一旦容量發生變化，就要帶來額外的內存開銷，和時間上的開銷。
因此，在已經知道容量大小的狀況下，推薦使用下面方式進行聲明：
List arrayList = new ArrayList(CAPACITY_SIZE);
即指定默認容量大小的方式。

 

探索ArrayList自動改變size真相
ArrayList的列表對象實質上是存儲在一個引用型數組裏的，有人認爲該數組有「自動增加機制」能夠自動改變size大小。正式地說，該數組是沒法改變
大小的，實際上它只是改變了該引用型數組的指向而已。下面，讓咱們來看看java是怎樣實現ArrayList類的。
1、ArrayList類的實質
     ArrayList底層採用Object類型的數組實現，當使用不帶參數的構造方法生成ArrayList對象時，
實際上會在底層生成一個長度爲10的Object類型數組。
    首先，ArrayList定義了一個私有的未被序列化的數組elementData，用來存儲ArrayList的對象列表（注意只定義未初始）：
　　private transient Object[] elementData;
    
    其次，以指定初始容量（Capacity）或把指定的Collection轉換爲引用型數組後實例化elementData數組；若是沒有指定，則預置初始容量爲10進行
實例化。把私有數組預先實例化，而後經過copyOf方法覆蓋原數組，是實現自動改變ArrayList的大小(size)的關鍵。有人說ArrayList是複雜的數組，我
認爲不如說ArrayList是關於數組的系統的方法組合。
　　ArrayList的構造方法源碼以下：
    // 用指定的初始容量構造一個空列表。
    public ArrayList(int initialCapacity) {
        super();
        if (initialCapacity < 0)
            throw new IllegalArgumentException("Illegal Capacity: "+initialCapacity);
        this.elementData = new Object[initialCapacity];//屬性指向新建長度爲初始容量的臨時數組
    }
    // 使用初始容量10構造一個空列表
    public ArrayList() {
        this(10);
    }
    / *構造包含利用collection的迭代器按順序返回的指定collection元素的列表
     * @param c 集合，它的元素被用來放入列表t
     * @throws NullPointerException 若是指定集合爲 null
     */
    public ArrayList(Collection<? extends E> c) {
        elementData = c.toArray();//用Collection初始化數組elementData
        size = elementData.length;
        if (elementData.getClass() != Object[].class)
            elementData = Arrays.copyOf(elementData, size, Object[].class);
    }
2、ArrayList實現自動改變size機制
   爲了實現這一機制，java引進了Capacity和size概念，以區別數組的length。爲了保證用戶增長新的列表對象，java設置了最小容量（minCapacity）
，一般狀況上，它大於列表對象的數目，因此Capactiy雖然就是底層數組的長度（length），可是對於最終用戶來說，它是無心義的。而size存儲着列表
對象的數量，纔是最終用戶所須要的。爲了防止用戶錯誤修改，這一屬性被設置爲privae的，不過能夠經過size()獲取。
   下面，對ArrayList的初始以及其列表對象的增長和刪除等三種狀況下的size自動改變機制進行分析。
   1、初始Capacity和size值。
   從上面給出的ArrayList構造方法源碼中，咱們不難看出Capacity初始值（initialCapacity）能夠由用戶直接指定或由用戶指定的Collection集合存
儲的對象數目肯定，若是沒有指定，系統默認爲10。而size的被聲明爲int型變量，默認爲0，當用戶指定Collection建立ArrayList時，size值等於
initialCapacity。
 
   2、add()方法
    該方法的源碼以下：
    public boolean add(E e) {
        ensureCapacityInternal(size + 1);
        elementData[size++] = e;//添加對象時，自增size
        return true;
    }
    方法中調用的ensureCapacityInternal主要用來調整容量，修改elementData數組的指向。其中涉及到3個方法的調用，其核心在於grow方法：
    
    private void ensureCapacityInternal(int minCapacity) {
        modCount++;//定義於ArrayList的父類AbstractList，用於存儲結構修改次數
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }  
    private void grow(int minCapacity) {
        // overflow-conscious code
        int oldCapacity = elementData.length;
        int newCapacity = oldCapacity + (oldCapacity >> 1);//新容量擴大到原容量的1.5倍，右移一位相關於原數值除以2。
        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);
    }
    private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;//MAX_ARRAY_SIZE和Integer.MAX_VALUE爲常量，詳細請參閱下面的註解
    }
   
   經過以上代碼，咱們可知java自動增長ArrayList大小的思路是：向ArrayList添加對象時，原對象數目加1若是大於原底層數組長度，則以適當長度新
建一個原數組的拷貝，並修改原數組，指向這個新建數組。原數組自動拋棄（java垃圾回收機制會自動回收）。size則在向數組添加對象，自增1。
 
   註解：
    //定義於該類的常量，用來分配數組的size最大值。一些 VMs在數組裏保留字頭，試圖分配更大數組時可能致使OutOfMemoryError:被請求數組的
size超出VM界限。
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
   //在java.lang.Integer類中常量MIN_VALUE、MAX_VALUE以下：
   public static final int   MIN_VALUE = 0x80000000;//整型取值區間下界：－2147483648
   public static final int   MAX_VALUE = 0x7fffffff;//整型取值區間上界：2147483647
　　//在java.util.AbstractList中modCount定義以下：
　　protected transient int modCount = 0;
    3、remove()方法
    該重構方法其一源碼以下（其它的就不累述了）：
    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; // 數組前移一位，size自減，空出來的位置置null，具體的對象的銷燬由Junk收集器負責
        return oldValue;
    }
    private void rangeCheck(int index) {//邊界檢查
        if (index < 0 || index >= this.size)
           throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
    }
    E elementData(int index) {//獲取指定index所在位置的對象
        return (E) elementData[index];
    }
 
    經過remove()源碼的學習，咱們不難看出，其改變ArrayList大小的核心與add()方法類似，都是同數組拷貝。
    另外，若是確有必要，用戶也能夠指定ArrayList實例的容量，能夠有效的下降時間成本。它是經過調用ensureCapacityInternal來實現的，源代碼
以下：
    public void ensureCapacity(int minCapacity) {
        if (minCapacity > 0)
            ensureCapacityInternal(minCapacity);
    }
    由於size爲private的，java給出方法來訪問它：
    public int size() {
         checkForComodification();
         return this.size;
    }
 
    綜上所述，在用戶向ArrayList追加對象時，Java老是要先計算容量（Capacity）是否適當，若容量不足則把原數組拷貝到以指定容量爲長度建立的
新數組內，並對原數組變量從新賦值，指向新數組。在這同時，size進行自增1。在刪除對象時，先使用拷貝方法把指定index後面的對象前移1位（若是
有的話），而後把空出來的位置置null，交給Junk收集器銷燬，size自減1，即完成了。