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倍，以上就是動態擴容的原理。

https://www.cnblogs.com/kuoAT/p/6771653.html