走進 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<E> 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<E> 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<E> 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<E> 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 源碼解析，掃碼關注我吧！