Arraylist動態擴容詳解

ArrayList 概述

ArrayList是基於數組實現的，是一個動態數組，其容量能自動增加。
ArrayList不是線程安全的，只能用在單線程環境下。
實現了Serializable接口，所以它支持序列化，可以經過序列化傳輸；
實現了RandomAccess接口，支持快速隨機訪問，實際上就是經過下標序號進行快速訪問；
實現了Cloneable接口，能被克隆。

動態擴容

一 初始化

首先有三種方式來初始化：

public ArrayList();

默認的構造器，將會以默認的大小來初始化內部的數組

public ArrayList(Collection<? extends E> c)

用一個ICollection對象來構造，並將該集合的元素添加到ArrayList

public ArrayList(int initialCapacity)

用指定的大小來初始化內部的數組

後兩種方式均可以理解，經過創造對象，或指定大小來初始化內部數據便可。 
那咱們來重點關注一下無參數構造器的實現過程：

/**
     * Constructs an empty list with an initial capacity of ten.     */
    public ArrayList() {      // DEFAULTCAPACITY_EMPTY_ELEMENTDATA是空數組
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    } private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

能夠看出它的默認數組爲長度爲0。而在以前JDK1,6中，無參數構造器代碼是初始長度爲10。 
JDK6代碼這樣的：

 public ArrayList() {    this(10);
    }  public ArrayList(int initialCapacity) {    super();        if (initialCapacity < 0)            throw new IllegalArgumentException("Illegal Capacity: "+
                                               initialCapacity);    this.elementData = new Object[initialCapacity];
    }

接下來，要擴容的話，確定是在ArrayList.add 方法中。咱們來看一下具體實現。

二  確保內部容量

咱們以無參數構造爲例， 
初始化時，數組長度爲0. 
那我如今要添加數據了，數組的長度是怎麼變化的？

 public boolean add(E e) {        //確保內部容量(經過判斷，若是夠則不進行操做；容量不夠就擴容來確保內部容量)
        ensureCapacityInternal(size + 1);  // ①Increments modCount!!
        elementData[size++] = e;//②
        return true;
    }

① ensureCapacityInternal方法名的英文大體是「確保內部容量」，size表示的是執行添加以前的元素個數，並不是ArrayList的容量，容量應該是數組elementData的長度。ensureCapacityInternal該方法經過將現有的元素個數數組的容量比較。看若是須要擴容，則擴容。 
②是將要添加的元素放置到相應的數組中。 
下面具體看 ensureCapacityInternal(size + 1);

  // ① 是如何判斷和擴容的。
private void ensureCapacityInternal(int minCapacity) {      //若是實際存儲數組 是空數組，則最小須要容量就是默認容量
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
        }

        ensureExplicitCapacity(minCapacity);
    }    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;        //若是數組（elementData)的長度小於最小須要的容量（minCapacity）就擴容
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }    /**
     * Default initial capacity.     */
    private static final int DEFAULT_CAPACITY = 10;

以上，elementData是用來存儲實際內容的數組。minExpand 是最小擴充容量。 
DEFAULTCAPACITY_EMPTY_ELEMENTDATA共享的空數組實例用於默認大小的空實例。根據傳入的最小須要容量minCapacity來和數組的容量長度對比，若minCapactity大於或等於數組容量，則須要進行擴容。

三 擴容

 

  /*
    *增長容量，以確保它至少能容納
    *由最小容量參數指定的元素數。
    * @param mincapacity所需的最小容量    */
    private void grow(int minCapacity) {        // overflow-conscious code
        int oldCapacity = elementData.length;        //>>位運算，右移動一位。 總體至關於newCapacity =oldCapacity + 0.5 * oldCapacity  
        // jdk1.7採用位運算比之前的計算方式更快
        int newCapacity = oldCapacity + (oldCapacity >> 1);        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;       //jdk1.7這裏增長了對元素個數的最大個數判斷,jdk1.7之前是沒有最大值判斷的，MAX_ARRAY_SIZE 爲int最大值減去8（不清楚爲何用這個值作比較）
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);        // 最重要的複製元素方法
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

 

　　綜上所述，ArrayList至關於在沒指定initialCapacity時就是會使用延遲分配對象數組空間，當第一次插入元素時才分配10（默認）個對象空間。假若有20個數據須要添加，那麼會分別在第一次的時候，將ArrayList的容量變爲10 (以下圖一)；以後擴容會按照1.5倍增加。也就是當添加第11個數據的時候，Arraylist繼續擴容變爲10*1.5=15(以下圖二)；當添加第16個數據時，繼續擴容變爲15 * 1.5 =22個(以下圖四)。：

　　向數組中添加第一個元素時，數組容量爲10.

　　向數組中添加到第10個元素時，數組容量仍爲10. 

　　向數組中添加到第11個元素時，數組容量擴爲15. 

　　向數組中添加到第16個元素時，數組容量擴爲22.

每次擴容都是經過Arrays.copyOf(elementData, newCapacity) 這樣的方式實現的。

　　對比和總結：

　　本文介紹了 ArrayList動態擴容的全過程。若是經過無參構造的話，初始數組容量爲0，當真正對數組進行添加時，才真正分配容量。每次按照1.5倍（位運算）的比率經過copeOf的方式擴容。 在JKD1.6中實現是，若是經過無參構造的話，初始數組容量爲10，每次經過copeOf的方式擴容後容量爲原來的1.5倍，以上就是動態擴容的原理。