- 本文對LinkedList的實現討論都基于JDK8版本
Java中的LinkedList類實現了List接口和Deque接口，是一種鏈表類型的數據結構，支持高效的插入和刪除操作，同時也實現了Deque接口，使得LinkedList類也具有隊列的特性。LinkedList類的底層實現的數據結構是一個雙端的鏈表。
LinkedList類中有一個內部私有類Node，這個類就代表雙端鏈表的節點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;
}
}
注意這個節點的初始化方法，給定三個參數，分別前驅節點，本節點的值，后繼結點。這個方法將在LinkedList的實現中多次調用。
下圖是LinkedList內部結構的可視化，能夠幫我們更好的理解LinkedList內部的結構。
雙端鏈表由node組成，每個節點有兩個reference指向前驅節點和后繼結點，第一個節點的前驅節點為null，最后一個節點的后繼節點為null。
LinkedList類有很多方法供我們調用。我們不會一一介紹，本文會詳細介紹其中幾個最核心最基本的方法，LinkedList的創建添加和刪除基本都和這幾個操作有關。
- linkFirst() method
首先我們介紹第一個方法，linkFirst（），顧名思義，這個方法是插入第一個節點，我們先直接上代碼，看看它的具體實現
/**
* Links e as first element.
*/
private void linkFirst(E e) {
final Node<E> f = first;
final Node<E> newNode = new Node<>(null, e, f);
first = newNode;
if (f == null)
last = newNode;
else
f.prev = newNode;
size++;
modCount++;
}
我們發現出現了兩個變量，first和last這兩個變量是LinkedList的成員變量，分別指向頭結點和尾節點。他們是如下定義的：
/**
* 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;
我們可以看到注釋中的內容。first和last需要維持一個不變量，也就是first和last始終都要維持兩種狀態：
首先，如果雙端鏈表為空的時候，兩個都必須為null
如果鏈表不為空，那么first的前驅節點一定是null，first的item一定不為null，同理，last的后繼節點一定是null，last的item一定不為null。
知道了first和last之后，我們就可以開始分析linkFirst的代碼了。
linkFirst的作用就是在first節點的前面插入一個節點，插入完之后，還要更新first節點為新插入的節點，并且同時維持last節點的不變量。
我們開始分析代碼，首先用f來臨時保存未插入前的first節點，然后調用的node的構造函數新建一個值為e的新節點，這個節點插入之后將作為first節點，所以新節點的前驅節點為null，值為e，后繼節點是f,也就是未插入前的first節點。
然后就是維持不變量，首先第一種情況，如果f==null，那就說明插入之前，鏈表是空的，那么新插入的節點不僅是first節點還是last節點，所以我們要更新last節點的狀態，也就是last現在要指向新插入的newNode。
如果f!=null那么就說明last節點不變，但是要更新f的前驅節點為newNode，維持first節點的不變量。
最后size加一就完成了操作。
- linkLast() method
分析了linkFirst方法，對于 linkLast()的代碼就很容易理解了，只不過是變成了插入到last節點的后面。我們直接看代碼
/**
* Links e as last element.
*/
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;
else
l.next = newNode;
size++;
modCount++;
}
到這里我們發現有這個兩個方法，我們已經可以實現一個簡單隊列的插入操作，上面兩個方法就可以理解為插入隊頭元素和隊尾元素，這也說明了LinkedList是實現了Deque接口的。
從源碼中也可以看出，addfirst和addLast這兩個方法內部就是直接調用了linkFirst和LinkLast
/**
* Inserts the specified element at the beginning of this list.
*
* @param e the element to add
*/
public void addFirst(E e) {
linkFirst(e);
}
/**
* Appends the specified element to the end of this list.
*
* <p>This method is equivalent to {@link #add}.
*
* @param e the element to add
*/
public void addLast(E e) {
linkLast(e);
}
- linkBefore(E e, Node<E> succ)
下面我們看一個linkBefore方法,從名字可以看出這個方法是在給定的節點前插入一個節點，可以說是linkFirst和linkLast方法的通用版。
/**
* Inserts element e before non-null Node 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;
if (pred == null)
first = newNode;
else
pred.next = newNode;
size++;
modCount++;
}
我們可以看到代碼的實現原理基本和前面的兩個方法一致，這里是假設插入的這個節點的位置是非空的。
- add(int index, E element)
下面我們看add方法，這個方法就是最常用的，在指定下標插入一個節點。我們先來看下源碼的實現，很簡單
/**
* Inserts the specified element at the specified position in this list.
* Shifts the element currently at that position (if any) and any
* subsequent elements to the right (adds one to their indices).
*
* @param index index at which the specified element is to be inserted
* @param element element to be inserted
* @throws IndexOutOfBoundsException {@inheritDoc}
*/
public void add(int index, E element) {
checkPositionIndex(index);
if (index == size)
linkLast(element);
else
linkBefore(element, node(index));
}
首先判斷給定的index是不是合法的，然后如果index==size，就說明要插入成為最后一個節點，直接調用linklast方法，否則就調用linkBefore方法，我們知道linkBefore需要給定兩個參數，一個插入節點的值，一個指定的node，所以我們又調用了Node(index)去找到index的那個node。
我們看一下Node<E> node(int index)方法，這個方法就是找到給定index的node并返回，類似于數組的隨機讀取，但由于這里是鏈表，所以要進行查找
/**
* Returns the (non-null) Node at the specified element index.
*/
Node<E> node(int index) {
// assert isElementIndex(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;
}
}
我們看到node的實現并不是像我們想象的那樣直接就線性從頭查找，而是折半查找，有一個小優化，先判斷index在前半段還是后半段，如果在前半段就從頭開始找，如果在后半段就從后開始找，這樣最壞情況也只要找一半就可以了。
LinkedList的源碼實現并不復雜，我們只介紹這幾個方法，相信你一定對于它的內部實現原理有了一定的了解，并且也學習到了優秀的代碼書寫風格和優化。
對于remove操作，有興趣的讀者可以自行研究代碼，它類似于add操作，也是基于三個基本方法來實現的。
- unlinkFirst(Node<E> f)
- unlinkLast(Node<E> l)
- unlink(Node<E> x)
