書接上一篇ArrayList原始碼解析,這一節繼續分析LinkedList在Java8中的實現，它同樣實現了List介面，不過由名字就可以知道，內部實現是基於連結串列的，而且是雙向連結串列，所以Linked List在執行像插入或者刪除這樣的操作，效率是極高的，相對地，在隨機訪問方面就弱了很多。 本文基於JDK1.8中LinkedList原始碼分析 ####類定義
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
複製程式碼由上圖以及類定義片段可知，LinkedList繼承了AbstractSequentialList並且實現List，Deque，Cloneable, Serializable介面。
其中，AbstractSequentialList相較於AbstractList(ArrayList的父類),只支援次序訪問，而不支援隨機訪問，因為它的
get(int index) ,set(int index, E element), add(int index, E element), remove(int index) 都是基於迭代器實現的。所以在LinkedList使用迭代器遍歷更快，而ArrayList使用get (i)更快。
介面方面，LinkedList多繼承了一個Deque介面，所以實現了雙端佇列的一系列方法。
####基本資料結構
transient int size = 0;
transient Node<E> first;
transient Node<E> last;
複製程式碼LinkedList中主要定義了頭節點指標，尾節點指標，以及size用於計數連結串列中節點個數。那麼每一個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;//前驅節點
}
}
複製程式碼可以看出，這是一個典型的雙向連結串列的節點。
- getFirst獲取頭節點
- getLast獲取尾節點
- get(int index) 獲取指定位置的節點
public E getFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return f.item;
}
複製程式碼檢查非空後，直接返回first節點的item
public E getLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return l.item;
}
複製程式碼檢查非空後，直接返回last節點的item
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
複製程式碼首先檢查index範圍，然後呼叫node(index)獲取index處的節點，返回該節點的item值。 看看node(index)的實現，後面很多地方藉助於這個小函式：
Node<E> node(int index) {
// assert isElementIndex(index);
if (index < (size >> 1)) { //判斷index是在連結串列偏左側還是偏右側
Node<E> x = first;
for (int i = 0; i < index; i++) //從左邊往右next
x = x.next;
return x;
} else {
Node<E> x = last;
for (int i = size - 1; i > index; i--) //從右往左prev
x = x.prev;
return x;
}
}
複製程式碼由上面可以看出，在連結串列中找一個位置，只能通過不斷遍歷。
另外還有IndexOf，LastIndexOf操作，找出指定元素在LinkedList中的位置： 也是一個從前找，一個從後找，只分析下IndexOf操作：
public int indexOf(Object o) {
int index = 0;
if (o == null) {
for (Node<E> x = first; x != null; x = x.next) {
if (x.item == null)
return index;
index++;
}
} else {
for (Node<E> x = first; x != null; x = x.next) {
if (o.equals(x.item))
return index;
index++;
}
}
return -1;
}
複製程式碼主要也是不斷遍歷，找到值相等的節點，返回它的Index。
####更改節點的值 主要也就是一個set函式
public E set(int index, E element) {
checkElementIndex(index);
Node<E> x = node(index);
E oldVal = x.item;
x.item = element;
return oldVal;
}
複製程式碼根據index找到指定節點，更改它的值，並且會返回原有值。
####插入節點 LinkedList實現了Deque介面，支援在連結串列頭部和尾部插入元素：
public void addFirst(E e) {
linkFirst(e);
}
public void addLast(E e) {
linkLast(e);
}
複製程式碼這裡我們可以看到內部實現的函式是linkFirst,linkLast,
連結串列頭插入元素：
private void linkFirst(E e) {
final Node<E> f = first; //現將原有的first節點儲存在f中
final Node<E> newNode = new Node<>(null, e, f); //將新增節點包裝成一個Node節點，同時該節點的next指向之前的first
first = newNode; //將新增的節點設成first
if (f == null)
last = newNode; //如果原來的first就是空，那麼新增的newNode同時也是last節點
else
f.prev = newNode; //如果不是空，則原來的first節點的前置節點就是現在新增的節點
size++; //插入元素後，節點個數加1
modCount++; //還記得上一篇講述的快速失敗嗎？這邊依然是這個作用
}
複製程式碼- 將原有頭節點儲存到f
- 將插入元素包裝成新節點，並且該新節點的next指向原來的頭節點，即f
- 如果原來的頭節點f為空的話，那麼新插的頭節點也是last節點，否則，還要設定f的前置節點為NewNode，即NewNode現在是first節點了
- 記得增加size，記錄修改次數modCount
連結串列尾插入元素
void linkLast(E e) {
final Node<E> l = last; //將尾節點儲存到l中
final Node<E> newNode = new Node<>(l, e, null); //把e包裝成Node節點，同時把該節點的前置節點設定為l
last = newNode; //把新插的節點設定為last節點
if (l == null)
first = newNode; //如果原來的last節點為空，那麼新增的節點在意義上也是first節點
else
l.next = newNode; //否則的話還要將newNode設為原有last節點的後繼節點，所以newNode現在是新的Last節點
size++;
modCount++;
}
複製程式碼在指定index處插入元素
public void add(int index, E element) {
checkPositionIndex(index);
if (index == size)
linkLast(element);
else
linkBefore(element, node(index));
}
複製程式碼首先呼叫checkPositionIndex檢查index值是否在範圍內，如果index在最後的話，就呼叫在尾部插入的函式，否則呼叫LinkBefore，主要看LinkBefore如何實現的：
void linkBefore(E e, Node<E> succ) { //在succ節點前插入newNode
// assert succ != null;
final Node<E> pred = succ.prev; //將succ的前置節點記為pred
final Node<E> newNode = new Node<>(pred, e, succ); 以pred為前置節點，以succ為後繼節點建立newNode
succ.prev = newNode; //將new Node設為succ的前置節點
if (pred == null)
first = newNode; //如果原有的succ的前置節點為空，那麼新插入的newNode就是first節點
else
pred.next = newNode; // 否則，要把newNode設為原來pred節點的後置節點
size++;
modCount++;
}
複製程式碼其餘幾個常用的add方法也是基於以上函式：
public boolean add(E e) {
linkLast(e);
return true;
}
複製程式碼add函式預設在函式尾部插入元素
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}
複製程式碼addAll(Collection<? extends E> c)指的是在list尾部插入一個集合，具體實現又依賴於addAll(size，c)，指的是在指定位置插入一個集合：
public boolean addAll(int index, Collection<? extends E> c) {
checkPositionIndex(index); // 檢查index位置是否超出範圍
Object[] a = c.toArray(); //將集合c轉變成Object陣列 同時計算陣列長度
int numNew = a.length;
if (numNew == 0)
return false;
Node<E> pred, succ;
if (index == size) { //如果插入位置為尾部，succ則為null，原來連結串列的last設定為此刻的pred節點
succ = null;
pred = last;
} else {
succ = node(index); //否則，index所在節點設定為succ，succ的前置節點設為pred
pred = succ.prev;
}
for (Object o : a) { //迴圈遍歷陣列a
@SuppressWarnings("unchecked") E e = (E) o;
Node<E> newNode = new Node<>(pred, e, null); //以a為element元素構造Node節點
if (pred == null)
first = newNode; //如果pred為空，此Node就為first節點
else
pred.next = newNode; //否則就往pred後插入該Node
pred = newNode; //newNode此刻成為新的pred, 這樣不斷迴圈遍歷，把這個陣列插入到連結串列中
}
if (succ == null) { //如果succ為空，就把插入的最後一個節點設為last
last = pred;
} else {
pred.next = succ; //否則，把之前儲存的succ接到pred後面
succ.prev = pred; //並且把succ的前向指標指向插入的最後一個元素
}
size += numNew; //記錄增長的尺寸
modCount++; //記錄修改次數
return true;
}
複製程式碼具體流程可以看程式碼中的註釋。
####刪除節點####
因為實現了Deque的介面，所以還是實現了removeFirst, removeLast方法。
public E removeFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}
複製程式碼首先儲存fisrt節點到f，如果為空，丟擲NoSuchElementException異常，實際還是呼叫unlinkFirst完成操作。
private E unlinkFirst(Node<E> f) {
// assert f == first && f != null;
final E element = f.item; //把f.item的值儲存到element
final Node<E> next = f.next; //把f.next的值記住
f.item = null;
f.next = null; // help GC //把item和next的都指向null
first = next; //next成為實際的first節點
if (next == null) //next為空的話，因為next是第一個節點，所以連結串列都是空的，last也為空
last = null;
else
next.prev = null; //next不為空，也要將它的前驅節點記為null，因為next是第一個節點
size--; //節點減少一個
modCount++; //操作次數加1
return element;
}
複製程式碼removeLast的實現基本和removeFirst對稱：
public E removeLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return unlinkLast(l);
}
複製程式碼主要實現還是藉助於unlinkLast:
private E unlinkLast(Node<E> l) {
// assert l == last && l != null;
final E element = l.item; //儲存最後一個節點的值
final Node<E> prev = l.prev; //把最後一個節點的前驅節點記為prev，它將成為last節點
l.item = null;
l.prev = null; // help GC //l節點的item和prev都記為空
last = prev; //此時設定剛才記錄的前驅節點為last
if (prev == null) //prev為空的話，說明要刪除的l前面原來沒節點，那麼刪了l，整個連結串列為空
first = null;
else
prev.next = null; //prev成為最後一個節點，沒有後繼節點
size--;
modCount++;
return element;
}
複製程式碼在指定index刪除
public E remove(int index) {
checkElementIndex(index);
return unlink(node(index));
}
複製程式碼首先也是檢查index是否合法，否則丟擲IndexOutOfBoundsException異常。
如果刪除成功，返回刪除的節點。
具體實現依賴於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) {
first = next;
} else {
prev.next = next;
x.prev = null;
}
if (next == null) {
last = prev;
} else {
next.prev = prev;
x.next = null;
}
x.item = null;
size--;
modCount++;
return element;
}
複製程式碼- 將刪除的節點儲存在element裡，同時把要刪除節點的前驅節點標記為prev,後繼節點標記為next；
- 如果prev為空，那麼next節點直接為first節點，反之把prev的next指向next節點，如圖中上面彎曲的紅色箭頭所示；
- 如果next為空，那麼prev節點直接為last節點，反之把next的prev指向prev節點，如圖中下面彎曲的藍色箭頭所示；
- 把要刪除的節點置空，返回第一步儲存的element。
還有種刪除是以刪除的元素作為引數：
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為null，也是遍歷連結串列，找到第一個值為null的節點，刪除；
- o部位空，遍歷連結串列，找到第一個值相等的節點，呼叫unlink(x)刪除。
####清空列表
public void clear() {
// Clearing all of the links between nodes is "unnecessary", but:
// - helps a generational GC if the discarded nodes inhabit
// more than one generation
// - is sure to free memory even if there is a reachable Iterator
for (Node<E> x = first; x != null; ) {
Node<E> next = x.next;
x.item = null;
x.next = null;
x.prev = null;
x = next;
}
first = last = null;
size = 0;
modCount++;
}
複製程式碼由程式碼看出，也就是迴圈遍歷整個連結串列，將每個節點的每個屬性都置為空。
LinkedList還定義了很多別的方法，基本上和上面分析的幾個函式功能類似
- elemet和GetFirst一樣，都返回列表的頭，並且不移除它，如果列表為空，都會丟擲NoSucnElement異常；
- peek也會返回第一個元素，但是為空時返回null, 不拋異常；
- remove方法內部就是呼叫removeFirst，所以表現相同，返回移除的元素，如果列表為空，都會丟擲NoSucnElement異常；
- poll也是移除第一個元素，只是會在列表為空時只返回null；
- offer和offerLast在尾部add節點， 最終呼叫的都是addLast方法，offerFirst在頭保護add節點，呼叫的就是addFirst方法；
- peekFirst返回頭節點，為空時返回null，peekLast返回尾節點，為空時返回null，都不會刪除節點；
- pollFirst刪除並返回頭節點，為空時返回null ，pollLast刪除並返回尾節點，為空時返回null；
- push和pop也是讓LinkedList具有棧的功能，也只是呼叫了addFirst和removeFirst函式。
####ListIterator
最後重點說一下LinkedList中如何實現了ListIterator迭代器。
ListIterator是一個更加強大的Iterator迭代器的子型別，它只能用於各種List類的訪問。儘管Iterator只能向前移動，但是ListIterator可以雙向移動。它還可以產生相對於迭代器在列表中指向的當前位置的前一個和後一個元素的索引，可以用set()方法替換它訪問過得最後一個元素。
定義如下：
public ListIterator<E> listIterator(int index) {
checkPositionIndex(index);
return new ListItr(index);
}
複製程式碼指定index，可以在一開始就獲取一個指向index位置元素的迭代器。 實際上LinkedList是實現了ListItr類：
private class ListItr implements ListIterator<E> {
private Node<E> lastReturned;
private Node<E> next; //用於記錄當前節點
private int nextIndex; //用於記錄當前節點所在索引
private int expectedModCount = modCount;
ListItr(int index) {
// assert isPositionIndex(index);
next = (index == size) ? null : node(index); //返回index處的節點，記錄為next
nextIndex = index; //記錄當前索引
}
public boolean hasNext() {
return nextIndex < size; //通過判斷nextIndex是否還在size範圍內
}
public E next() {
checkForComodification();
if (!hasNext())
throw new NoSuchElementException();
lastReturned = next; //記錄上一次的值
next = next.next; //往後移動一個節點
nextIndex++; //索引值也加1
return lastReturned.item; //next會返回上一次的值
}
public boolean hasPrevious() { //通過哦按段nextIndex是否還大於0，如果<=0，就證明沒有前驅節點了
return nextIndex > 0;
}
public E previous() {
checkForComodification();
if (!hasPrevious())
throw new NoSuchElementException();
lastReturned = next = (next == null) ? last : next.prev; //往前移動
nextIndex--;
return lastReturned.item;
}
public int nextIndex() {
return nextIndex;
}
public int previousIndex() {
return nextIndex - 1;
}
public void remove() {
checkForComodification();
if (lastReturned == null)
throw new IllegalStateException();
Node<E> lastNext = lastReturned.next;
unlink(lastReturned);
if (next == lastReturned)
next = lastNext;
else
nextIndex--;
lastReturned = null;
expectedModCount++;
}
public void set(E e) {
if (lastReturned == null)
throw new IllegalStateException();
checkForComodification();
lastReturned.item = e;
}
public void add(E e) {
checkForComodification();
lastReturned = null;
if (next == null)
linkLast(e);
else
linkBefore(e, next);
nextIndex++;
expectedModCount++;
}
public void forEachRemaining(Consumer<? super E> action) {
Objects.requireNonNull(action);
while (modCount == expectedModCount && nextIndex < size) {
action.accept(next.item);
lastReturned = next;
next = next.next;
nextIndex++;
}
checkForComodification();
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}
複製程式碼我們可以發現在ListIterator的操作中仍然有checkForComodification函式，而且在上面敘述的各種操作中還是會記錄modCount,所以LinkedList也是會產生快速失敗事件的。