準備知識
結構圖：
LinkedList.png
①LinkedList是一種雙向鏈表。
②根據雙向鏈表的特點，會有頭節點和尾節點，并且節點之間是通過前驅指針和后繼指針來維護關系的，而不是像數組那樣通過位置下標來維護節點間關系的。所以既可以從頭到尾遍歷，又可以從尾到頭遍歷。
LinkedList中Node節點類的數據結構
//E類型的Node類，作為LinkedList雙向鏈表中的節點
private static class Node<E> {
//E類型的值item
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;
}
}
屬性
// 初始化鏈表的長度為0
transient int size = 0;
說明：雙向鏈表的長度
//指向頭節點的變量first
transient Node<E> first;
說明：雙向鏈表的頭節點
//指向尾節點的變量last
transient Node<E> last;
說明：雙向鏈表的尾節點
構造方法
構造方法1：構造一個空的LinkedList鏈表結構
public LinkedList() { }
構造方法2：構造一個包含指定元素的collection集合中元素的LinkedList
public LinkedList(Collection<? extends E> c) {
this();
//使用addAll方法，實際上就是使用遍歷c并且采用頭插法進行雙向鏈表插入值。
addAll(c);
}
方法
addAll方法將指定集合中的所有元素從指定位置開始插入此列表：
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}
追加指定 collection 中的所有元素到此列表的結尾，順序是指定 collection 的迭代器返回這些元素的順序。
public boolean addAll(int index, Collection<? extends E> c) {
//判斷下標元素是否在鏈表的長度范圍之內
checkPositionIndex(index);
//將集合c轉換成Object數組
Object[] a = c.toArray();
int numNew = a.length;
//如果Object數組長度為0，那么就返回添加失敗
if (numNew == 0)
return false;
//pred節點為succ節點的前驅
Node<E> pred, succ;
//如果下標等于鏈表的長度時，pred為尾節點，succ指向為空
if (index == size) {
succ = null;
pred = last;
} else {
/* 如果下標不等于鏈表長度，node方法就是用來通過下標索引獲
* 取鏈表中的對應的節點對象。
*/
succ = node(index);
pred = succ.prev;
}
for (Object o : a) {
@SuppressWarnings("unchecked")
E e = (E) o;
//將遍歷的值包裝成節點Node，初始化前驅節點為pred，后繼節點為null
Node<E> newNode = new Node<>(pred, e, null);
//如果前驅節點為空，那么肯定是頭節點
if (pred == null)
first = newNode;
else
//否則不是頭節點，那么前驅的后繼節點為當前節點，其實就是類似于鏈表的插入節點操作。
pred.next = newNode;
pred = newNode;
}
/*
* 因為pred節點是succ節點的前驅節點，反之succ是pred的后繼節點.
* 如果succ為空，說明pred為尾節點。
*/
if (succ == null) {
last = pred;
} else {
/* 如果succ不是尾節點，那么只要保證pred節點是succ節點的前驅
* 節點、succ是pred的后繼節點這種雙向鏈表的關系
*/
pred.next = succ;
succ.prev = pred;
}
size += numNew;
modCount++;
return true;
}
add(E e)方法：將元素插入到鏈表的尾部
//采用雙向鏈表的尾插法
public boolean add(E e) {
linkLast(e);
return true;
}
void linkLast(E e) {
//創建臨時節點l初始化為尾節點（那么其后繼節點為null，前驅節點不為空）。
final Node<E> l = last;
//初始化新節點，前驅節點為l，后繼暫為null
final Node<E> newNode = new Node<>(l, e, null);
//由于是在鏈表尾部插入節點，那么新節點就作為尾節點。
last = newNode;
/**
* l節點作為newNode節點的前驅節點。
* 如果l為空，那么newNode前驅節點為空。
* 在雙向鏈表中，前驅節點為空，那么該節點為頭節點。
*/
if (l == null)
first = newNode;
else
l.next = newNode;
size++;//再插入節點后，鏈表的長度加1
modCount++;
}
說明：如果尾節點為空，那么將新節點作為頭節點；否則新節點插入到尾節點后面。
add(int index, E element)方法：在鏈表指定的位置插入元素
public void add(int index, E element) {
//先檢查索引是否在鏈表的范圍內。
checkPositionIndex(index);
if (index == size)
//如果索引等于鏈表長度，那么直接采用尾插法的linkLast方法。
linkLast(element);
else
linkBefore(element, node(index));
}
/**
* 在節點succ作為通過下標索引在鏈表中查詢出來的對應的節點。
* e值包裝的節點插入到succ節點之前。
*/
void linkBefore(E e, Node<E> succ) {
//succ節點的前驅為pred
final Node<E> pred = succ.prev;
//初始化新節點前驅為pred，后繼為succ，意思就是想在pred和succ節點之間插入newNode節點
final Node<E> newNode = new Node<>(pred, e, succ);
//到這步，newNode已經確立了，后繼節點為succ。succ節點的前驅為newNode。
succ.prev = newNode;
//如果pred為空，那么newNode的前驅節點為空，可以確定newNode為頭節點。
if (pred == null)
first = newNode;
else
/* 如果pred不為空，則確定了pred節點后繼為newNode，之前已經確
* 定newNode的前驅為pred，這樣pred和newNode就確立關系了。
*/
pred.next = newNode;
size++;//新增節點，長度更新為原來長度加1
modCount++;
}
說明：將元素插入指定位置，首先通過位置獲取當前對應的定位節點。如果下標對應的定位節點就是尾節點，那么直接使用linkLast方法在鏈表尾部插入節點。如果對應的定位節點不是尾節點，就插入到定位節點的前面。
addFirst方法：將指定元素插入到鏈表的頭部
/**
* 將指定元素插入到鏈表的頭部
*/
public void addFirst(E e) {
linkFirst(e);
}
/**
* 將e作為頭結點，采用雙向鏈表的頭插法
*/
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++;
}
說明：如果雙向鏈表為空，那么插入節點作為頭節點，如果雙向鏈表不為空，那么插入節點作為頭結點的前驅節點。
addLast方法：插入元素到鏈表的尾部
/**
* 將指定元素插入到鏈表的尾部
*/
public void addLast(E e) {
linkLast(e);
}
//采用雙向鏈表尾插法的方式插入元素
void linkLast(E e) {
//創建臨時節點l初始化為尾節點（那么其后繼節點為null，前驅節點不為空）。
final Node<E> l = last;
//初始化新節點，前驅節點為l，后繼暫為null
final Node<E> newNode = new Node<>(l, e, null);
//由于是在鏈表尾部插入節點，那么新節點就作為尾節點。
last = newNode;
/**
* l節點作為newNode節點的前驅節點。
* 如果l為空，那么newNode前驅節點為空。
* 在雙向鏈表中，前驅節點為空，那么該節點為頭節點。
*/
if (l == null)
first = newNode;
else
l.next = newNode;
size++;//再插入節點后，鏈表的長度加1
modCount++;
}
說明：如果雙向鏈表為空，那么直接新節點作為頭節點。如果雙向鏈表不為空，那么在尾節點后面插入新節點。
remove(Object o)方法：刪除雙向鏈表中首次出現的元素
/**
* 列表中移除首次出現的元素
*/
public boolean remove(Object o) {
/* 通過雙向鏈表的前后關系，遍歷雙向鏈表。
* 判斷是否存在元素和要刪除的元素相同。
* 如果遍歷到了，那么就刪除元素，并且返回true
* 如果沒遍歷到，那么就返回false
*/
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;
}
/**
* 刪除非空節點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 {
/* 如果前驅不為空，那么就直接采用雙向鏈表刪除節點的套路，
* 此處是解決前驅節點和刪除節點的鏈接關系
* 直接將前驅節點的后繼關系指向后繼結點，就解決了前驅節點的后繼關系
* 將刪除節點x的前驅設置為空，就解決了刪除節點的前驅關系
*/
prev.next = next;
x.prev = null;
}
//如果后繼結點為空，說明當前刪除的節點為尾節點，那么就讓其前驅節點作為尾節點
if (next == null) {
last = prev;
} else {
/* 如果后繼不為空，那么就直接采用雙向鏈表刪除節點的套路，
* 此處是解決刪除節點和后繼結點的鏈接關系
* 直接將后繼節點的前驅關系指向前驅節點，就解決了后繼結點的前驅關系
* 將刪除節點x的后繼設置為空，就解決了刪除節點的后繼關系
*/
next.prev = prev;
x.next = null;
}
//如果上面雙向鏈表刪除關系不清楚可以自己畫圖看看就明白了
//將刪除節點的值設置為空，便于gc
x.item = null;
size--;
modCount++;
return element;
}
說明：從頭結點遍歷鏈表，找到第一次出現的節點；
如果定位節點的前驅為空，那么說明定位節點為頭節點，將頭結點的后繼節點設置為頭節點。如果定位節點的前驅節點不為空，那么將定位節點的后繼節點設置為定位節點前驅節點的后繼節點。
如果定位節點的后繼節點為空，那么將尾節點設置為null。
如果定位節點的后繼節點不為空，那么將定位節點的后繼節點的前驅節點設置定位節點的前驅節點。
get方法：獲取雙向鏈表中指定下標的節點值。
public E get(int index) {
// 校驗下標不超出范圍
checkElementIndex(index);
// 通過下標獲取節點，返回節點的值
return node(index).item;
}
// 通過下標獲取節點
Node<E> node(int index) {
// 判斷下標索引是更靠近頭節點還是尾節點
if (index < (size >> 1)) {
// 獲取頭節點
Node<E> x = first;
// 循環遍歷找到index的節點
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
// 獲取尾節點
Node<E> x = last;
// 循環遍歷找到index的節點
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
說明：首先判斷下標更靠近頭節點還是尾節點，減少遍歷的次數。
如果靠近頭節點，那么就從頭節點向后遍歷到指定的下標索引節點。
如果靠近尾節點，那么就從尾節點向前遍歷到指定的下標索引節點。
總結
1. LinkedList采用一種雙向鏈表實現。
2. LinkedList添加的元素，取時與添加時的順序一致。因為向雙向鏈表的尾部添加元素，然后按照頭節點順序遍歷獲取，所以一致。
3. LinkedList允許添加重復元素。
4. LinkedList不是線程安全的集合。
5. LinkedList允許添加null元素。
6. add方法插入元素是在雙向鏈表的尾部插入。
7. get方法遍歷雙向鏈表，先判斷下標靠近頭節點還是尾節點，這樣會減少多余的循環。
