LinkedList源码分析 (JDK1.8)
简介
LinkedList是以双向链表为数据结构的容器。它可以进行堆栈、队列、双端队列的操作。
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
LinkedList 继承AbstractSequentialList，该被继承类是抽象类，是在迭代器的基础上实现的get、set、add和remove方法。该抽象类更多信息：AbstractSequentialList
LinkedList实现 Deque接口：能当做双端队列使用。
LinkedList实现 Cloneable接口：具有克隆功能。
LinkedList实现 Serializable接口：具有序列化功能。
API
boolean add(E object)
void add(int location, E object)
boolean addAll(Collection<? extends E> collection)
boolean addAll(int location, Collection<? extends E> collection)
void addFirst(E object)
void addLast(E object)
void clear()
Object clone()
boolean contains(Object object)
Iterator<E> descendingIterator()
E element()
E get(int location)
E getFirst()
E getLast()
int indexOf(Object object)
int lastIndexOf(Object object)
ListIterator<E> listIterator(int location)
boolean offer(E o)
boolean offerFirst(E e)
boolean offerLast(E e)
E peek()
E peekFirst()
E peekLast()
E poll()
E pollFirst()
E pollLast()
E pop()
void push(E e)
E remove()
E remove(int location)
boolean remove(Object object)
E removeFirst()
boolean removeFirstOccurrence(Object o)
E removeLast()
boolean removeLastOccurrence(Object o)
E set(int location, E object)
int size()
<T> T[] toArray(T[] contents)
Object[] toArray()
属性
//链表节点
transient int size = 0;
//双向链表表头节点
transient Node<E> first;
//双向链表表尾节点
transient Node<E> last;
//序列号
private static final long serialVersionUID = 876323262645176354L;
Node节点
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;
}
特别说明
/**
* Pointer to first node.
* Invariant: (first == null && last == null) ||
* (first.prev == null && first.item != null)
*/
transient Node<E> first;
/**
* Pointer to last node.
* Invariant: (first == null && last == null) ||
* (last.next == null && last.item != null)
*/
transient Node<E> last;
由注释内容知道，当双链表为空的时候，first和last都为空；当双链表都不为空的时候，first的前节点指针为空，first的数据不为空，last的后节点指针为空，last的数据不为空。
构造函数
//创建一个空的链表
public LinkedList() {
}
//将其他容器数据放入初始化链表中
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
//在first节点前面添加节点
private void linkFirst(E e) {
//保存first节点
final Node<E> f = first;
//创建节点，该节点前节点为null，后节点为first
final Node<E> newNode = new Node<>(null, e, f);
//更换first节点
first = newNode;
//若该链表为空，则也把last更换为新节点
if (f == null)
last = newNode;
else
//若该链表非空，则将原本first的前指针指向新的的first
f.prev = newNode;
//节点数++
size++;
modCount++;
}
//在last节点后面添加节点
void linkLast(E e) {
//保存last节点
final Node<E> l = last;
//创建节点，该节点前节点为last，后节点为null
final Node<E> newNode = new Node<>(l, e, null);
//更换last节点
last = newNode;
//若该链表为空，则也把first更换为新节点
if (l == null)
first = newNode;
else
//若该链表非空，则将原本last的后指针指向新的的last
l.next = newNode;
//节点数++
size++;
modCount++;
}
//在指定节点前添加一个新节点
void linkBefore(E e, Node<E> succ) {
//获取指定节点的前节点pre
final Node<E> pred = succ.prev;
//创建节点，该节点前节点为pre，后节点为指定节点succ
final Node<E> newNode = new Node<>(pred, e, succ);
//更改指定节点前指针，为e
succ.prev = newNode;
//若succ为first或者改链表节点数为1时，修改first节点
if (pred == null)
first = newNode;
else
//更改前节点pre的后指针为新节点newNode
pred.next = newNode;
size++;
modCount++;
}
//移除first节点
private E unlinkFirst(Node<E> f) {
// assert f == first && f != null;
//前提就是f为first且不为空
//获取first节点数据
final E element = f.item;
//获取first节点指向的下一个节点
final Node<E> next = f.next;
//将first节点置空
f.item = null;
f.next = null; // help GC
//first赋值为下一个节点next
first = next;
//若next为空，即链表长度为1，为将last置空
if (next == null)
last = null;
else
next.prev = null;
size--;
modCount++;
return element;
}
//移除last节点
private E unlinkLast(Node<E> l) {
// assert l == last && l != null;
//前提就是l为last且不为空
final E element = l.item;
//获取last节点指向的前一个节点
final Node<E> prev = l.prev;
l.item = null;
l.prev = null; // help GC
//last赋值为前一个节点prev
last = prev;
//若prev为空，即链表长度为1，为将first置空
if (prev == null)
first = null;
else
prev.next = null;
size--;
modCount++;
return element;
}
//移除节点
E unlink(Node<E> x) {
//获取该移除节点数据、前节点、后节点
final E element = x.item;
final Node<E> next = x.next;
final Node<E> prev = x.prev;
//若移除节点为first，修改first为后节点
if (prev == null) {
first = next;
} else {
//前节点与后节点互连
prev.next = next;
//将移除的节点的前指针置空
x.prev = null;
}
//若移除节点为last，则修改last为前节点
if (next == null) {
last = prev;
} else {
//前节点与后节点互连
next.prev = prev;
//将移除的节点的后指针置空
x.next = null;
}
x.item = null;
size--;
modCount++;
return element;
}
//获取first节点数据
public E getFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return f.item;
}
//获取last节点数据
public E getLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return l.item;
}
//移除first节点
public E removeFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}
//移除last节点
public E removeLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return unlinkLast(l);
}
//在链表头部添加数据
public void addFirst(E e) {
linkFirst(e);
}
//在链表尾部添加数据
public void addLast(E e) {
linkLast(e);
}
//检测是否存在数据o
public boolean contains(Object o) {
return indexOf(o) != -1;
}
//返回链表节点数
public int size() {
return size;
}
//往链表末尾添加数据
public boolean add(E e) {
linkLast(e);
return true;
}
//移除指定数据的节点
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 { //数据不为null
//遍历链表
for (Node<E> x = first; x != null; x = x.next) {
if (o.equals(x.item)) {
//调用移除节点方法
unlink(x);
return true;
}
}
}
return false;
}
//在链表尾部添加其他容器的数据
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}
//在指定位置添加其他容器的数据
public boolean addAll(int index, Collection<? extends E> c) {
//检测位置是否合法
checkPositionIndex(index);
Object[] a = c.toArray();
int numNew = a.length;
if (numNew == 0)
return false;
//pre为插入位置的前节点，succ为插入位置的后节点
Node<E> pred, succ;
if (index == size) {
succ = null;
pred = last;
} else {
succ = node(index);
pred = succ.prev;
}
//容器的数据依次创建节点，并设置好前后节点指针即可
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为null，则表示插入位置为size，需要重新对last赋值
if (succ == null) {
last = pred;
} else {
pred.next = succ;
succ.prev = pred;
}
size += numNew;
modCount++;
return true;
}
//清空链表数据，其实就是遍历链表，置空属性
public void clear() {
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;
modCount++;
}
//根据位置获取节点
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
//根据位置更改该节点信息
public E set(int index, E element) {
//判断位置是否合法
checkElementIndex(index);
Node<E> x = node(index);
E oldVal = x.item;
x.item = element;
return oldVal;
}
//根据位置添加数据
public void add(int index, E element) {
checkPositionIndex(index);
//若位置为链表尾部，直接调用linkLast
if (index == size)
linkLast(element);
else
linkBefore(element, node(index));
}
//根据位置移除节点
public E remove(int index) {
checkElementIndex(index);
return unlink(node(index));
}
//判断索引是否非法
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));
}
//根据索引获取节点
Node<E> node(int index) {
//当索引小于节点数一半，则从first节点向后开始寻找
if (index < (size >> 1)) {
Node<E> x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
//当索引大于等于节点数一半，则从last节点向前开始寻找
Node<E> x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
}
//根据指定数据获取节点位置（正向）
public int indexOf(Object o) {
int index = 0;
//通过遍历数据来寻找，数据照旧有两种情况，null和非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和非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;
}
//获取first节点的数据
public E peek() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
//获取first节点的数据
public E element() {
return getFirst();
}
//移除first节点
public E poll() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
//移除first节点
public E remove() {
return removeFirst();
}
//在链表末尾添加数据
public boolean offer(E e) {
return add(e);
}
//在链表头部添加数据
public boolean offerFirst(E e) {
addFirst(e);
return true;
}
//在链表末尾添加数据
public boolean offerLast(E e) {
addLast(e);
return true;
}
//查看first节点数据
public E peekFirst() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
//查看last节点数据
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 void push(E e) {
addFirst(e);
}
//移除链表第一个数据
public E pop() {
return removeFirst();
}
//移除从链表头部到尾部第一次出现数据o的节点
public boolean removeFirstOccurrence(Object o) {
return remove(o);
}
//移除从链表尾部到头部第一次出现数据o的节点
public boolean removeLastOccurrence(Object o) {
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;
}
//获取next为index的迭代器
public ListIterator<E> listIterator(int index) {
checkPositionIndex(index);
return new ListItr(index);
}
//获取反向迭代器
public Iterator<E> descendingIterator() {
return new DescendingIterator();
}
//反向迭代器实现类
private class DescendingIterator implements Iterator<E> {
private final ListItr itr = new ListItr(size());
// 反向迭代器是否下一个元素。
// 实际上是判断双向链表的当前节点是否达到开头
public boolean hasNext() {
return itr.hasPrevious();
}
// 反向迭代器获取下一个元素。
// 实际上是获取双向链表的前一个节点
public E next() {
return itr.previous();
}
// 删除当前节点
public void remove() {
itr.remove();
}
}
//调用父类克隆函数
private LinkedList<E> superClone() {
try {
return (LinkedList<E>) super.clone();
} catch (CloneNotSupportedException e) {
throw new InternalError(e);
}
}
// 克隆函数。返回LinkedList的克隆对象。
public Object clone() {
LinkedList<E> clone = superClone();
// 将克隆置于“原始”状态
clone.first = clone.last = null;
clone.size = 0;
clone.modCount = 0;
// 将链表中所有节点的数据都添加到克隆对象中
for (Node<E> x = first; x != null; x = x.next)
clone.add(x.item);
return clone;
}
//返回LinkedList的Object[]数组
public Object[] toArray() {
// 新建Object[]数组
Object[] result = new Object[size];
int i = 0;
// 将链表中所有节点的数据都添加到Object[]数组中
for (Node<E> x = first; x != null; x = x.next)
result[i++] = x.item;
return result;
}
// 返回LinkedList的模板数组。所谓模板数组，即可以将T设为任意的数据类型
public <T> T[] toArray(T[] a) {
// 若数组a的大小 < LinkedList的元素个数(意味着数组a不能容纳LinkedList中全部元素)
// 则新建一个T[]数组，T[]的大小为LinkedList大小，并将该T[]赋值给a。
if (a.length < size)
a = (T[])java.lang.reflect.Array.newInstance(
a.getClass().getComponentType(), size);
int i = 0;
// 将链表中所有节点的数据都添加到数组a中
Object[] result = a;
for (Node<E> x = first; x != null; x = x.next)
result[i++] = x.item;
if (a.length > size)
a[size] = null;
return a;
}
// java.io.Serializable的写入函数
// 将LinkedList的“容量，所有的元素值”都写入到输出流中
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
// Write out any hidden serialization magic
s.defaultWriteObject();
// 写入节点数
s.writeInt(size);
// 将链表中所有节点的数据都写入到输出流中
for (Node<E> x = first; x != null; x = x.next)
s.writeObject(x.item);
}
// java.io.Serializable的读取函数：根据写入方式反向读出
// 先将LinkedList的“容量”读出，然后将“所有的元素值”读出
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// Read in any hidden serialization magic
s.defaultReadObject();
// 从输入流中读取“容量”
int size = s.readInt();
// 从输入流中将“所有的元素值”并逐个添加到链表中
for (int i = 0; i < size; i++)
linkLast((E)s.readObject());
}
引用其他博客的总结：skywang12345：
-
LinkedList是通过双向链表来实现，其中链表节点为node，为LinkedList的内部类，属性包括该节点值、上一个节点，下一个节点。
-
从LinkedList的实现方式中可以发现，它不存在LinkedList容量不足的问题。
-
LinkedList的克隆函数，即是将全部元素克隆到一个新的LinkedList对象中。
-
LinkedList实现java.io.Serializable。当写入到输出流时，先写入“容量”，再依次写入“每一个节点保护的值”；当读出输入流时，先读取“容量”，再依次读取“每一个元素”。
-
从LinkedList的实现方式中可以发现，它不存在LinkedList容量不足的问题。
-
由于LinkedList实现了Deque，而Deque接口定义了在双端队列两端访问元素的方法。提供插入、移除和检查元素的方法。每种方法都存在两种形式：一种形式在操作失败时抛出异常，另一种形式返回一个特殊值（null 或 false，具体取决于操作）。
第一个元素（头部） 最后一个元素（尾部） 抛出异常 特殊值 抛出异常 特殊值 插入 addFirst(e) offerFirst(e) addLast(e) offerLast(e) 移除 removeFirst() pollFirst() removeLast() pollLast() 检查 getFirst() peekFirst() getLast() peekLast() -
LinkedList可以作为FIFO(先进先出)的队列，作为FIFO的队列时，下表的方法等价：
队列方法 等效方法 add(e) addLast(e) offer(e) offerLast(e) remove() removeFirst() poll() pollFirst() element() getFirst() peek() peekFirst() -
LinkedList可以作为LIFO(后进先出)的栈，作为LIFO的栈时，下表的方法等价：
栈方法 等效方法 push(e) addFirst(e) pop() removeFirst() peek() peekFirst()
