一、概述
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迭代器