轉載請標明出處：
http://www.lxweimin.com/p/e69557b217c0
本文出自:【張旭童的簡書】 (http://www.lxweimin.com/users/8e91ff99b072/latest_articles)
代碼傳送門：喜歡的話，隨手點個star。多謝
https://github.com/mcxtzhang/
概述
本篇是Java集合類解析的第二篇，上一篇[面試必備：ArrayList源碼解析（JDK8）]里，我們嘮了ArrayList，今兒來繼續說LinkedList.面試中，這兄弟倆也經常會拿來比較。
它們兩可以說是List接口的兩種不同的實現，ArrayList的增刪效率低，但是改查效率高。
而LinkedList正好相反，增刪由于不需要移動底層數組數據，其底層是鏈表實現的，只需要修改鏈表節點指針，所以效率較高。
而改和查，都需要先定位到目標節點（由于允許null值的存在，往往要進行兩個for循環遍歷，時間復雜度o(n)），所以效率較低。
開篇前，再說一遍Collection.toArray(); 。
這個方法很重要，不管是ArrayList、LinkedList 在批量add的時候，都會先轉化成數組去做。 因為數組可以用for循環直接花式遍歷。比較方便 高效
套路依舊，
本文將從幾個常用方法下手，來閱讀LinkedList的源碼。
按照從構造方法->常用API（增、刪、改、查）的順序來閱讀源碼，并會講解閱讀方法中涉及的一些變量的意義。了解LinkedList的特點、適用場景。
如果本文中有不正確的結論、說法，請大家提出和我討論，共同進步，謝謝。
概述
概括的說，LinkedList 是線程不安全的，允許元素為null的雙向鏈表。
其底層數據結構是鏈表，它實現List<E>, Deque<E>, Cloneable, java.io.Serializable接口，它實現了Deque<E>,所以它也可以作為一個雙端隊列。和ArrayList比，沒有實現RandomAccess所以其以下標，隨機訪問元素速度較慢。
因其底層數據結構是鏈表，所以可想而知，它的增刪只需要移動指針即可，故時間效率較高。不需要批量擴容，也不需要預留空間，所以空間效率比ArrayList高。
缺點就是需要隨機訪問元素時，時間效率很低，雖然底層在根據下標查詢Node的時候，會根據index判斷目標Node在前半段還是后半段，然后決定是順序還是逆序查詢，以提升時間效率。不過隨著n的增大，總體時間效率依然很低。
當每次增、刪時，都會修改modCount。
構造方法
//集合元素數量
transient int size = 0;
//鏈表頭節點
transient Node<E> first;
//鏈表尾節點
transient Node<E> last;
//啥都不干
public LinkedList() {
}
//調用 public boolean addAll(Collection<? extends E> c) 將集合c所有元素插入鏈表中
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
構造方法基本沒干啥。
節點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;
}
}
可以看出，這是一個雙向鏈表。
增
1 addAll
接上文，先說addAll
//addAll ,在尾部批量增加
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);//以size為插入下標，插入集合c中所有元素
}
//以index為插入下標，插入集合c中所有元素
public boolean addAll(int index, Collection<? extends E> c) {
checkPositionIndex(index);//檢查越界 [0,size] 閉區間
Object[] a = c.toArray();//拿到目標集合數組
int numNew = a.length;//新增元素的數量
if (numNew == 0)//如果新增元素數量為0，則不增加，并返回false
return false;
Node<E> pred, succ; //index節點的前置節點，后置節點
if (index == size) { //在鏈表尾部追加數據
succ = null; //size節點（隊尾）的后置節點一定是null
pred = last;//前置節點是隊尾
} else {
succ = node(index);//取出index節點，作為后置節點
pred = succ.prev; //前置節點是，index節點的前一個節點
}
//鏈表批量增加，是靠for循環遍歷原數組，依次執行插入節點操作。對比ArrayList是通過System.arraycopy完成批量增加的
for (Object o : a) {//遍歷要添加的節點。
@SuppressWarnings("unchecked") E e = (E) o;
Node<E> newNode = new Node<>(pred, e, null);//以前置節點 和 元素值e，構建new一個新節點，
if (pred == null) //如果前置節點是空，說明是頭結點
first = newNode;
else//否則 前置節點的后置節點設置問新節點
pred.next = newNode;
pred = newNode;//步進，當前的節點為前置節點了，為下次添加節點做準備
}
if (succ == null) {//循環結束后，判斷，如果后置節點是null。 說明此時是在隊尾append的。
last = pred; //則設置尾節點
} else {
pred.next = succ; // 否則是在隊中插入的節點 ，更新前置節點 后置節點
succ.prev = pred; //更新后置節點的前置節點
}
size += numNew; // 修改數量size
modCount++; //修改modCount
return true;
}
//根據index 查詢出Node，
Node<E> node(int index) {
// assert isElementIndex(index);
//通過下標獲取某個node 的時候，（增、查 ），會根據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;
}
}
private void checkPositionIndex(int index) {
if (!isPositionIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
private boolean isPositionIndex(int index) {
return index >= 0 && index <= size; //插入時的檢查，下標可以是size [0,size]
}
小結：
- 鏈表批量增加，是靠for循環遍歷原數組，依次執行插入節點操作。對比ArrayList是通過System.arraycopy完成批量增加的
- 通過下標獲取某個node 的時候，（add select），會根據index處于前半段還是后半段 進行一個折半，以提升查詢效率
2 插入單個節點add
//在尾部插入一個節點： add
public boolean add(E e) {
linkLast(e);
return true;
}
//生成新節點 并插入到 鏈表尾部， 更新 last/first 節點。
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++;//修改size
modCount++;//修改modCount
}
//在指定下標，index處，插入一個節點
public void add(int index, E element) {
checkPositionIndex(index);//檢查下標是否越界[0,size]
if (index == size)//在尾節點后插入
linkLast(element);
else//在中間插入
linkBefore(element, node(index));
}
//在succ節點前，插入一個新節點e
void linkBefore(E e, Node<E> succ) {
// assert succ != null;
//保存后置節點的前置節點
final Node<E> pred = succ.prev;
//以前置和后置節點和元素值e 構建一個新節點
final Node<E> newNode = new Node<>(pred, e, succ);
//新節點new是原節點succ的前置節點
succ.prev = newNode;
if (pred == null)//如果之前的前置節點是空，說明succ是原頭結點。所以新節點是現在的頭結點
first = newNode;
else//否則構建前置節點的后置節點為new
pred.next = newNode;
size++;//修改數量
modCount++;//修改modCount
}
小結：
- 增一定會修改modCount
刪 remove
//刪：remove目標節點
public E remove(int index) {
checkElementIndex(index);//檢查是否越界 下標[0,size)
return unlink(node(index));//從鏈表上刪除某節點
}
//從鏈表上刪除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) { //如果前置節點為空(說明當前節點原本是頭結點)
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++; //修改modCount
return element; //返回取出的元素值
}
private void checkElementIndex(int index) {
if (!isElementIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
//下標[0,size)
private boolean isElementIndex(int index) {
return index >= 0 && index < size;
}
刪除鏈表中的指定節點，也是要遍歷兩次：
//因為要考慮 null元素，也是要遍歷兩次
public boolean remove(Object o) {
if (o == null) {//如果要刪除的是null節點(從remove和add 里 可以看出，允許元素為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;
}
//將節點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) {//前置節點為null，
first = next;//則首節點為next
} else {//否則 更新前置節點的后置節點
prev.next = next;
x.prev = null;//記得將要刪除節點的前置節點置null
}
//如果后置節點為null，說明是尾節點
if (next == null) {
last = prev;
} else {//否則更新 后置節點的前置節點
next.prev = prev;
x.next = null;//記得刪除節點的后置節點為null
}
//將刪除節點的元素值置null，以便GC
x.item = null;
size--;//修改size
modCount++;//修改modCount
return element;//返回刪除的元素值
}
刪也一定會修改modCount。 按下標刪，也是先根據index找到Node，然后去鏈表上unlink掉這個Node。 按元素刪，會先去遍歷鏈表尋找是否有該Node，考慮到允許null值，所以會遍歷兩遍，然后再去unlink它。
改set
public E set(int index, E element) {
checkElementIndex(index); //檢查越界[0,size)
Node<E> x = node(index);//取出對應的Node
E oldVal = x.item;//保存舊值 供返回
x.item = element;//用新值覆蓋舊值
return oldVal;//返回舊值
}
改也是先根據index找到Node，然后替換值，改不修改modCount
查get
//根據index查詢節點
public E get(int index) {
checkElementIndex(index);//判斷是否越界 [0,size)
return node(index).item; //調用node()方法 取出 Node節點，
}
//根據節點對象，查詢下標,也是需要遍歷兩遍鏈表。
public int indexOf(Object o) {
int index = 0;
if (o == null) {//如果目標對象是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;
}
//從尾至頭遍歷鏈表，找到目標元素值為o的節點
public int lastIndexOf(Object o) {
int index = size;
if (o == null) {
for (Node<E> x = last; x != null; x = x.prev) {
index--;
if (x.item == null)
return index;
}
} else {
for (Node<E> x = last; x != null; x = x.prev) {
index--;
if (o.equals(x.item))
return index;
}
}
return -1;
}
查不修改modCount
toArray()
我們也順帶看一下toArray().畢竟這是個高頻的API
public Object[] toArray() {
//new 一個新數組 然后遍歷鏈表，將每個元素存在數組里，返回
Object[] result = new Object[size];
int i = 0;
for (Node<E> x = first; x != null; x = x.next)
result[i++] = x.item;
return result;
}
總結：
LinkedList 是雙向列表。
鏈表批量增加，是靠for循環遍歷原數組，依次執行插入節點操作。對比ArrayList是通過System.arraycopy完成批量增加的。增加一定會修改modCount。
通過下標獲取某個node 的時候，（add select），會根據index處于前半段還是后半段 進行一個折半，以提升查詢效率
刪也一定會修改modCount。 按下標刪，也是先根據index找到Node，然后去鏈表上unlink掉這個Node。 按元素刪，會先去遍歷鏈表尋找是否有該Node，考慮到允許null值，所以會遍歷兩遍，然后再去unlink它。
改也是先根據index找到Node，然后替換值。改不修改modCount。
查本身就是根據index找到Node。
所以它的CRUD操作里，都設計到根據index去找到Node的操作。
