List集合之LinkedList深度解析

我們在前面的文章中已經介紹過 List 大家族中的 ArrayList 和Vector 這兩位猶如孿生兄弟一般，從底層實現，功能都有着相似之處，除了一些個人行爲不同（成員變量，構造函數和方法線程安全）。接下來，我們將會認識一下他們的另一位功能強大的兄弟：LinkedList

## 一、LinkedList的概覽

1.1、結構圖

首先我們還是看一看LinkedList中的結構圖，繼承體系關係

從這個繼承體系關係中可以看到LinkeList和ArrayList是有非常大的不同的，LinkedList的依賴關係如下：

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

仔細的分析依賴關係之前，我們再來看一下Collection集合的總覽：

1、繼承於 AbstractSequentialList ，本質上面與繼承 AbstractList 沒有什麼區別，AbstractSequentialList 完善了 AbstractList 中沒有實現的方法。

2、Serializable：成員變量 Node 使用 transient 修飾，通過重寫read/writeObject 方法實現序列化。

3、Cloneable：重寫clone（）方法，通過創建新的LinkedList 對象，遍歷拷貝數據進行對象拷貝。

4、Deque：實現了Collection 大家庭中的隊列接口，說明他擁有作爲雙端隊列的功能。

LinkedList與ArrayList最大的區別就是LinkedList中實現了Collection中的 Queue（Deque）接口擁有作爲雙端隊列的功能

###1.2、LinkedList的成員變量

  //當前有多少個結點
  transient int size = 0;

    /**
     * Pointer to first node.
     * Invariant: (first == null && last == null) ||
     *            (first.prev == null && first.item != null)
     * 第一個結點
     */
    transient Node<E> first;

    /**
     * Pointer to last node.
     * Invariant: (first == null && last == null) ||
     *            (last.next == null && last.item != null)
     * 最後一個結點
     */
    transient Node<E> last;

    //Node的數據結構
    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的數據結構是：

LinkedList 的成員變量主要由 size（數據量大小），first(頭節點)和last（尾節點）。結合數據結構中雙端鏈表的思想，每個節點需要擁有，保存數據（E item），指向下一節點（Node next ）和指向上一節點（Node prev）。

LinkedList 與ArrayLit、Vector 的成員變量對比中，明顯沒有提供 MAX_ARRAY_SIZE 這一個最大值的限定，這是由於鏈表沒有長度限制的原因，他的內存地址不需要分配固定長度進行存儲，只需要記錄下一個節點的存儲地址即可完成整個鏈表的連續。

這篇文章的源碼是是基於JDK1.8的，那麼LinkedList在JDK1.6與JDK1.8有什麼區別呢？

主要不同爲，LinkedList 在1.6 版本以及之前，只通過一個 header 頭指針保存隊列頭和尾。這種操作可以說很有深度，但是從代碼閱讀性來說，卻加深了閱讀代碼的難度。因此在後續的JDK 更新中，將頭節點和尾節點區分開了。節點類也更名爲 Node。

爲什麼Node這個類是靜態的？答案是：這跟內存泄露有關，Node類是在LinkedList類中的，也就是一個內部類，若不使用static修飾，那麼Node就是一個普通的內部類，在java中，一個普通內部類在實例化之後，默認會持有外部類的引用，這就有可能造成內存泄露。但使用static修飾過的內部類（稱爲靜態內部類），就不會有這種問題，在Android中，有很多這樣的情況，如Handler的使用。好像扯遠了~

1.3、LinkedList 構造函數

LinkedList 只提供了兩個構造函數：

LinkedList()
LinkedList(Collection

1.3.1、LinkedList()

在jdk1.6中的實現是：

private transient Entry<E> header = new Entry<E>(null, null, null);
    public LinkedList() {
        header.next = header.previous = header;
    }

JDK 1.8 在使用的時候，纔會創建第一個節點。

 public LinkedList() {
    }

1.3.2、LinkedList(Collection

public LinkedList(Collection<? extends E> c) {
        this();
        addAll(c);
}

1.3.3、小結

LinkedList 在新版本的實現中，除了區分了頭節點和尾節點外，更加註重在使用時進行內存分配，這裏跟ArrayList 類似（ArrayList 默認構造器是創建一個空的數組對象）。

### 1.4、LinkedList的方法

1.4.1、添加方法（Add）概覽

LinkedList 繼承了 AbstractSequentialList（AbstractList），同時實現了Deque（隊列）接口，因此，他在添加方法這一塊，包含了兩者的操作：

AbstractSequentialList:

add(E e)
add(int index，E e)
addAll(Collection

1.4.2、 add(E e) & addLast(E e) & offer(E e) & offerLast(E e)

雖然 LinkedList 分別實現了List 和 Deque 的添加方法，但是在某種意義上，這些方法其實都是有共性的。例如，我們調用add（E e）方法，不管是ArrayList 或 Vector 等列表，都是默認在數組末尾進行添加，因此與隊列中在末尾添加節點 addLast（E e）是有着一樣的韻味的。所以，從LinkedList 的源碼中，這幾個方法，底層操作其實是一致的。

“`java
public boolean add(E e) {
linkLast(e);
return true;
}

public void addLast(E e) {
linkLast(e);
}

public boolean offer(E e) {
return add(e);
}

public boolean offerLast(E e) {
addLast(e);
return true;
}

void linkLast(E e) {
final Node l = last;
//Node的構造函數 Node(Node prev, E element, Node next)
final Node newNode = new Node<>(l, e, null);
last = newNode;
if (l == null)
first = newNode;
else
l.next = newNode;
size++;
modCount++;
}

“`

我們主要是分析linkLast的代碼，也就是鏈表在末尾進行插入的代碼：

獲取表尾結點
創建插入結點，使插入結點的前一個元素指向表尾，數據爲 e ,下一個元素指向null
更新尾指針，使尾指針指向新插入的結點
如果l(初始末尾結點) == null，說明這是插入的第一個元素，則頭結點指向新插入的結點
如果不是，則更新初始的尾結點，使其next的指針指向新插入的結點

思考：爲什麼Node l 需要使用的是final進行修飾的？

首先我們大概的瞭解一下final修飾變量的作用，一個永不改變的編譯時常量。一個在運行時被初始化的值，而你不希望在運行時改變他

1.4.3、 addFirst(E e) & offerFirst（E e）

在頭部添加元素

public boolean offerFirst(E e) {
        addFirst(e);
        return true;
    }

    public void addFirst(E e) {
        linkFirst(e);
    }

    private void linkFirst(E e) {
        final Node<E> f = first;
        //Node的構造函數 Node(Node<E> prev, E element, Node<E> next)
        final Node<E> newNode = new Node<>(null, e, f);
        first = newNode;
        if (f == null)
            last = newNode;
        else
            f.prev = newNode;
        size++;
        modCount++;
    }

從上述代碼可以看出，offerFirst 和addFirst 其實都是一樣的操作，只是返回的數據類型不同。

下面也是簡單的分析一下linkFirst的步驟：

（1）：獲取表頭結點f

（2）：創建新結點newNode，新結點的prev指針指向的是null，新結點的尾結點指向的是ｆ（初始的表頭結點）

（３）：新的頭指針指向新創建的結點newNode

（4）：判斷f(初始的表頭結點) == null ，如果初始的表頭結點爲空的情況下，則說明這個鏈表的初始的狀態是空，所以尾指針last指向的也是這個新創建的結點newNode

（5）：如果不爲空，初始的表頭結點的prev指針指向的是新創建的結點

#### 1.4.3、add(int index，E e)

這裏我們主要講一下，爲什麼LinkedList 在添加、刪除元素這一方面優於 ArrayList。

public void add(int index, E element) {
        checkPositionIndex(index);
        // 如果插入節點爲末尾，直接插入
        if (index == size)
            linkLast(element);
        // 否則，找到該節點，把新的結點插入到找到的結點的位置
        else
            linkBefore(element, node(index));
    }

    Node<E> node(int index) {
        // 這裏順序查找元素，通過二分查找的方式，決定從頭或尾節點開始進行查找，時間複雜度爲 n/2
        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;
        }
    }

    void linkBefore(E e, Node<E> succ) {
        // assert succ != null;
        final Node<E> pred = succ.prev;
        //Node的構造函數 Node(Node<E> prev, E element, Node<E> next)
        final Node<E> newNode = new Node<>(pred, e, succ);
        succ.prev = newNode;
        if (pred == null)
            first = newNode;
        else
            pred.next = newNode;
        size++;
        modCount++;
    }

LinkedList 在 add（int index，Element e）方法的流程

判斷下標有效性
如果插入位置爲末尾，直接插入
否則，遍歷1/2的鏈表找到 index 下標的節點
通過 succ 設置新節點的前，後節點

下面分析一下 linkBefore (E e, Node<E> succ）的操作：

找到待插入結點的前一個結點pred
創建需要新插入的結點，新插入結點的prev指針指向的是pred，next指針指向的是找到的結點succ
設置succ的prev前向指針指向的是succ
pred如果爲空的話，說明找到的結點是頭結點，則頭指針指向新創建的結點、
如果不是空的情況下，則pred的next指針指向的是新結點

LinkedList 在插入數據之所以會優於ArrayList，主要是由於在插入數據這一環節（linkBefore），插入計算只需要設置節點的前，後節點即可，而ArrayList 則需要將整個數組的數據進行後移

1.4.4、addAll(Collection

 public boolean addAll(Collection<? extends E> c) {
        return addAll(size, c);
    }

      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;
        //獲取插入節點的前節點（prev）和尾節點（next）
        if (index == size) {
            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)
                first = newNode;
            else
                pred.next = newNode;
            pred = newNode;
        }
        //將 Collection 的鏈表插入 LinkedList 中。
        if (succ == null) {
            last = pred;
        } else {
            pred.next = succ;
            succ.prev = pred;
        }

        size += numNew;
        modCount++;
        return true;
    }

1.4.5、小結

LinkedList 在插入數據優於ArrayList ，主要是因爲他只需要修改指針的指向即可，而不需要將整個數組的數據進行轉移。而LinkedList 差於沒有實現 RandomAccess，或者說不支持索引搜索的原因，他在查找元素這一操作，需要消耗比較多的時間進行操作（n/2）。

1.4.6、刪除方法的總覽

AbstractSequentialList：

remove（int index）
remove（Object o）

Deque

remove()
removeFirst()
removeLast()
removeFirstOccurrence(Object o)
removeLastOccurrence(Object o）

1.4.7、remove(int index)&remove（Object o）

在 ArrayList 中，remove（Object o）方法，是通過遍歷數組，找到下標後，通過fastRemove（與 remove（int i）類似的操作）進行刪除。而LinkedList，則是遍歷鏈表，找到目標節點（node），通過 unlink 進行刪除：我們這裏主要來看看 unlink 方法：

public E remove(int index) {
    checkElementIndex(index);
    //node(index)找到index位置的元素
    return unlink(node(index));
}

/**remove(Object o)這個刪除元素的方法的形參o是數據本身，而不是LinkedList集合中的元素（節點），所以需要先通過節點遍歷的方式，找到o數據對應的元素，然後再調用unlink(Node x)方法將其刪除
*/
public boolean remove(Object o) {
    if (o == null) {
        for (Node<E> x = first; x != null; x = x.next) {
            if (x.item == null) {
                unlink(x);
                return true;
            }
        }
    } else {
        for (Node<E> x = first; x != null; x = x.next) {
            if (o.equals(x.item)) {
                unlink(x);
                return true;
            }
        }
    }
    return false;
}


E unlink(Node<E> x) {
    // assert x != null;
    //x的數據域element
    final E element = x.item;
    //x的下一個結點
    final Node<E> next = x.next;
    //x的上一個結點
    final Node<E> prev = x.prev;

    //如果x的上一個結點是空結點的話，那麼說明這個結點是頭結點
    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--;
    modCount++;
    return element;
}

在remove(int index)這個方法中，先通過index和node(int index)拿到了要被刪除的元素x，然後調用了unlink(Node x)方法將其刪除，自然，LinkedList刪除元素的核心方法就是unlink(Node x)，刪除操作分以下幾個步驟：

1、通過要刪除的元素x拿到它的前驅節點prev和後繼節點next。

2、若前驅節點prev爲null，說明x是集合中的首個元素，直接將first指向後繼節點next即可；

若不爲null，則讓前驅節點prev的next指向後繼節點next，再將x的prev置空。（這時prev與x的關聯就解除了，並與next建立了聯繫）。

3、若後繼節點next爲null，說明x是集合中的最後一個元素，直接將last指向前驅節點prev即可；（下圖分別對應步驟2中的兩種情況）

若不爲null，則讓後繼節點next的prev指向前驅節點prev，再將x的next置空。（這時next與x的關聯就解除了，並與prev建立了聯繫）

4、最後，讓記錄集合長度的size減1。

說到底就是雙向鏈表的刪除擦操作

1.4.8、Deque 中的Remove

Deque 中的 removeFirstOccurrence 和 removeLastOccurrence 主要過程爲，首先從first/last 節點開始遍歷，當發現第一個目標對象，則調用remove（Object o）進行刪除對象。總體上沒有什麼特別之處。

稍有不同的是Deque 中的removeFirst（）和removeLast（）方法，在底層實現上面，由於明確知道刪除的對象爲first/last對象，因此在刪除操作上面會更加簡單：

“`java
public E removeFirst() {
final Node f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}

private E unlinkFirst(Node<E> f) {
    // assert f == first && f != null;
    final E element = f.item;
    //獲取到頭結點的下一個結點           
    final Node<E> next = f.next;
    f.item = null;
    f.next = null; // help GC
    //頭指針指向的是頭結點的下一個結點
    first = next;
    //如果next爲空，說明這個鏈表只有一個結點
    if (next == null)
        last = null;
    else
        next.prev = null;
    size--;
    modCount++;
    return element;
}

“`

整體操作爲，將first 節點的next 設置爲新的頭節點，然後將 f 清空。 removeLast 操作也類似。

1.5、LinkedList 雙端鏈表（隊列Queue）

這裏要順帶分析下java中的隊列實現，why？因爲java中隊列的實現就是LinkedList，你可能會疑問，隊列的英文是Queue，在java中也有對應的接口，怎麼會跟LinkedList扯上關係呢？因爲LinkedList實現了隊列：我們之所以說LinkedList 爲雙端鏈表，是因爲他實現了Deque 接口；我們知道，隊列是先進先出的，添加元素只能從隊尾添加，刪除元素只能從隊頭刪除，Queue中的方法就體現了這種特性。支持隊列的一些操作，我們來看一下有哪些方法實現：

pop（）是棧結構的實現類的方法，返回的是棧頂元素，並且將棧頂元素刪除
poll（）是隊列的數據結構，獲取對頭元素並且刪除隊頭元素
push（）是棧結構的實現類的方法，把元素壓入到棧中
peek（）獲取隊頭元素，但是不刪除隊列的頭元素
offer（）添加隊尾元素

可以看到Deque 中提供的方法主要有上述的幾個方法，接下來我們來看看在LinkedList 中是如何實現這些方法的。

1.5.1、隊列的增

offer（）添加隊尾元素

   public boolean offer(E e) {
       return add(e);
   }

具體的實現就是在尾部添加一個元素，我們在上面的代碼中已經進行了分析

1.5.2、隊列的刪

poll（）是隊列的數據結構，獲取對頭元素並且刪除隊頭元素

public E poll() {
    final Node<E> f = first;
    return (f == null) ? null : unlinkFirst(f);
}

具體的實現前面已經講過，刪除的是隊列頭部的元素

1.5.3、隊列的查

peek（）獲取隊頭元素，但是不刪除隊列的頭元素

public E peek() {
    final Node<E> f = first;
    return (f == null) ? null : f.item;
}

1.5.4、棧的增

push（）是棧結構的實現類的方法，把元素壓入到棧中

push（）方法的底層實現，其實就是調用了 addFirst（Object o）

  public void push(E e) {
       addFirst(e);
   }

1.5.5、棧的刪

pop（）是棧結構的實現類的方法，返回的是棧頂元素，並且將棧頂元素刪除

“`java
public E pop() {
return removeFirst();
}
public E removeFirst() {
final Node f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}

“`

總結

LinkedList 由於沒有實現 RandomAccess，因此，在以隨機訪問的形式進行遍歷時效果會非常低下。除此之外，LinkedList 提供了類似於通過Iterator 進行遍歷，節點的prev 或 next 進行遍歷，還有for循環遍歷，都有不錯的效果。

參考文獻

Java 集合系列3、骨骼驚奇之LinkedList

LinkedList與Queue源碼分析

List集合之LinkedList深度解析

List集合之LinkedList深度解析

1.1、結構圖

1.3、LinkedList 構造函數

1.3.1、LinkedList()

1.3.2、LinkedList(Collection

1.3.3、小結

1.4.1、添加方法（Add）概覽

1.4.2、 add(E e) & addLast(E e) & offer(E e) & offerLast(E e)

1.4.3、 addFirst(E e) & offerFirst（E e）

1.4.4、addAll(Collection

1.4.5、小結

1.4.6、刪除方法的總覽

1.4.7、remove(int index)&remove（Object o）

1.4.8、Deque 中的Remove

1.5、LinkedList 雙端鏈表（隊列Queue）

1.5.1、隊列的增

1.5.2、隊列的刪

1.5.3、隊列的查

1.5.4、棧的增

1.5.5、棧的刪

總結

參考文獻

C語言--右移左移

一個開源且全面的C#算法實戰教程

12款高效開源Wiki系統推薦，打造團隊知識管理利器

dotnet 基於 DirectML 控制檯運行 Phi-3 模型

自定義MyBatis插件

一款.NET開源、功能強大、跨平臺的繪圖庫 - OxyPlot

常用的 Git 指令

sm4加密工具類

[重識多線程] 01- java多線程創建

IDEA-Debug高級技巧

PicGo + 阿里雲oss搭建個人圖牀工具

線程同步與死鎖（3）

Java併發編程：volatile關鍵字解析

Mac下配置sublime實現LaTeX

https://yachay.unat.edu.pe/blog/index.php?comment_area=format_blog&comment_component=blog&comment_co

linux以太網驅動總結