寫在前面

資料結構在面試中基本都是常問的，但是一般開發中基本上都是在使用沒有去關心過怎麼實現的。

在資料結構中，連結串列是一種線性儲存結構，也就是常說的線性表。

概念：線性表，是資料結構中的一種資料儲存結構，資料元素之間具有“一對一”的邏輯關係。可以理解為把所有資料用一根線串起來，在儲存到物理空間中。

順序表ArrayList

概念：將資料依次儲存在連續的整塊物理空間中，這種儲存結構稱為順序儲存結構（簡稱順序表）。類似下圖用一個線把他們連線起來，形成一條線性的結構。

ArrayList就是屬於這樣的一種。

ArrayList是基於陣列實現的，陣列是一種最簡單的資料結構，在使用時必須要給它建立大小，在日常開發中，往往我們是不知道給陣列分配多大空間的，如果陣列空間分配多了，記憶體浪費，分配少了，裝不下。而ArrayList在使用時可以新增多個元素切不需要指定大小，因為ArrayList是動態擴容的。

類的繼承關係

原始碼分析

類的屬性

/**
 * 預設初始容量
 */
private static final int DEFAULT_CAPACITY = 10;

/**
 *ArrayList 實際資料儲存的一個數組
 *儲存ArrayList的元素的陣列緩衝區。 ArrayList的容量是此陣列緩衝區的長度。
 *新增第一個元素時，任何具有elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA的空ArrayList都將擴充套件為DEFAULT_CAPACITY。
 */
transient Object[] elementData;

/**
 * 共享的空陣列例項，用於預設大小的空例項
 */
private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

/**
 * elementData 的大小
 */
private int size;
 

類的建構函式

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

new ArrayList()做了什麼

public class TestClient {

    public static void main(String[] args) {
        List<String> list = new ArrayList<>();
        Integer capacity = getCapacity(list);
        System.out.println("沒新增元素時的容量：" + capacity);
        System.out.println("沒新增元素時的大小：" + list.size());
        list.add("新增元素");
        capacity = getCapacity(list);
        System.out.println("新增1個元素時的容量：" + capacity);
        System.out.println("新增1個元素時的大小：" + list.size());
    }

    /**
     * 通過反射獲取list的容量
     *
     * @param list
     * @return
     */
    public static Integer getCapacity(List<String> list) {
        Integer length = null;
        Class c = list.getClass();
        Field f;
        try {
            f = c.getDeclaredField("elementData");
            f.setAccessible(true);
            Object[] o = (Object[]) f.get(list);
            length = o.length;
        } catch (NoSuchFieldException e) {
            e.printStackTrace();
        } catch (IllegalAccessException e) {
            e.printStackTrace();
        }
        return length;
    }
}
 

列印結果

沒新增元素時的容量：0
沒新增元素時的大小：0
新增1個元素時的容量：10
新增1個元素時的大小：1

因此，當new ArrayList()時，預設會有一個空的Object空陣列，在沒有新增有元素的時候，其初始化容量是0，只有當新增第一個元素的時候，容量才會設定成10。

基本方法

新增元素add(E e)

/**
 * 將指定的元素追加到此列表的末尾
 */
 public boolean add(E e) {
     ensureCapacityInternal(size + 1);
     //直接賦值
     elementData[size++] = e;
     return true;
}

add(int index, E element)

在指定索引位置新增元素

String[] elementData = {"1", "2", "3", "4", "5", "6", "7", "8"};
int index = 4;
//從下標為4的位置開始複製，複製的長度為8-4=4(複製"5", "6", "7", "8")，從下標為4+1=5的位置開始替換為"5", "6", "7", "8"
System.arraycopy(elementData, index, elementData, index+1, elementData.length-index);

ArrayList 擴容機制

ensureExplicitCapacity(int minCapacity)

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

        //如果其元素數量大於其容量，則進行擴容
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }

grow(int minCapacity)

    /**
     * 擴容
     * @param minCapacity
     */
    private void grow(int minCapacity) {
        //原來的容量
        int oldCapacity = elementData.length;
        //新的容量  通過位運算右移一位  如，預設為10 10>>1=5  右移過程：10的二進位制為  1010   右移1位->0101 轉十進位制->5
        //可以理解為oldCapacity >> 1 == oldCapacity/2 再加上原來的長度就擴容1.5倍
        int newCapacity = oldCapacity + (oldCapacity >> 1);
        if (newCapacity - minCapacity < 0)
            newCapacity = minCapacity;
        //如果大於ArrayList 可以容許的最大容量，則設定為最大容量
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        elementData = Arrays.copyOf(elementData, newCapacity);
    }

想了解位運算的可以看看這篇文章

Java中的位運算

ArrayList 的內部實現，其實是用一個物件陣列進行存放具體的值，然後用一種擴容的機制，進行陣列的動態增長。

其擴容機制可以理解為，如果元素的個數，大於其容量，則把其容量擴充套件為原來容量的1.5倍。

拓展延伸

• ArrayList的大小是如何自動增加的？
• 什麼情況下你會使用ArrayList？
• 在索引中ArrayList的增加或者刪除某個物件的執行過程？效率很低嗎？解釋一下為什麼？
• ArrayList如何順序刪除節點？
• ArrayList的遍歷方法？