走進 JDK 之 LinkedList

走進 JDK 系列第 15 篇

概述

若是你瞭解鏈表的基本結構的話，LinkedList 的源碼其實仍是比較容易理解的。LinkedList 是基於雙向鏈表實現的，與 ArrayList 不一樣的是，它在內存中不佔用連續的內存空間，相連元素之間經過 「鏈」 來連接。對於單鏈表，每一個節點有一個 後繼指針 指向下一個節點。對於雙向鏈表來講，除了後繼指針外，它還要一個 前驅指針 指向前一個節點。那麼，雙向鏈表有什麼好處呢？既然有了前驅指針，在遍歷的時候就能夠向前遍歷，在下面的源碼分析中能夠看到，這是單鏈表所不具有的功能。

前面介紹 ArrayList 的時候說過，數組具有隨機訪問能力，其根據下標隨機訪問的時間複雜度是 O(1)。一樣，爲了保證內存的連續性，其 插入 和 刪除 操做就相對低效的多。而鏈表正好與其相反，其不具有隨機訪問能力，可是 插入 和 刪除 就相對高效，僅僅只需修改 後繼指針 和 前驅指針 指向的節點便可。其插入和刪除操做的時間複雜度均爲 O(1)，但這個 O(1) 其實也不是很嚴謹。刪除指定節點，仍是刪除值等於給定值的節點，單鏈表仍是雙向鏈表，其實時間複雜度的表現都是不同的，下面的源碼解析中也會有所體現。好了，關於鏈表就說這麼多了，下面來進入 LinkedList 的源碼分析。

首先看一下 LinkedList 的 UML 圖：

源碼解析

類聲明

public class LinkedList<E> extends AbstractSequentialList<E> implements List<E>, Deque<E>, Cloneable, java.io.Serializable {}
複製代碼

• 繼承了抽象類 AbstractSequentialList，它提供了一些集合類型無關的基本方法的實現，如 get set add remove 等。一般實現它的集合類型不具有隨機訪問能力，這和 AbstractList 是相對立的。

• 實現了 List 接口

• 實現了 Deque 接口，說明也能夠當作一個雙端隊列，源碼中也實現了相關方法。

• 實現了 Cloneable 接口，提供克隆能力。和 ArrayList 同樣，也是淺拷貝。

• 實現了 Serializable 接口，提供序列化能力

成員變量

transient int size = 0; // 表示鏈表大小
transient Node<E> first; // 頭結點
transient Node<E> last; // 尾節點
private static final long serialVersionUID = 876323262645176354L;
複製代碼

順便看一下結點 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;
    }
}
複製代碼

每一個結點都包含指向前一個結點的前驅指針 prev，和指向後一個結點的後繼指針 next。通常頭結點的前驅指針和尾節點的後繼指針都指向 null。

構造函數

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

第一個是默認的無參構造，會構建一個空鏈表。第二個根據參數中的集合 經過 addAll() 方法構造鏈表，鏈表中的元素順序根據集合 c 的迭代器的迭代順序。

方法

你能夠翻一下 LinkedList 的 API 列表，提供了許許多多的方法，其實不少都是重複的。它實現了 Deque 接口中的方法，重寫了 AbstractSequentialList 類的方法，總結一下就是各類增刪改查操做，最後調用的都是本身的私有方法 linkxxx/unlinkxxx 等，很好的作到了隔離，也是一種值得學習的設計思想。下面就優先來看一下這些方法。

linkFirst(E e)

// 將 e 置爲頭結點
private void linkFirst(E e) {
    final Node<E> f = first;
    final Node<E> newNode = new Node<>(null, e, f);
    first = newNode;
    if (f == null) // 若是鏈表爲空， e 節點就是尾節點
        last = newNode;
    else
        f.prev = newNode; // 鏈表不爲空，插入 e 節點，並將原頭結點的 prev 指向 e 節點
    size++;
    modCount++;
}
複製代碼

鏈表爲空的話，插入的 e 既是頭結點也是尾節點。

鏈表不爲空的話，就移動原頭結點的前驅指針。

linkLast(E e)

// 將 e 置爲尾結點
void linkLast(E e) {
    final Node<E> l = last;
    final Node<E> newNode = new Node<>(l, e, null);
    last = newNode;
    if (l == null)
        first = newNode; // 若是鏈表爲空， e 節點就是頭節點
    else
        l.next = newNode; // 鏈表不爲空，插入 e 節點，並將原尾結點的 next 指向 e 節點
    size++;
    modCount++;
}
複製代碼

鏈表爲空的話，插入的 e 既是頭結點也是尾節點。

鏈表不爲空的話，就移動原尾結點的後繼指針。

linkBefore(E e, Node succ)

// 在節點 succ 前插入元素
void linkBefore(E e, Node<E> succ) {
    // assert succ != null;
    final Node<E> pred = succ.prev;
    final Node<E> newNode = new Node<>(pred, e, succ); // 構建新結點
    succ.prev = newNode; // 將 succ 的 prev 指針指向新結點
    if (pred == null) // pred 爲 null，說明 succ 原來就是頭結點，如今要更新頭結點
        first = newNode;
    else
        pred.next = newNode; // 將 succ 的前一個結點的 next 指針指向新結點
    size++;
    modCount++;
}
複製代碼

原理也很簡單，你能夠想象成打上結的繩子，你只須要把 succ 結點打開，而後把須要插入的結點繫上去就能夠了，時間複雜度爲 O(1)。固然，這是雙向鏈表。對於單向鏈表仍是 O(1) 嗎？顯然不是的，由於在單向鏈表中你沒辦法執行下面這行代碼：

final Node<E> pred = succ.prev;
複製代碼

也就是說你沒辦法直接拿到 succ 的前驅結點，也就無法直接將 succ 的前一個結點的 next 指針指向新結點。你只能經過遍歷去獲取前驅結點。因此，對於單鏈表來講，插入元素的時間複雜度仍是 O(n)。

unlinkFirst(Node f)

// 移除頭結點 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 頭結點置空以便 GC
    first = next;
    if (next == null) // next 爲空，說明鏈表原來只有一個元素
        last = null;
    else
        next.prev = null; // 將 next 的 prev 置空，此時 next 是頭結點
    size--;
    modCount++;
    return element;
}
複製代碼

這裏默認參數中的 f 結點就是頭結點。若是鏈表中本來只有一個元素，那麼頭尾結點都要置空。若是多於一個元素，只要把頭結點的下一個結點的前驅指針指向 null 就能夠了。

unlinkLast(Node l)

// 移除尾節點 l
private E unlinkLast(Node<E> l) {
    // assert l == last && l != null;
    final E element = l.item;
    final Node<E> prev = l.prev;
    l.item = null;
    l.prev = null; // help GC 頭結點置空以便 GC
    last = prev;
    if (prev == null) // prev 爲空，說明鏈表原來只有一個元素
        first = null;
    else
        prev.next = null; // 將 prev 的 next 置空，此時 prev 是尾結點
    size--;
    modCount++;
    return element;
}
複製代碼

和 unlinkfirst 基本一致，只要把尾結點的前一個結點的後繼指針指向 null 就能夠了。

unlink(Node x)

// 移除指定非空節點 x
E unlink(Node<E> x) {
    // assert x != null;
    final E element = x.item;
    final Node<E> next = x.next;
    final Node<E> prev = x.prev;

    if (prev == null) { // x 是頭結點
        first = next;
    } else {
        prev.next = next; // 將 x 的 next 指向 x 後面一個節點
        x.prev = null;
    }

    if (next == null) { // x 是尾節點
        last = prev;
    } else {
        next.prev = prev; // 將 x 的 prev 指向 x 前面一個節點
        x.next = null;
    }

    x.item = null;
    size--;
    modCount++;
    return element;
}
複製代碼

代碼也比較簡單，同時修改前一個結點的後繼指針和後一個結點的前驅指針就能夠了，要注意參數結點是頭結點或者尾節點的特殊狀況。時間複雜度也是 O(1)，對於單鏈表是 O(n)。

上面的插入和刪除都是針對指定結點的，還有一種狀況是針對指定值的。好比，對於一個存儲 int 值的鏈表，我要刪除值爲 1 的結點，其時間複雜度仍是 O(1) 嗎？下面來看看 remove(Object o) 方法。

remove(Object o)

public boolean remove(Object o) {
    if (o == null) { // 刪除 null 元素
        for (Node<E> x = first; x != null; x = x.next) {
            if (x.item == null) {
                unlink(x);
                return true;
            }
        }
    } else { // 刪除非 null 元素
        for (Node<E> x = first; x != null; x = x.next) {
            if (o.equals(x.item)) {
                unlink(x);
                return true;
            }
        }
    }
    return false;
}
複製代碼

很顯然，對於刪除值等於指定值的結點，時間複雜度也是 O(n)。循環遍歷獲得該結點以後再調用 unlink() 方法去刪除。還要注意一點，該方法僅僅刪除第一次出現的值等於指定值的結點，鏈表是容許重複元素的。

說完了插入和刪除，咱們再來看看查找。雖然說鏈表的查找操做必然是 O(n) 的，可是 LinkedList 仍是對查找操做作了相應的優化。下面來看一下 get() 方法。

get(int index)

// 返回指定位置的元素
public E get(int index) {
    checkElementIndex(index); // 邊界檢查
    return node(index).item; // 雖然時間複雜度仍然是 O(n)，但只需遍歷一半的鏈表
}
複製代碼

checkElementIndex 檢測 index 是否越界。node() 方法用來獲取 index 處的指定結點。

Node<E> node(int index) {
    // assert isElementIndex(index);
    // 根據下標是否小於 size/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;
    }
}
複製代碼

得益於雙向鏈表的特性，LinkedList 的查找每次只需遍歷半個鏈表，雖然時間複雜度仍是 O(n)，可是是有實際上的性能提高的。

LinkedList 的方法就說這麼多了，雖然說大部分方法都沒提到，可是剩下的方法基本都是依靠上面解析過的這些方法來實現的，也就沒有單獨拿出來講的必要了。我在源碼文件中都進行了註釋，感興趣的能夠到個人 Github 查看 LinkedList.java 。

總結

LinkedList 基於雙向鏈表實現，內存中不連續，不具有隨機訪問，插入和刪除效率較高，查找效率較低。使用上沒有大小限制，自然支持擴容。

容許 null 值，容許重複元素。和 ArrayList 同樣，也是 fail-fast 機制。在 走進 JDK 之 ArrayList（二） 中已經詳細說明過 fail-fast 機制，這裏就再也不贅述了。

雙向鏈表因爲能夠反向遍歷，相較於單向鏈表在某些操做上具備性能優點，可是因爲每一個結點都須要額外的內存空間來存儲前驅指針，因此雙向鏈表相對來講須要佔用更多的內存空間，這也是 空間換時間 的一種體現。

文章首發微信公衆號： 秉心說 ， 專一 Java 、 Android 原創知識分享，LeetCode 題解。

更多 JDK 源碼解析，掃碼關注我吧！