走進 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，它提供了一些集合型別無關的基本方法的實現，如getsetaddremove等。通常實現它的集合型別不具備隨機訪問能力，這和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 機制，這裡就不再贅述了。
雙向連結串列由於可以反向遍歷，相較於單向連結串列在某些操作上具有效能優勢，但是由於每個結點都需要額外的記憶體空間來儲存前驅指標，所以雙向連結串列相對來說需要佔用更多的記憶體空間，這也是 空間換時間 的一種體現。