@
准备
LinkedList是基于双向链表数据结构实现的Java集合(jdk1.8以前基于双向循环链表)，在阅读源码之前，有必要简单了解一下链表。
先了解一下链表的概念：链表是由一系列非连续的节点组成的存储结构，简单分下类的话，链表又分为单向链表和双向链表，而单向/双向链表又可以分为循环链表和非循环链表。
- 单向链表：单向链表就是通过每个结点的指针指向下一个结点从而链接起来的结构，最后一个节点的next指向null。
- 单向循环链表：单向循环链表和单向列表的不同是，最后一个节点的next不是指向null，而是指向head节点，形成一个“环”。
- 双向链表：向链表是包含两个指针的，pre指向前一个节点，next指向后一个节点，但是第一个节点head的pre指向null，最后一个节点的tail指向null。
- 双向循环链表：向循环链表和双向链表的不同在于，第一个节点的pre指向最后一个节点，最后一个节点的next指向第一个节点，也形成一个“环”。
LinkedList继承体系
通过类图可以看到，LinkedList不仅实现了List接口，而且实现了现了Queue和Deque接口，所以它既能作为List使用，也能作为双端队列使用，也可以作为栈使用。
源码分析
节点类
LinkedList有一个静态内部类，我们看到在双链表中每个节点有前趋、后继、数据域，节点类实现了这个结构。
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;
}
}
属性
看一下LinkedList的主要属性。first和last对应了双链表的头结点和尾结点。
//元素个数
transient int size = 0;
//头结点
transient Node<E> first;
//尾结点
transient Node<E> last;
构造函数
//无参
public LinkedList() {
}
//从其它集合中构造
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
获取元素
双向链表的灵活处就是链表中的一个元素结构就可以向左或者向右开始遍历查找需要的元素结构。因此对于一个有序链表，查询的效率比单链表高一些。因为，我们可以记录上次查找的位置 p，每次查询时，根据要查找的值与 p 的大小关系，决定是往前还是往后查找，所以平均只需要查找一半的数据。
链表查询示意图如下：
//根据索引获取数据
public E get(int index) {
//越界判断
checkElementIndex(index);
//根据index获取节点
return node(index).item;
}
//根据索引获取节点
Node<E> node(int index) {
// 因为是双链表
// 所以根据index是在前半段还是后半段决定从前遍历还是从后遍历
// 这样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 linkFirst(E e) {
// 首节点
final Node<E> f = first;
// 创建新节点，新节点的next是首节点
final Node<E> newNode = new Node<>(null, e, f);
first = newNode;
// 判断链表是不是为空
// 如果是就把last也置为新节点
// 否则把原首节点的prev指针置为新节点
if (f == null)
last = newNode;
else
f.prev = newNode;
//元素个数加1
size++;
// 修改次数 +1，用于 fail-fast 处理
modCount++;
}
public void addFirst(E e) {
linkFirst(e);
}
- 尾插法
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;
//元素个数加1
size++;
// 修改次数 +1，用于 fail-fast 处理
modCount++;
}
public void addLast(E e) {
linkLast(e);
}
public boolean add(E e) {
linkLast(e);
return true;
}
在链表头部和尾部插入时间复杂度都是O(1)，头插法和尾插法的示意图如下：
- 中间插入法：中间插入需要找到插入位置节点，改变该节点的前趋和该节点前趋节点的后继
//根据索引插入节点
public void add(int index, E element) {
//判断是否越界
checkPositionIndex(index);
//未插入
if (index == size)
linkLast(element);
else
//找到索引位置节点，在该节点前插入新节点
linkBefore(element, node(index));
}
// 在节点succ之前添加元素
void linkBefore(E e, Node<E> succ) {
//节点succ的前趋节点
final Node<E> pred = succ.prev;
//新节点
final Node<E> newNode = new Node<>(pred, e, succ);
//改变节点succ的前趋指向
succ.prev = newNode;
// 判断前置节点是否为空
// 如果为空，说明是第一个添加的元素，头结点重新赋值
// 否则修改前置节点的next为新节点
if (pred == null)
first = newNode;
else
pred.next = newNode;
//元素个数加1
size++;
// 修改次数 +1，用于 fail-fast 处理
modCount++;
}
在中间添加元素效率低一些，首先要先找到插入位置的节点，再修改前后节点的指针，时间复杂度为O(n)。
删除元素
双链表中删除元素只需要改变前趋和后继的指向。
- 删除头节点
//删除头节点
public E removeFirst() {
final Node<E> f = first;
//如果链表为空，抛出异常
if (f == null)
throw new NoSuchElementException();
// 删除首节点
return unlinkFirst(f);
}
// 删除头节点
private E unlinkFirst(Node<E> f) {
// 头结点
final E element = f.item;
//头结点后继节点
final Node<E> next = f.next;
//头结点数据域后继置空，帮助GC
f.item = null;
f.next = null;
//头结点置为后继节点
first = next;
// 如果只有一个元素，删除了，把last也置为空
// 否则把next的前趋置为空
if (next == null)
last = null;
else
next.prev = null;
size--;
modCount++;
//返回删除的节点
return element;
}
- 删除尾结点
//删除尾结点
public E removeLast() {
//尾结点
final Node<E> l = last;
//链表为空，抛出异常
if (l == null)
throw new NoSuchElementException();
return unlinkLast(l);
}
//删除尾结点
private E unlinkLast(Node<E> l) {
// 尾结点元素
final E element = l.item;
//尾结点前趋节点
final Node<E> prev = l.prev;
//尾结点数据、前趋置为null，帮助GC
l.item = null;
l.prev = null;
//尾结点置为前趋节点
last = prev;
// 如果只有一个元素，删除了把first置为空
// 否则把前置节点的next置为空
if (prev == null)
first = null;
else
prev.next = null;
size--;
modCount++;
//返回删除的节点
return element;
}
注意：
不管是上一节的头插入和未插入，还是这一节的删除头节点和删除尾结点，都没有在List中定义。前面提到，LinkedList实现了Deque接口，所以这是作为双向队列的LinkedList插入和删除元素的方式。还有获取头结点和尾结点的方法getFirst()和getLast()，同样都是双向队列的实现。
- 删除指定位置的节点
//删除指定位置的节点
public E remove(int index) {
//检查越界情况
checkElementIndex(index);
//根据索引找到节点，删除
return unlink(node(index));
}
//删除指定节点
E unlink(Node<E> x) {
// 删除节点的值
final E element = x.item;
//被删除节点的后继节点
final Node<E> next = x.next;
//被删除节点的前趋节点
final Node<E> prev = x.prev;
// 如果前趋节点为空
// 说明是首节点，让first指向x的后继节点
// 否则修改前置节点的next为x的后继节点
if (prev == null) {
first = next;
} else {
prev.next = next;
x.prev = null;
}
// 如果后继节点为空
// 说明是尾节点，让last指向x的前趋节点
// 否则修改后置节点的prev为x的前趋节点
if (next == null) {
last = prev;
} else {
next.prev = prev;
x.next = null;
}
// 清空x的元素值，协助GC
x.item = null;
// 元素个数减1
size--;
// 修改次数加1，fail-fast
modCount++;
//返回删除的元素
return element;
}
删除头尾节点，时间复杂度为O(1)。
在中间删除元素，首先要找到删除位置的节点，再修改前后指针，时间复杂度为O(n)。
前面还提到，LinkedList可以作为栈使用，栈的特点是先进后出，LinkedList同样有作为栈的方法实现。
push
入栈：插入头节点
public void push(E e) {
addFirst(e);
}
pop
出栈：删除头结点
public E pop() {
return removeFirst();
}
与ArrayList
LinkedList作为Java中链表的实现，ArrayList作为顺序表的实现（ArrayList源码阅读笔记），LinkedList常常被拿来和ArrayList来进行比较。
LinkedList、ArrayList基本操作时间效率对比如下(粗略对比)：
| 操作 | ArrayList | LinkedList |
|---|---|---|
| get(int index) | O(1) | O(n)，平均 n / 4步 |
| add(E element) | 最坏情况（扩容）O(n) ，平均O(1) | O(1) |
| add(int index, E element) | O(n) ,平均n / 2步 | O(n)，平均 n / 4步 |
| remove(int index) | O(n) 平均n /2步 | O(n)，平均 n / 4步 |
简而言之，需要频繁读取集合中的元素时，使用ArrayList效率较高，而在插入和删除操作较多时，使用LinkedList效率较高。
纸上得来终觉浅，绝知此事要躬行。
参考：
【1】：【死磕 Java 集合】— LinkedList源码分析
【2】：【JDK1.8】LinkedList源码分析
【3】：Java集合干货系列-（二）LinkedList源码解析
【4】：看动画轻松理解「链表」实现「LRU缓存淘汰算法」
【5】：和我一起读Java8 LinkedList源码
【6】：LinkedList Java Data Structure