【集合框架】JDK1.8源碼分析之LinkedList（七）

一、前言

　　在分析了ArrayList了之后，緊接着必須要分析它的同胞兄弟：LinkedList，LinkedList與ArrayList在底層的實現上有所不同，其實，只要我們有數據結構的基礎，在分析源碼的時候就會很簡單，下面進入正題，LinkedList源碼分析。

二、LinkedList數據結構

　　還是老規矩，先抓住LinkedList的核心部分：數據結構，其數據結構如下

　　說明：如上圖所示，LinkedList底層使用的雙向鏈表結構，有一個頭結點和一個尾結點，雙向鏈表意味着我們可以從頭開始正向遍歷，或者是從尾開始逆向遍歷，並且可以針對頭部和尾部進行相應的操作。

三、LinkedList源碼分析

　　3.1 類的繼承關系　

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable

　　說明：LinkedList的類繼承結構很有意思，我們着重要看是Deque接口，Deque接口表示是一個雙端隊列，那么也意味着LinkedList是雙端隊列的一種實現，所以，基於雙端隊列的操作在LinkedList中全部有效。

　　3.2 類的內部類　

    private static class Node<E> {
        E item; // 數據域
        Node<E> next; // 后繼
        Node<E> prev; // 前驅
        
        // 構造函數，賦值前驅后繼
        Node(Node<E> prev, E element, Node<E> next) {
            this.item = element;
            this.next = next;
            this.prev = prev;
        }
    }

　　說明：內部類Node就是實際的結點，用於存放實際元素的地方。

　　3.3 類的屬性　　

public class LinkedList<E>
    extends AbstractSequentialList<E>
    implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
    // 實際元素個數
    transient int size = 0;
    // 頭結點
    transient Node<E> first;
    // 尾結點
    transient Node<E> last;
}    

　　說明：LinkedList的屬性非常簡單，一個頭結點、一個尾結點、一個表示鏈表中實際元素個數的變量。注意，頭結點、尾結點都有transient關鍵字修飾，這也意味着在序列化時該域是不會序列化的。

　　3.4 類的構造函數

　　1. LinkedList()型構造函數　

public LinkedList() {
}

　　2. LinkedList(Collection<? extends E>)型構造函數　　

    public LinkedList(Collection<? extends E> c) {
        // 調用無參構造函數
        this();
        // 添加集合中所有的元素
        addAll(c);
    }

　　說明：會調用無參構造函數，並且會把集合中所有的元素添加到LinkedList中。

　　3.5 核心函數分析

　　1. add函數　

    public boolean add(E e) {
        // 添加到末尾
        linkLast(e);
        return true;
    }

　　說明：add函數用於向LinkedList中添加一個元素，並且添加到鏈表尾部。具體添加到尾部的邏輯是由linkLast函數完成的。

    void linkLast(E e) {
        // 保存尾結點，l為final類型，不可更改
        final Node<E> l = last;
        // 新生成結點的前驅為l,后繼為null
        final Node<E> newNode = new Node<>(l, e, null);
        // 重新賦值尾結點
        last = newNode;    
        if (l == null) // 尾結點為空
            first = newNode; // 賦值頭結點
        else // 尾結點不為空
            l.next = newNode; // 尾結點的后繼為新生成的結點
        // 大小加1    
        size++;
        // 結構性修改加1
        modCount++;
    }

　　說明：對於添加一個元素至鏈表中會調用add方法 -> linkLast方法。

　　對於添加元素的情況我們使用如下示例進行說明

　　示例一代碼如下（只展示了核心代碼）　

List<Integer> lists = new LinkedList<Integer>();
lists.add(5);
lists.add(6);

　　說明：首先調用無參構造函數，之后添加元素5，之后再添加元素6。具體的示意圖如下：

　　說明：上圖的表明了在執行每一條語句后，鏈表對應的狀態。

　　2. addAll函數

　　addAll有兩個重載函數，addAll(Collection<? extends E>)型和addAll(int, Collection<? extends E>)型，我們平時習慣調用的addAll(Collection<? extends E>)型會轉化為addAll(int, Collection<? extends E>)型，所以我們着重分析此函數即可。　

// 添加一個集合
    public boolean addAll(int index, Collection<? extends E> c) {
        // 檢查插入的的位置是否合法
        checkPositionIndex(index);
        // 將集合轉化為數組
        Object[] a = c.toArray();
        // 保存集合大小
        int numNew = a.length;
        if (numNew == 0) // 集合為空，直接返回
            return false;

        Node<E> pred, succ; // 前驅，后繼
        if (index == size) { // 如果插入位置為鏈表末尾，則后繼為null，前驅為尾結點
            succ = null;
            pred = last;
        } else { // 插入位置為其他某個位置
            succ = node(index); // 尋找到該結點
            pred = succ.prev; // 保存該結點的前驅
        }

        for (Object o : a) { // 遍歷數組
            @SuppressWarnings("unchecked") E e = (E) o; // 向下轉型
            // 生成新結點
            Node<E> newNode = new Node<>(pred, e, null);
            if (pred == null) // 表示在第一個元素之前插入(索引為0的結點)
                first = newNode;
            else
                pred.next = newNode;
            pred = newNode;
        }

        if (succ == null) { // 表示在最后一個元素之后插入
            last = pred;
        } else {
            pred.next = succ;
            succ.prev = pred;
        }
        // 修改實際元素個數
        size += numNew;
        // 結構性修改加1
        modCount++;
        return true;
    }

　　說明：參數中的index表示在索引下標為index的結點（實際上是第index + 1個結點）的前面插入。在addAll函數中，addAll函數中還會調用到node函數，get函數也會調用到node函數，此函數是根據索引下標找到該結點並返回，具體代碼如下

    Node<E> node(int index) {
        // 判斷插入的位置在鏈表前半段或者是后半段
        if (index < (size >> 1)) { // 插入位置在前半段
            Node<E> x = first; 
            for (int i = 0; i < index; i++) // 從頭結點開始正向遍歷
                x = x.next;
            return x; // 返回該結點
        } else { // 插入位置在后半段
            Node<E> x = last; 
            for (int i = size - 1; i > index; i--) // 從尾結點開始反向遍歷
                x = x.prev;
            return x; // 返回該結點
        }
    }

　　說明：在根據索引查找結點時，會有一個小優化，結點在前半段則從頭開始遍歷，在后半段則從尾開始遍歷，這樣就保證了只需要遍歷最多一半結點就可以找到指定索引的結點。

　　下面通過示例來更深入了解調用addAll函數后的鏈表狀態。　　

List<Integer> lists = new LinkedList<Integer>();
lists.add(5);
lists.addAll(0, Arrays.asList(2, 3, 4, 5));

　　上述代碼內部的鏈表結構如下：

　　3. unlink函數

　　在調用remove移除結點時，會調用到unlink函數，unlink函數具體如下：　　

    E unlink(Node<E> x) {
        // 保存結點的元素
        final E element = x.item;
        // 保存x的后繼
        final Node<E> next = x.next;
        // 保存x的前驅
        final Node<E> prev = x.prev;
        
        if (prev == null) { // 前驅為空，表示刪除的結點為頭結點
            first = next; // 重新賦值頭結點
        } else { // 刪除的結點不為頭結點
            prev.next = next; // 賦值前驅結點的后繼
            x.prev = null; // 結點的前驅為空，切斷結點的前驅指針
        }

        if (next == null) { // 后繼為空，表示刪除的結點為尾結點
            last = prev; // 重新賦值尾結點
        } else { // 刪除的結點不為尾結點
            next.prev = prev; // 賦值后繼結點的前驅
            x.next = null; // 結點的后繼為空，切斷結點的后繼指針
        }

        x.item = null; // 結點元素賦值為空
        // 減少元素實際個數
        size--; 
        // 結構性修改加1
        modCount++;
        // 返回結點的舊元素
        return element;
    }

　　說明：將指定的結點從鏈表中斷開，不再累贅。

四、針對LinkedList的思考

　　1. 對addAll函數的思考

　　在addAll函數中，傳入一個集合參數和插入位置，然后將集合轉化為數組，然后再遍歷數組，挨個添加數組的元素，但是問題來了，為什么要先轉化為數組再進行遍歷，而不是直接遍歷集合呢？從效果上兩者是完全等價的，都可以達到遍歷的效果。關於為什么要轉化為數組的問題，我的思考如下：1. 如果直接遍歷集合的話，那么在遍歷過程中需要插入元素，在堆上分配內存空間，修改指針域，這個過程中就會一直占用着這個集合，考慮正確同步的話，其他線程只能一直等待。2. 如果轉化為數組，只需要遍歷集合，而遍歷集合過程中不需要額外的操作，所以占用的時間相對是較短的，這樣就利於其他線程盡快的使用這個集合。說白了，就是有利於提高多線程訪問該集合的效率，盡可能短時間的阻塞。

五、總結

　　分析完了LinkedList源碼，其實很簡單，值得注意的是LinkedList可以作為雙端隊列使用，這也是隊列結構在Java中一種實現，當需要使用隊列結構時，可以考慮LinkedList。謝謝各位園友觀看~