Java容器類淺析四----ArrayList和LinkedList的存取原理

一、概述

數組和列表是Java容器類中最經常使用的一類。
列表的底層存儲數據結構是Object的數組，數組是靜態的，而列表的長度是可以動態增長的，可以稱之爲“動態數組”。
列表長度的動態增長，是在add時檢查當前元素個數是否達到了數組的邊界，如果達到了，則創建一個長度爲當前數組長度1.5倍的新數組，並將之前的數據copy到新的數組中；copy時調用Native Method—System.arrayCopy，該方法是C/C++的實現，可以直接操作指針，實現快速拷貝。

鏈式列表的底層存儲結構是Node節點組成的雙向鏈表，通過first節點和last節點來鏈接所有的節點，每次add元素時如果沒有指定index，則將元素插入到尾部。

二、成員變量

/**
 * Default initial capacity.
 * 默認的數組長度爲10，當size超過10以後，每次size >= elementData.legth時，capacity都會增加50%
 */
private static final int DEFAULT_CAPACITY = 10;

/**
 * Shared empty array instance used for empty instances.
 * 和HashMap的EMPTY_TABLE一樣的作用，初始化時賦值給elementData
 */
private static final Object[] EMPTY_ELEMENTDATA = {};

/**
 * The array buffer into which the elements of the ArrayList are stored.
 * The capacity of the ArrayList is the length of this array buffer. Any
 * empty ArrayList with elementData == EMPTY_ELEMENTDATA will be expanded to
 * DEFAULT_CAPACITY when the first element is added.
 * 列表中存儲結構
 */
private transient Object[] elementData;

/**
 * The size of the ArrayList (the number of elements it contains).
 *列表中元素的個數，不同於elementData.length
 * @serial
 */
private int size;

三、構造函數

/**
*指定數組的長度，長度必須爲自然數
*/
public ArrayList(int initialCapacity) {
    super();//顯示調用父類構造函數
    if (initialCapacity < 0)
        throw new IllegalArgumentException("Illegal Capacity: "+
                                           initialCapacity);
    this.elementData = new Object[initialCapacity];
}

/**
 * 初始化數組爲空數組
 */
public ArrayList() {
    super();
    this.elementData = EMPTY_ELEMENTDATA;
}

/**
 *將一個Collection子類的對象轉爲ArrayList對象。
 */
public ArrayList(Collection<? extends E> c) {
    elementData = c.toArray();獲取元素的數組
    size = elementData.length;
    // c.toArray might (incorrectly) not return Object[] (see 6260652)
    //確保數組的類型是Object，以免導致方法簽名不正確的錯誤
    if (elementData.getClass() != Object[].class)
        elementData = Arrays.copyOf(elementData, size, Object[].class);
}

四、主要方法分析

1. add()相關方法

public boolean add(E e) {
  //在插入數據時首先檢查當前數組容量是否足夠
    ensureCapacityInternal(size + 1);  // Increments modCount!!
  //每次插入的元素存放在數組的尾部，這樣可以避免造成其他元素的移動，尾插法的時間空間效率都爲O(1)
    elementData[size++] = e;
    return true;
}

private void ensureCapacityInternal(int minCapacity) {
    //第一次調用add方法時，纔會對數組設定長度，默認長度爲10
    if (elementData == EMPTY_ELEMENTDATA) {
        minCapacity = Math.max(DEFAULT_CAPACITY, minCapacity);
    }

    ensureExplicitCapacity(minCapacity);
}

private void ensureExplicitCapacity(int minCapacity) {
    modCount++;//Fail-Fast策略

    // overflow-conscious code  自我增長
    //第一次 數組長度從0增長到10，以後每次需要增長時，長度增加50%
    if (minCapacity - elementData.length > 0)
        grow(minCapacity);
}

/**
*增長函數
*/
private void grow(int minCapacity) {
    // overflow-conscious code
    int oldCapacity = elementData.length;
    int newCapacity = oldCapacity + (oldCapacity >> 1);//容量增加50%
    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);
}

指定插入位置的add方法

public void add(int index, E element) {
    rangeCheckForAdd(index);//首先檢查位置是否越界

    ensureCapacityInternal(size + 1);  // 檢查是否需要對數組進行擴容 

    //
    System.arraycopy(elementData, index, elementData, index + 1,
                     size - index);
    elementData[index] = element;
    size++;
}

LinkedList的源碼較爲簡單，這裏就不再一一分析了。可參見深入Java集合學習系列：LinkedList的實現原理