在JDK1.7之前，LinkedList是採用雙向環形連結串列來實現的，在1.7及之後，Oracle將LinkedList做了優化，將環形連結串列改成了線性連結串列。本文對於LinkedList的原始碼分析基於JDK1.8。
LinkedList既然是通過一個雙向線性連結串列來實現，那麼肯定就能夠很輕易的找到連結串列的第一個節點和最後一個節點，在原始碼中可以看到有這兩個欄位：
transient Node<E> first; // 連結串列第一個節點
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中有三個成員：
- item ： 儲存的元素
- next ： 下一個節點
- prev ： 上一個節點
節點中儲存有需要儲存的元素，同時持有上一個節點和下一個節點的引用，各個節點依次持有前後節點的引用就形成了一個鏈，這樣，當我們需要查詢鏈中某一個節點儲存的元素時，只需要通過第一個節點或者最後一個節點依次查詢，就可以找到我們需要的節點。
需要注意的是，在JDK1.7及之後，第一個節點first的前一個節點prev為null，最後一個節點last的後一個節點next也為null。而在JDK1.6及之前，頭節點header是一個不儲存元素的節點，header的下一個節點next是第一個元素節點，而header的上一個節點是最後一個元素節點，這樣使得它形成一個環形的雙向連結串列。
LinkedList的建構函式有兩個，一個無參，另一個可以傳入一個集合：
public LinkedList() {
}
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}複製程式碼看下addAll方法的實現：
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}
public boolean addAll(int index, Collection<? extends E> c) {
// 檢查是否越界
checkPositionIndex(index);
// 將集合c轉化為陣列a
Object[] a = c.toArray();
int numNew = a.length;
if (numNew == 0)
return false;
// pred為插入元素位置點前一個節點，succ為插入元素位置的後一個節點
Node<E> pred, succ;
if (index == size) { // index==size的話，在連結串列的末尾新增元素
succ = null;
pred = last;
} else { // 否則的話，從連結串列中間加入
succ = node(index);
pred = succ.prev;
}
// 遍歷需要加入的元素陣列a
for (Object o : a) {
// 通過元素o構造一個節點Node
@SuppressWarnings("unchecked") E e = (E) o;
Node<E> newNode = new Node<>(pred, e, null);
if (pred == null) // 插入位置的前一個節點為null，說明需要插入的是first節點
first = newNode;
else // 插入位置的前一個節點不為null，即從連結串列中或連結串列末尾插入
// 將要插入的節點複製給插入位置的上一個節點的next
pred.next = newNode;
// 將newNode賦值給下個需要插入的節點的pred
pred = newNode;
}
if (succ == null) { // succ為null，說明是從末尾新增的元素，將新增的最後一個元素賦值給last
last = pred;
} else { // 從連結串列中某個位置新增的，重新連線上新增元素時斷開的引用鏈
pred.next = succ;
succ.prev = pred;
}
// 更新連結串列的大小
size += numNew;
modCount++;
return true;
}複製程式碼在構造方法中呼叫addAll方法，相當於是向一個空連結串列中新增集合c中的元素。
如果是在已有元素的連結串列中呼叫addAll方法來新增元素的話，就需要判斷指定的新增位置index是否越界，如果越界會丟擲異常；如果沒有越界，根據新增的位置index，斷開連結串列中index位置的節點前後的引用，加入新元素，重新連上斷開位置的前後節點的引用。過程如下圖：
add方法:
public boolean add(E e) {
linkLast(e);
return true;
}複製程式碼直接就呼叫了linkLast方法，說明預設的add方法是直接將元素新增到已有的連結串列的末尾。
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++;
}複製程式碼新加入元素的節點賦值給last節點，然後判斷了一下加入之前的last節點是否為空，為空的話，說明連結串列中沒有元素，新加入的就是連結串列的first節點；不為空直接將之前的最後一個節點的next引用新增的節點即可。
還有一個add方法，指定了新增位置：
public void add(int index, E element) {
checkPositionIndex(index);
if (index == size)
linkLast(element);
else
linkBefore(element, node(index));
}複製程式碼先判斷是否越界，在判斷新增的位置是否在已有連結串列的末尾，如果在末尾就直接新增到末尾，不在末尾的話，呼叫linkBefore新增到index位置的節點之前。
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++;
}複製程式碼pred為null的話，說明succ是新增元素前連結串列的first節點，加入元素e，更新first節點，並更改引用鏈。
addFirst和addLast方法中分別呼叫了linkFirst方法和linkLast方法：
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++;
}
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++;
}複製程式碼linkFirst/linkLast方法即是將新節點新增到連結串列的頭部或者尾部，更新連結串列的prev和next引用。
remove方法：
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;
}複製程式碼不管需要移除的元素O是否為空，都是遍歷後呼叫unlink方法來刪除節點，繼續看unlink方法：
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) {
// 如果prev為null的話，那麼刪除的是first節點，將next指定為刪除後的first節點
first = next;
} else {
// prev不為null，將prev的next引用指向next，並解除x元素對prev的引用
prev.next = next;
x.prev = null;
}
if (next == null) {
// 如果next為null，那麼刪除的是last節點，將prev指定為刪除後的last節點
last = prev;
} else {
// next不為null，將next的prev引用指向prev，並解除x的next引用
next.prev = prev;
x.next = null;
}
// 置空x節點中的元素
x.item = null;
size--;
modCount++;
return element;
}複製程式碼removeFirst和removeLast方法同樣是直接呼叫了unlinkFirst和unlinkLast，實現和unlink差不多，不做過多解釋。
set方法，set方法即修改連結串列中指定位置的元素：
public E set(int index, E element) {
checkElementIndex(index);
Node<E> x = node(index);
E oldVal = x.item;
x.item = element;
return oldVal;
}複製程式碼找到指定位置的節點x，更改該節點的item屬性就行了。
獲取節點的node方法：
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;
}
}複製程式碼判斷位置index是靠近頭部還是尾部，靠近頭部，則從first節點往後遍歷，靠近尾部則從last節點往前遍歷，這種方式可以使得連結串列查詢的時候遍歷次數不會超過連結串列長度的一半，從而提升查詢效率。
get、getFirst、getLast方法：
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
public E getFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return f.item;
}
public E getLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return l.item;
}複製程式碼getFirst和getLast直接後去first和last節點中的元素值，get方法則直接呼叫了node方法，不再解釋。
LinkedList原始碼中的其他方法不再分析了，實現都很容易理解。從LinkedList的增、刪、改、查等方法的實現邏輯可以看出來，LinkedList的增和刪效率相對於改和查要高，因為每次修改和查詢都要從連結串列的頭節點或尾節點開始遍歷，而增加和刪除，只需要在制定位置斷開節點引用，新增和刪除元素後，重新連上引用鏈即可。所以，LinkedList適合用在新增和刪除比較頻繁，而修改和查詢較少的情況下。