想看我更多文章:【張旭童的部落格】blog.csdn.net/zxt0601
想來gayhub和我gaygayup:【mcxtzhang的Github主頁】github.com/mcxtzhang
概述
本篇是Java集合類解析的第二篇，上一篇[面試必備：ArrayList原始碼解析（JDK8）]裡，我們嘮了ArrayList，今兒來繼續說LinkedList.面試中，這兄弟倆也經常會拿來比較。
它們兩可以說是List介面的兩種不同的實現，ArrayList的增刪效率低，但是改查效率高。
而LinkedList正好相反，增刪由於不需要移動底層陣列資料，其底層是連結串列實現的，只需要修改連結串列節點指標，所以效率較高。
而改和查，都需要先定位到目標節點，所以效率較低。
開篇前，再說一遍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，如果有，去連結串列上unlink掉這個Node。
- 改也是先根據index找到Node，然後替換值。改不修改modCount。
- 查本身就是根據index找到Node。
- 所以它的CRUD操作裡，都涉及到根據index去找到Node的操作。