ArrayList擴容原理-基於1.8

ArrayList擴容原理-基於1.8

ArrayList 中的屬性字段

這個是一個默認的容量，針對無參構造

private static final int DEFAULT_CAPACITY = 10;

空的數組

private static final Object[] EMPTY_ELEMENTDATA = {};
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

arrayList存放元素的位置，因爲elementData的實際長度和list的長度可能是不等的，爲了在序列化的時候節約空間，所以用了transient，具體的可以看看writeObject readObject

transient Object[] elementData;

list中元素的數量(區分一下elementData的長度)

private int size;

構造方法

無參

public ArrayList() {
        this.elementData = DEFAULTCAPACITY_EMPTY_ELEMENTDATA;
    }

這裏只是對elementData進行了初始化，給賦了一個空數組。沒有進行擴容操作。

有參 initialCapacity

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);
        }
    }

這裏的參數是一個初始容量。
小於0會拋出異常，等於0效果和無參構造一樣。

有參 Collection<? extends E> c

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;
        }
    }

這裏參數是一個集合，集合大小爲0和無參沒區別，
集合大小不爲0的時候，會給size賦值。然後會判斷class並進行復制。

擴容

ArrayList的擴容都是發生在添加新元素的過程中。
我們以 **add(E e)**方法爲例：

	public boolean add(E e) {
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }

    private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }

    private void ensureExplicitCapacity(int minCapacity) {
        modCount++;

        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

調用add方法後，會先進行一個最小容量（size+1）的計算，若elementData爲空數組，那麼計算結果爲DEFAULT_CAPACITY,否則將返回Math.max(size+1,DEFAULT_CAPACITY).
後面會比較計算的 minCapacity 和 elementData.size()大小，判斷是否需要進行擴容。

	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);
    }

grow纔是真正擴容的過程。
擴容的過程就是 elementData.size >> 1。然後判斷和Integer.MAX_VALUE的差值，看看是否溢出。

• 若是使用addAll，可能存在elementData.size >> 1後還是不滿足最小容量的條件 *

擴展：System源碼中的arraycopy（）標識爲native意味JDK的本地庫，不可避免的會進行IO操作，如果頻繁的對ArrayList進行擴容，毫不疑問會降低ArrayList的使用性能，因此當我們確定添加元素的個數的時候，我們可以事先知道並指定ArrayList的可存儲元素的個數，這樣當我們向ArrayList中加入元素的時候，就可以避免ArrayList的自動擴容，從而提高ArrayList的性能。