LinkedList源码解析
一、概述
LinkedList同时实现了List接口和Deque接口,也就是说它既可以看作一个顺序容器,又可以看作一个队列(Queue),同时又可以看作一个栈(Stack)。这样看来,LinkedList简直就是个全能冠军。当你需要使用栈或者队列时,可以考虑使用LinkedList,一方面是因为Java官方已经声明不建议使用Stack类,更遗憾的是,Java里根本没有一个叫做Queue的类(它是个接口名字)。关于栈或队列,现在的首选是ArrayDeque,它有着比LinkedList(当作栈或队列使用时)有着更好的性能。
LinkedList的实现方式决定了所有跟下标相关的操作都是线性时间,而在首段或者末尾删除元素只需要常数时间。为追求效率LinkedList没有实现同步(synchronized),如果需要多个线程并发访问,可以先采用Collections.synchronizedList()方法对其进行包装。
二、源码解读
LinkedLists实现
底层数据结构
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;
}
}
继承和实现的接口
// 实现Deque 和List 做队列也可以做栈,双端队列,实现Cloneable, java.io.Serializable,可以进行浅拷贝和进行序列化
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
基本属性
// 结点个数 transient代表不进行序列化
transient int size = 0;
// 头节点 transient代表不进行序列化
transient Node<E> first;
// 尾节点 transient代表不进行序列化
transient Node<E> last;
构造函数
// 空参构造
public LinkedList() {
}
// 有参构造,通过集合添加
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
添加元素
头部添加
// 从头部添加结点
public void addFirst(E e) {
linkFirst(e);
}
// 添加元素到头节点
public boolean offerFirst(E e) {
// 添加元素到头节点
addFirst(e);
return true;
}
// 添加元素,并从头节点开始添加
public void push(E e) {
addFirst(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++;
}
尾部添加
// 从尾部添加结点
public void addLast(E e) {
linkLast(e);
}
// 添加结点,默认为从尾部添加
public boolean add(E e) {
linkLast(e);
return true;
}
// 在尾部添加集合里的全部元素
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}
// 将元素添加到尾部
public boolean offer(E e) {
// 元素添加到尾部
return add(e);
}
// 添加元素到尾节点
public boolean offerLast(E e) {
// 添加元素到尾节点
addLast(e);
return true;
}
// 添加到尾节点
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
// 如果不是,则之前的尾结点的next结点为新结点
l.next = newNode;
// 结点累加
size++;
// 操作数累加,支持快速失败
modCount++;
}
指定位置添加
// 从指定位置添加集合的全部元素到链表
public boolean addAll(int index, Collection<? extends E> c) {
// 检查索引,是否越界
checkPositionIndex(index);
// 将集合转换为数组
Object[] a = c.toArray();
// 数组长度
int numNew = a.length;
// 为0,则没有元素需要添加
if (numNew == 0)
return false;
Node<E> pred, succ;
// 如果位置等于size,则添加到尾部
if (index == size) {
// 索引succ为null
succ = null;
// 前驱结点为尾结点
pred = last;
} else {
// 获取指定索引的结点
succ = node(index);
// 指定结点的前驱结点
pred = succ.prev;
}
// 遍历添加结点
for (Object o : a) {
// 检查类型
@SuppressWarnings("unchecked") E e = (E) o;
// 新建结点,设置前驱结点为指定索引的前驱结点,next结点暂时为null
Node<E> newNode = new Node<>(pred, e, null);
// 如果前驱结点为null ,则代表为添加到头部
if (pred == null)
//头节点设置为新结点
first = newNode;
else
// 否则设置当前结点的前驱结点的next结点为新结点
pred.next = newNode;
// 前驱结点更新为新添加的结点,为添加下一个结点做准备
pred = newNode;
}
// 代表当前索引指向尾节点
if (succ == null) {
// 设置尾节点为当前的前驱结点
last = pred;
} else {
// 否则将添加完的链表的next结点设置为之前的succ结点
pred.next = succ;
// succ结点的前驱结点设置为添加完元素的新发prev
succ.prev = pred;
}
//结点数量增加
size += numNew;
// 操作数累加,支持快速失败
modCount++;
return true;
}
// 添加元素到指定的索引
public void add(int index, E element) {
//检查索引是否越界
checkPositionIndex(index);
// 如果索引等于size,等于添加到尾部
if (index == size)
linkLast(element);
else
// 添加到指定位置
linkBefore(element, node(index));
}
// 添加到非空succ结点之前
void linkBefore(E e, Node<E> succ) {
// assert succ != null;
// succ的前驱结点
final Node<E> pred = succ.prev;
// 新建一个结点,前驱结点为succ的前驱结点,next结点为succ
final Node<E> newNode = new Node<>(pred, e, succ);
// 涉嫌succ的前驱结点为新结点
succ.prev = newNode;
// 如果succ前驱结点为null,则succ是首结点
if (pred == null)
// 设置首结点为新结点
first = newNode;
else
// 如果不是,设置succ的前驱结点的next结点为新结点
pred.next = newNode;
// 结点累加
size++;
// 操作数累加,支持快速失败
modCount++;
}
// 返回指定索引的非空结点
Node<E> node(int index) {
// assert isElementIndex(index);
// 如果索引小于size的一半,则从头结点开始遍历寻找
if (index < (size >> 1)) {
// 获取头节点
Node<E> x = first;
for (int i = 0; i < index; i++)
// 拿到结点
x = x.next;
return x;
} else {
// 如果索引大于size的一半,则从尾结点开始倒序遍历寻找
// 获取尾节点
Node<E> x = last;
for (int i = size - 1; i > index; i--)
// 拿到结点
x = x.prev;
return x;
}
}
删除元素
删除元素 - 指的是删除第一次出现的这个元素, 如果没有这个元素,则返回false;判断的依据是equals方法, 如果equals,则直接unlink这个node;由于LinkedList可存放null元素,故也可以删除第一次出现null的元素;
头部删除
private E unlinkFirst(Node<E> f) {
// assert f == first && f != null;
// 首结点的值
final E element = f.item;
// 首结点的next结点
final Node<E> next = f.next;
// 设置为null 帮助gc回收
f.item = null;
// 设置为null 帮助gc回收
f.next = null; // help GC
// 头结点设置为next
first = next;
// 如果next == null 代表只有一个结点
if (next == null)
// 所以尾节点也设置为null
last = null;
else
// 否则next结点的前驱结点为null
next.prev = null;
// 结点减少
size--;
// 操作数累加,支持快速失败
modCount++;
// 返回删除头节点的值
return element;
}
// 删除头节点
public E removeFirst() {
// 获取头节点
final Node<E> f = first;
// 如果为null 抛出异常
if (f == null)
throw new NoSuchElementException();
// 调用删除头节点的方法
return unlinkFirst(f);
}
// 删除并返回头节点的值
public E remove() {
return removeFirst();
}
//返回头节点的值,并删除
public E poll() {
// 获取头结点
final Node<E> f = first;
// 删除并返回头节点的值
return (f == null) ? null : unlinkFirst(f);
}
//删除并返回头节点的值
public E pollFirst() {
// 获取头节点
final Node<E> f = first;
//判断是否为空,不为空删除并返回值
return (f == null) ? null : unlinkFirst(f);
}
// 删除元素并返回元素值,从头结点开始删除
public E pop() {
return removeFirst();
}
尾部删除
// 删除尾节点
private E unlinkLast(Node<E> l) {
// assert l == last && l != null;
// 尾节点的值
final E element = l.item;
// 尾结点的前驱结点
final Node<E> prev = l.prev;
// 设置为null 帮助gc回收
l.item = null;
// 设置为null 帮助gc回收
l.prev = null; // help GC
// 设置尾结点为为尾节点的前驱结点
last = prev;
// 如果前驱结点为null,说明只有一个结点
if (prev == null)
// 所以设置首结点为null
first = null;
else
// 否则设置前驱结点的next结点为null
prev.next = null;
// 结点减少
size--;
// 操作数累加,支持快速失败
modCount++;
// 返回删除尾节点的值
return element;
}
// 删除尾结点
public E removeLast() {
// 获取尾结点
final Node<E> l = last;
// 如果为null 抛出异常
if (l == null)
throw new NoSuchElementException();
// 调用删除尾节点的方法
return unlinkLast(l);
}
//删除并返回尾节点的值
public E pollLast() {
// 获取尾节点
final Node<E> l = last;
//判断是否为空,不为空删除并返回值
return (l == null) ? null : unlinkLast(l);
}
指定位置删除
// 删除指定结点
E unlink(Node<E> x) {
// assert x != null;
// x结点的值
final E element = x.item;
// x结点的next结点
final Node<E> next = x.next;
// x结点的prev结点
final Node<E> prev = x.prev;
// 如果前驱结点为null ,则表示为首结点
if (prev == null) {
// 设置next结点为首结点
first = next;
} else {
// 设置前驱结点的next结点为x结点的next结点
prev.next = next;
// x 的前驱结点设置为null
x.prev = null;
}
// 如果next结点为null,代表为尾结点
if (next == null) {
// 设置新的尾结点为前驱结点
last = prev;
} else {
// 否则设置next的前驱结点为prev
next.prev = prev;
// 设置x的next结点为null
x.next = null;
}
// 设置x结点的值为null
x.item = null;
// 结点减少
size--;
// 操作数累加,支持快速失败
modCount++;
// 返回删除节点的值
return element;
}
// 删除指定的结点
public boolean remove(Object o) {
// 如果为null
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;
}
// 删除指定索引的值
public E remove(int index) {
//检查索引是否越界
checkElementIndex(index);
// 删除指定结点
return unlink(node(index));
}
// 删除第一次出现的指定结点
public boolean removeFirstOccurrence(Object o) {
return remove(o);
}
// 删除最后一次出现的指定结点
public boolean removeLastOccurrence(Object o) {
// 如果为null
if (o == null) {
// 从尾结点开始寻找
for (Node<E> x = last; x != null; x = x.prev) {
// 找到
if (x.item == null) {
// 删除
unlink(x);
return true;
}
}
} else {
// 从尾结点开始寻找
for (Node<E> x = last; x != null; x = x.prev) {
// 找到
if (o.equals(x.item)) {
// 删除
unlink(x);
return true;
}
}
}
return false;
}
检查索引和反馈信息
// 检查元素索引是否越界
private boolean isElementIndex(int index) {
return index >= 0 && index < size;
}
// 检查位置索引是否越界
private boolean isPositionIndex(int index) {
return index >= 0 && index <= size;
}
// 越界信息
private String outOfBoundsMsg(int index) {
return "Index: "+index+", Size: "+size;
}
// 检查元素的索引是否越界
private void checkElementIndex(int index) {
if (!isElementIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
// 检查位置索引是否越界
private void checkPositionIndex(int index) {
if (!isPositionIndex(index))
throw new IndexOutOfBoundsException(outOfBoundsMsg(index));
}
寻找元素索引
// 返回元素所在的索引
public int indexOf(Object o) {
int index = 0;
// 如果为null
if (o == 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;
}
// 返回指定元素最后一次出现的索引
public int lastIndexOf(Object o) {
// 从后往前
int index = size;
// 如果为null
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;
}
获取元素的值
// 获取头节点的值
public E getFirst() {
// 获取头节点
final Node<E> f = first;
// 如果为null 抛出异常
if (f == null)
throw new NoSuchElementException();
// 返回头结点的值
return f.item;
}
// 获取尾结点的值
public E getLast() {
// 获取尾结点
final Node<E> l = last;
// 如果为null 抛出异常
if (l == null)
throw new NoSuchElementException();
// 返回尾结点的值
return l.item;
}
// 根据指定的索引获取值
public E get(int index) {
//检查索引是否越界
checkElementIndex(index);
// 返回指定索引的值
return node(index).item;
}
// 返回头节点的值
public E peek() {
// 获取头结点
final Node<E> f = first;
//判断是否为空,不为空返回值
return (f == null) ? null : f.item;
}
//返回头节点的值
public E element() {
return getFirst();
}
//返回头节点的值,并删除
public E poll() {
// 获取头结点
final Node<E> f = first;
// 删除并返回头节点的值
return (f == null) ? null : unlinkFirst(f);
}
// 删除并返回头节点的值
public E remove() {
return removeFirst();
}
// 返回头节点的值
public E peekFirst() {
// 获取头节点
final Node<E> f = first;
//判断是否为空,不为空返回值
return (f == null) ? null : f.item;
}
// 返回尾结点的值
public E peekLast() {
// 获取尾节点
final Node<E> l = last;
//判断是否为空,不为空返回值
return (l == null) ? null : l.item;
}
//删除并返回头节点的值
public E pollFirst() {
// 获取头节点
final Node<E> f = first;
//判断是否为空,不为空删除并返回值
return (f == null) ? null : unlinkFirst(f);
}
//删除并返回尾节点的值
public E pollLast() {
// 获取尾节点
final Node<E> l = last;
//判断是否为空,不为空删除并返回值
return (l == null) ? null : unlinkLast(l);
}
// 删除元素并返回元素值,从头结点开始删除
public E pop() {
return removeFirst();
}
修改元素
// 设置指定索引的值
public E set(int index, E element) {
//检查索引是否越界
checkElementIndex(index);
// 返回指定索引的结点
Node<E> x = node(index);
//指定索引结点原来的值
E oldVal = x.item;
// 设置为新的值
x.item = element;
// 返回旧的值
return oldVal;
}
判断是否包含
// 判断是否包含该值
public boolean contains(Object o) {
return indexOf(o) != -1;
}
clear()
为了让GC更快可以回收放置的元素,需要将node之间的引用关系赋空。
// 清空链表
public void clear() {
// Clearing all of the links between nodes is "unnecessary", but:
// - helps a generational GC if the discarded nodes inhabit
// more than one generation
// - is sure to free memory even if there is a reachable Iterator
// 从头节点开始遍设置为null
for (Node<E> x = first; x != null; ) {
Node<E> next = x.next;
x.item = null;
x.next = null;
x.prev = null;
x = next;
}
// 设置为null
first = last = null;
// 结点数清零
size = 0;
// 操作数累加,支持快速失败
modCount++;
}
作为队列
继承于Deque,说明其也具有队列的peek(),poll()与其类似的就是pollFirst(),pollLast(),peekLast(),peekFirst()
// 返回头节点的值
public E peekFirst() {
// 获取头节点
final Node<E> f = first;
//判断是否为空,不为空返回值
return (f == null) ? null : f.item;
}
// 返回尾结点的值
public E peekLast() {
// 获取尾节点
final Node<E> l = last;
//判断是否为空,不为空返回值
return (l == null) ? null : l.item;
}
//删除并返回头节点的值
public E pollFirst() {
// 获取头节点
final Node<E> f = first;
//判断是否为空,不为空删除并返回值
return (f == null) ? null : unlinkFirst(f);
}
//删除并返回尾节点的值
public E pollLast() {
// 获取尾节点
final Node<E> l = last;
//判断是否为空,不为空删除并返回值
return (l == null) ? null : unlinkLast(l);
}
//返回头节点的值,并删除
public E poll() {
// 获取头结点
final Node<E> f = first;
// 删除并返回头节点的值
return (f == null) ? null : unlinkFirst(f);
}
// 返回头节点的值
public E peek() {
// 获取头结点
final Node<E> f = first;
//判断是否为空,不为空返回值
return (f == null) ? null : f.item;
}
作为栈
// 删除元素并返回元素值,从头结点开始删除
public E pop() {
return removeFirst();
}
// 添加元素,并从头节点开始添加
public void push(E e) {
addFirst(e);
}
// 返回头节点的值
public E peek() {
// 获取头结点
final Node<E> f = first;
//判断是否为空,不为空返回值
return (f == null) ? null : f.item;
}