一、概述
LinkedList是 Java 集合框架中一个重要的实现，其底层采用的双向链表结构。和 ArrayList 一样，LinkedList 也支持空值和重复值。由于 LinkedList 基于链表实现，存储元素过程中，无需像 ArrayList 那样进行扩容。
但有得必有失，一方面，LinkedList 存储元素的节点需要额外的空间存储前驱和后继的引用。另一方面，LinkedList 在链表头部和尾部插入效率比较高，但在指定位置进行插入时，效率一般。原因是，在指定位置插入需要定位到该位置处的节点，此操作的时间复杂度为O(N)。
最后，LinkedList 是非线程安全的集合类，并发环境下，多个线程同时操作 LinkedList，会引发不可预知的错误。
二、继承体系
LinkedList 的继承体系较为复杂，继承自 AbstractSequentialList，同时又实现了 List 和 Deque 接口
LinkedList 继承自 AbstractSequentialList，AbstractSequentialList 又是什么呢？从实现上，AbstractSequentialList 提供了一套基于顺序访问的接口。通过继承此类，子类仅需实现部分代码即可拥有完整的一套访问某种序列表（比如链表）的接口。深入源码，AbstractSequentialList 提供的方法基本上都是通过 ListIterator 实现的，比如：
public abstract class AbstractSequentialList<E> extends AbstractList<E> {
public E get(int index) {
try {
return listIterator(index).next();
} catch (NoSuchElementException exc) {
throw new IndexOutOfBoundsException("Index: "+index);
}
}
public void add(int index, E element) {
try {
listIterator(index).add(element);
} catch (NoSuchElementException exc) {
throw new IndexOutOfBoundsException("Index: "+index);
}
}
//留给子类实现
public abstract ListIterator<E> listIterator(int index);
}
所以只要继承类实现了 listIterator 方法，它不需要再额外实现什么即可使用。对于随机访问集合类一般建议继承 AbstractList 而不是 AbstractSequentialList。LinkedList 和其父类一样，也是基于顺序访问。所以 LinkedList 继承了 AbstractSequentialList，但 LinkedList 并没有直接使用父类的方法，而是重新实现了一套的方法。
另外，LinkedList 还实现了 Deque (double ended queue)，Deque 又继承自 Queue 接口。这样 LinkedList 就具备了队列的功能。比如，我们可以这样使用：
Queue<T> queue = new LinkedList<>();除此之外，我们基于 LinkedList 还可以实现一些其他的数据结构，比如栈，以此来替换 Java 集合框架中的 Stack 类。
三、源码分析
1、成员属性
// 元素个数
transient int size = 0;
// 链表头节点
transient Node<E> first;
// 链表尾节点
transient Node<E> last;
2、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;
}
}3、构造器
构造一个空列表，里面没有任何实现，只是进行了初始化操作。
public LinkedList() {
}构造一个包含指定 collection 中的元素的列表，这些元素按其 collection 的迭代器返回的顺序排列。
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}4、增加元素
1）增加头节点
public void addFirst(E e) {
//内部调用linkFirst方法
linkFirst(e);
}
private void linkFirst(E e) {
//创建一个节点引用l，指向原头节点
final Node<E> f = first;
//创建新节点，前驱为null，后继为当前头节点
final Node<E> newNode = new Node<>(null, e, f);
//新的要插入的节点作为新的头节点
first = newNode;
//判断原头节点是否为null，即原集合有没有节点数据
if (f == null)
//判断原头节点是否为null，即原集合有没有节点数据
last = newNode;
else
//如果原头节点不为null，即原集合有节点数据，那么将原来头节点的prev引用指向新的头节点
f.prev = newNode;
//节点数自增1
size++;
//结构改变的次数自增1
modCount++;
}其他添加到尾部的方法，原理都是一样的：
public boolean offerFirst(E e) {
addFirst(e);
return true;
}
public void push(E e) {
addFirst(e);
}2）增加尾节点
public boolean add(E e) {
//内部调用linkLast方法
linkLast(e);
return true;
}
//将元素链接到链表尾部
void linkLast(E e) {
//创建一个节点引用l，指向原尾节点
final Node<E> l = last;
//创建新节点，前驱为当前尾节点，后继为null
final Node<E> newNode = new Node<>(l, e, null);
//新的要插入的节点作为新的尾节点
last = newNode;
//判断原尾节点是否为null，即原集合有没有节点数据
if (l == null)
//如果原尾节点为null，即原集合没有节点数据，那么将新节点同时也作为首节点
first = newNode;
else
//如果原尾节点不为null，即原集合有节点数据，那么将原来尾节点的next引用指向新的尾节点
l.next = newNode;
//节点数自增1
size++;
//结构改变的次数自增1
modCount++;
}其他添加到尾部的方法，原理都是一样的：
public void addLast(E e) {
linkLast(e);
}
public boolean offer(E e) {
return add(e);
}
public boolean offerLast(E e) {
addLast(e);
return true;
}
3）指定位置添加
//在index前插入节点
public void add(int index, E element) {
//检查索引是否处于[0-size]之间
checkPositionIndex(index);
//判断索引index是否等于size
if (index == size)
//如果索引index等于size，那实际上就是添加在链表尾部
linkLast(element);
else
//如果不等，调用linkBefore方法
linkBefore(element, node(index));
}
//检查索引的方法
private void checkPositionIndex(int index) {
if (!isPositionIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
//索引是否大于等于0，且小于等于size
private boolean isPositionIndex(int index) {
return index >= 0 && index <= size;
} //在 指定节点 前插入一个元素，这里 指定节点对象不为 null
void linkBefore(E e, Node<E> succ) {
// 获取指定节点 succ 前面的一个节点
final Node<E> pred = succ.prev;
// 创建新节点，头部指向 succ 前面的节点，尾部指向 succ 节点，
final Node<E> newNode = new Node<>(pred, e, succ);
//让 succ 节点头部指向 新建的节点
succ.prev = newNode;
//如果 succ 前面的节点为空，说明 succ 就是第一个节点，新建的节点就变成第一个节点了
if (pred == null)
first = newNode;
else
//如果前面有节点，让前面的节点的下一个节点指向新节的点
pred.next = newNode;
//节点数自增1
size++;
//结构改变的次数自增1
modCount++;
}
//获取对应索引处的Node节点
Node<E> node(int index) {
//判断索引是否小于节点数量的一半，size >> 1是位运算，就是size/2的意思
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;
}
}从node节点查找的实现可以看出来，这里的索引的查找，是从头或者尾开始循环遍历查找，时间复杂度为O(n)，因此效率相对于ArrayLsit的O(1)的查找时间复杂度来说，效率比较低。
4）批量增加
//在index前批量插入节点
public boolean addAll(int index, Collection<? extends E> c) {
//检查索引是否处于[0-size]之间
checkPositionIndex(index);
//将集合转换为数组
Object[] a = c.toArray();
int numNew = a.length;
if (numNew == 0)
return false;
// 记录 index 处节点及其前驱
// 相当于原链表在 pred 处断开了
Node<E> pred, succ;
//如果索引index等于size，那实际上就是添加在链表尾部
if (index == size) {
succ = null;
pred = last;
} else {
succ = node(index);
pred = succ.prev;
}
// 在该节点前驱 pred 后链式增加集合里的元素
for (Object o : a) {
@SuppressWarnings("unchecked") E e = (E) o;
Node<E> newNode = new Node<>(pred, e, null);
if (pred == null)
first = newNode;
else
pred.next = newNode;
pred = newNode;
}
// 把两条链表合在一起
// succ 为空，设置 last 即可
if (succ == null) {
//尾节点为pred
last = pred;
} else {
// succ 不为空，进行两条链表的链接
pred.next = succ;
succ.prev = pred;
}
//节点数增加numNew
size += numNew;
//结构改变的次数自增1
modCount++;
return true;
}5、删除元素
1）删除头节点
//获取并移除此列表的头（第一个元素）。如果列表为null，则抛出NoSuchElementException异常。
public E remove() {
return removeFirst();
}
//获取并移除此列表的头（第一个元素）。如果列表为null，则抛出NoSuchElementException异常。
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;
// 相应数据item设为 null, next指向null, 从而之后GC清理
f.item = null;
f.next = null;
//使头节点引用指向下一个节点
first = next;
//如果下一个节点为null，即只有一个元素，此时集合为空
if (next == null)
//那么尾节点的引用也置null
last = null;
else
//下一个节点不为null，将下一个节点作为头节点，并将下一个节点的prev引用置null
next.prev = null;
//节点数自减1
size--;
//结构改变的次数自增1
modCount++;
return element;
}其他移除头结点的方法，原理都是一样的：
public E pollFirst() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
public E pop() {
return removeFirst();
}2）删除尾节点
//获取并移除此列表的尾（最后一个元素）。如果列表为null，则抛出NoSuchElementException异常。
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;
// 相应数据item设为 null, prev指向null, 从而之后GC清理
l.item = null;
l.prev = null;
last = prev;
//如果上一个节点为null，即只有一个元素，此时集合为空
if (prev == null)
//那么头节点的引用也置null
first = null;
else
//上一个节点不为null，将上一个节点作为尾节点，并将上一个节点的next引用置null
prev.next = null;
//节点数自减1
size--;
//结构改变的次数自增1
modCount++;
return element;
}其他移除头结点的方法，原理都是一样的：
public E pollLast() {
final Node<E> l = last;
return (l == null) ? null : unlinkLast(l);
}
3）指定位置移除
public E remove(int index) {
//索引检查
checkElementIndex(index);
//注意这里和指定位置添加元素时检查的索引范围不一样，删除是[0,size),添加是[0,size]
return unlink(node(index));
}
//取消链接非空节点 x
E unlink(Node<E> x) {
// 获取该节点的值
final E element = x.item;
//创建节点引用next，指向该节点的下一个节点
final Node<E> next = x.next;
//创建节点引用prev，指向该节点的上一个节点
final Node<E> prev = x.prev;
//判断该节点是否存在上一个节点
if (prev == null) {
//不存在上一个节点，则该节点为首节点，则让首节点引用指向该节点的下一个节点
first = next;
} else {
//存在上一个节点，则上一个节点的下一个节点引用指向该节点的下一个节点
prev.next = next;
//该节点的上一个节点的引用指向null
x.prev = null;
}
//判断该节点是否存在下一个节点
if (next == null) {
//不存在下一个节点，则该节点为尾节点.则让尾节点引用指向该节点的上一个节点
last = prev;
} else {
//存在下一个节点，则下一个节点的上一个节点引用指向该节点的上一个节点
next.prev = prev;
//该节点的下一个节点的引用指向null
x.next = null;
}
//该节点的值置空.此时没有任何引用指向该node节点对象,该对象将会被垃圾回器回收
x.item = null;
//节点数自减1
size--;
//结构改变的次数自增1
modCount++;
return element;
}4）删除指定数据
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;
}
6、获取
1）获取头节点的方法
//返回此列表的第一个元素。如果此列表为空，则抛出NoSuchElementException异常。
public E getFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return f.item;
}
//获取但不移除此列表的头（第一个元素）。如果此列表为空，则返回null。
public E peek() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
//获取但不移除此列表的头（第一个元素）。如果此列表为空，则抛出NoSuchElementException异常。
public E element() {
return getFirst();
}
//获取但不移除此列表的第一个元素；如果此列表为空，则返回null。
public E peekFirst() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}2）获取尾节点的方法
//返回此列表的最后一个元素。如果此列表为空，则抛出NoSuchElementException异常。
public E getLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return l.item;
}
//获取但不移除此列表的最后一个元素；如果此列表为空，则返回 null。
public E peekLast() {
final Node<E> l = last;
return (l == null) ? null : l.item;
}3）指定位置获取
public E get(int index) {
//索引检查
checkElementIndex(index);
return node(index).item;
}
7、contains和indexOf
//如果此列表包含指定元素，则返回 true。
public boolean contains(Object o) {
return indexOf(o) != -1;
}
//返回此列表中首次出现的指定元素的索引，如果此列表中不包含该元素，则返回 -1。
public int indexOf(Object o) {
int index = 0;
// o 为 null，直接比引用
if (o == null) {
for (Node<E> x = first; x != null; x = x.next) {
if (x.item == null)
return index;
index++;
}
// 否则，调用 equals
} else {
for (Node<E> x = first; x != null; x = x.next) {
if (o.equals(x.item))
return index;
index++;
}
}
return -1;
}
//从后往前找
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;
}8、克隆方法
和大多数集合类一样，LinkedList的克隆方法并不会对数据进行克隆，算是浅克隆。
public Object clone() {
LinkedList<E> clone = superClone();
//清空克隆对象的内部变量引用值
clone.first = clone.last = null;
clone.size = 0;
clone.modCount = 0;
/*
重新赋值
深克隆Node，这时新旧对象的Node是不一样了，但是对应索引的Node中的Item却还是浅克隆，
指向了同一个对象，改变对象的值会对两个链表都产生影响！
但是如果储存的是直接量则不会影响！
*/
for (Node<E> x = first; x != null; x = x.next)
clone.add(x.item);
return clone;
}
private LinkedList<E> superClone() {
try {
//Object的clone方法
return (LinkedList<E>) super.clone();
} catch (CloneNotSupportedException e) {
throw new InternalError(e);
}
}9、clear方法
public void clear() {
//手动清理全部链表节点之间的引用关系,帮助GC
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
size = 0;
//结构改变的次数自增1
modCount++;
}10、迭代器
1）迭代器的结构
private class ListItr implements ListIterator<E> {
// 最后被返回的节点的
private Node<E> lastReturned;
// 下一个被返回的节点
private Node<E> next;
// 下一个被返回的节点的索引
private int nextIndex;
// 用于检测并发修改异常
private int expectedModCount = modCount;
ListItr(int index) {
//根据index设置下一个要被返回的节点
next = (index == size) ? null : node(index);
//根据index设置下一个要被返回的节点的索引
nextIndex = index;
}
}2）checkForComodification函数
判断是否存在并发修改异常
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}3）next 函数
用于正序遍历
public E next() {
//检测并发修改异常
checkForComodification();
//检测是否还存在可以获取的节点
if (!hasNext())
throw new NoSuchElementException();
//设置 next,nextIndex 和 lastReturned 的值
lastReturned = next;
next = next.next;
nextIndex++;
return lastReturned.item;
}
//是否具有下一个节点
public boolean hasNext() {
return nextIndex < size;
}
4）previous函数
用于倒序遍历
public E previous() {
checkForComodification();
if (!hasPrevious())
throw new NoSuchElementException();
//注意这里，next和lastReturned设置的是一个值
//在remove方法里会有应用
lastReturned = next = (next == null) ? last : next.prev;
nextIndex--;
return lastReturned.item;
}
public boolean hasPrevious() {
return nextIndex > 0;
}
4）调用原 LinkedList 的增删函数
public void add(E e) {
//检测并发修改异常
checkForComodification();
lastReturned = null;
if (next == null)
//尾部添加
linkLast(e);
else
//next前面添加
linkBefore(e, next);
nextIndex++;
expectedModCount++;
}注意源码中倒序遍历与正序遍历的区别
public void remove() {
//检测并发修改异常
checkForComodification();
//检测最后被返回的节点是否为null，当创建了迭代器对象直接使用该方法时，lastReturned就指向null
//因此不能先于next()方法使用，也不能连续使用remove()方法
if (lastReturned == null)
throw new IllegalStateException();
//获取最后被返回的节点的下一个节点
Node<E> lastNext = lastReturned.next;
//移除lastReturned节点和链表之间的引用关系，后续的节点链接到原节点的位置
unlink(lastReturned);
//这里说明一下，如果是倒序遍历，那么就会返回true，正序遍历就会返回false，
if (next == lastReturned)
next = lastNext;
else
nextIndex--;
lastReturned = null;
//调用原 LinkedList 的增删函数，会导致modCount++，所以这里要更新对应的expectedModCount
expectedModCount++;
}5）forEachRemaining函数
对 next 以及之后的节点的 item 属性调用action.accept(next.item);进行操作
public void forEachRemaining(Consumer<? super E> action) {
//判断action是否为null
Objects.requireNonNull(action);
while (modCount == expectedModCount && nextIndex < size) {
action.accept(next.item);
lastReturned = next;
next = next.next;
nextIndex++;
}
//检测并发修改异常
checkForComodification();
}
public static <T> T requireNonNull(T obj) {
if (obj == null)
throw new NullPointerException();
return obj;
}四、总结
总体来看 LinkedList 的源码并不复杂，基本都是双向链表的基本操作，大家感兴趣的可以看一下。
参考文章：LinkedList源码深度解析以及迭代器机制【一万字】_刘Java的博客-CSDN博客_linkedlist迭代器
377
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
