Java集合原始碼探究~List

胖琪的升級之路發表於2019-01-20
Java原始碼

在Java中，集合是我們經常要使用的內容，並且集合也是面試的考點之一，掌握集合幫助我們瞭解更多的內部構造。

List

list集合是代表的是一個元素有序的，可重複的集合。

雖然List中有很多子類的實現，但我們經常用的還是那幾個，ArrayList,LinkedList,Vector等內容。

ArrayList

ArrayList 是底層由陣列構成的集合，但是ArrayList有哪些優點呢？

  • 能夠做到動態擴容，不再侷限於設定的陣列大小。
  • 繼承於List,有集合的操作方式，方便快速的操作書庫，新增，刪除，修改，遍歷等內容。

缺點

  • 不是執行緒安全的集合，在操作多執行緒的時候需要採用別的集合例如Vector或者CopyOnWriteArrayList方式。

ArrayList 原始碼解析

基本元素

   // 預設的List 集合大小，在建立ArrayList 的時候沒有制定大小 預設是10 
    private static final int DEFAULT_CAPACITY = 10;

   // 預設的空物件
    private static final Object[] EMPTY_ELEMENTDATA = {};

   // 預設物件內容是該值
    private static final Object[] DEFAULTCAPACITY_EMPTY_ELEMENTDATA = {};

    //當前資料物件存放的地方  
    transient Object[] elementData; // non-private to simplify nested class access

    //當前陣列的長度
    private int size;
    
    // 陣列最大的長度
    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
    // 改變list 大小的次數，進行增刪除資料都涉及到此數值
    protected transient int modCount = 0;
複製程式碼

方法介紹

既然是陣列集合，就需要涉及到陣列的擴容與縮容，在原先我們學習陣列的時候就瞭解，陣列的擴容與縮容都涉及到陣列內的資料的遷移問題。

既然ArrayList 底層是陣列，想當然的也需要涉及到這部分內容。

add方法

add 方法中涉及到增加單個元素，增加單個元素到指定位置，增加一個集合元素，增加一個集合元素到指定位置四個不同型別的方法，但是基本內容是相同的.

public boolean add(E e) {
          元素增加 ，在現在的大小上增加1 
        ensureCapacityInternal(size + 1);  // Increments modCount!!
        elementData[size++] = e;
        return true;
    }
     // 計算是否需要進行擴容 ，需要就進行擴容
     private void ensureCapacityInternal(int minCapacity) {
        ensureExplicitCapacity(calculateCapacity(elementData, minCapacity));
    }
    
    private static int calculateCapacity(Object[] elementData, int minCapacity) {
        // 預設的空物件 DEFAULTCAPACITY_EMPTY_ELEMENTDATA 
        // 判斷 現在list 列表中的元素 是否是空物件。 空物件 返回 最大的值 。不是空物件 返回minCapacity
        if (elementData == DEFAULTCAPACITY_EMPTY_ELEMENTDATA) {
            return Math.max(DEFAULT_CAPACITY, minCapacity);
        }
        return minCapacity;
    }
    private void ensureExplicitCapacity(int minCapacity) {
        // 擴容結構進行加1 
        modCount++;
        // 進行擴容 
        // overflow-conscious code
        if (minCapacity - elementData.length > 0)
            grow(minCapacity);
    }
    
    // 擴容程式碼 
    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);
    }
    
    // 計算容量 選擇 
     private static int hugeCapacity(int minCapacity) {
        if (minCapacity < 0) // overflow
            throw new OutOfMemoryError();
        return (minCapacity > MAX_ARRAY_SIZE) ?
            Integer.MAX_VALUE :
            MAX_ARRAY_SIZE;
    }
    
複製程式碼

從以上程式碼來看庫容有以下流程來判斷

  • 如果是新建立的集合list 加入資料
    1. 首先new出來的是集合，不給定引數的情況下，是沒有進行任何容量的初始化的。
    2. 在執行插入add的時候,會進行容量的初始化10.
  • 已經存在的資料量的集合或者指定集合數量
    1. 在建立的時候指定數量，那麼會初始化這麼陣列空內容。
    2. 執行插入的時候會進行直接插入。

以上內容新建後的流程，有內容後，就涉及到擴容的問題。

  • List 陣列擴容。
    1. 判斷現在list裡面內容的大小是否超過設定的容量大小。
    2. 不超過不執行擴容
    3. 超過執行庫容
    4. 擴容首先擴大1.5倍的大小容量
    5. 如果該容量還是不足以放置新增的資料，會直接擴容到最小要求的容量。
    6. 新的容量大小與最大值進行比較
    7. 存在負值情況小於0 直接超出內容容量的大小。
    8. 大於現在最大值直接返回Integer的最大值。
    9. 說明list不是無限大小的，最大是Integer的最大值。
    10. 進行資料的copy進行陣列的擴容。 程式碼解釋請看上面
 
  
    
    public void add(int index, E element) {
        // 指定位置增加資料，需要檢查該位置是否已經被安置資料如果沒有那麼執行失敗
        rangeCheckForAdd(index);

        ensureCapacityInternal(size + 1);  // Increments modCount!!
        // 進行資料的copy 工作，將該位置的資料往後面進行復制
        System.arraycopy(elementData, index, elementData, index + 1,
                         size - index);
        然後修改該值
        elementData[index] = element;
        size++;
    }    
    
      public boolean addAll(Collection<? extends E> c) {
        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  // Increments modCount
        System.arraycopy(a, 0, elementData, size, numNew);
        size += numNew;
        return numNew != 0;
    }
    
       public boolean addAll(int index, Collection<? extends E> c) {
        rangeCheckForAdd(index);

        Object[] a = c.toArray();
        int numNew = a.length;
        ensureCapacityInternal(size + numNew);  // Increments modCount

        int numMoved = size - index;
        if (numMoved > 0)
            System.arraycopy(elementData, index, elementData, index + numNew,
                             numMoved);

        System.arraycopy(a, 0, elementData, index, numNew);
        size += numNew;
        return numNew != 0;
    }
複製程式碼

總體新增流程簡單來說是這樣的：

  1. 判斷是否是新初始化的空集合或者指定了容量的集合
  2. 進行新增資料判斷是否需要擴容，或者先判斷指定位置資料是否存在
  3. 擴容後的資料遷移。

ArrayList 集合容量擴容會導致效能問題，Java中複製是需要消耗內容空間，建立同樣數量的物件大小，特別是大批量資料進行庫容容易導致效能下降。

set get

set get 方法沒有需要多說的，根據下標進行資料的讀取與插入，小標註意不要超過集合大小。

remove

remove 方法在陣列中會導致陣列的結構的破壞，刪除資料也需要進行資料的遷移。

 // 移除指定元素
    public E remove(int index) {
       //還是檢查下標 是否不合理  
        rangeCheck(index);
        // 結構的修改增加
        modCount++;
        // 獲取移除元素
        E oldValue = elementData(index);
        // 需要移動的 數量
        int numMoved = size - index - 1;
        // 進行資料的遷移 後面資料複製到前一位的資料位置上
        if (numMoved > 0)
            System.arraycopy(elementData, index+1, elementData, index,
                             numMoved);
        //最後的一位置位null  讓gc來處理
        elementData[--size] = null; // clear to let GC do its work
        返回移除內容
        return oldValue;
    }
複製程式碼
// 批量進行刪除
private boolean batchRemove(Collection<?> c, boolean complement) {
        final Object[] elementData = this.elementData;
        int r = 0, w = 0;
        boolean modified = false;
        try {
            for (; r < size; r++)
                // 判斷不被 刪除的元素是否在集合中 集合是 0  1 2  3 4  5   刪除 1 3 complement = true 
                if (c.contains(elementData[r]) == complement)
                    elementData[w++] = elementData[r];
        } finally {
        
            // Preserve behavioral compatibility with AbstractCollection, 
            // even if c.contains() throws. 1 3 2 3 4 5  異常執行復制copy  這裡主要是存在可能刪除的元素不在集合中
            if (r != size) {
                System.arraycopy(elementData, r,
                                 elementData, w,
                                 size - r);
                w += size - r;
            }
            if (w != size) {
                // clear to let GC do its work 0 1  size = 6  w = 2 
                for (int i = w; i < size; i++)     
                    elementData[i] = null;
                modCount += size - w;  
                size = w;       
                modified = true; 
            }
        }
        return modified;
    }
複製程式碼

刪除程式碼中主要涉及到

  • 刪除指定元素，都涉及到陣列內容的拷貝。

迴圈

  • for迴圈，根據指標進行迴圈，比較快速
  • foreach與迭代器迴圈資料比較適合連結串列式的集合資料
  • 刪除集合中的資料使用迭代器，如果使用for指標迴圈刪除資料容易出現異常。

相關文章