LinkedList源码分析
LinkedList是一个实现了List接口和Deque接口的双端链表。 LinkedList底层的链表结构使它支持高效的插入和删除操作，另外它实现了Deque接口，使得LinkedList类也具有队列的特性; LinkedList不是线程安全的，如果想使LinkedList变成线程安全的，可以调用静态类Collections类中的synchronizedList方法：
List list=Collections.synchronizedList(new LinkedList(...));
LinkedList中每一个节点是一个Node类型的对象，Node是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;
}
}
这个类就代表双端链表的节点Node。这个类有三个属性，分别是本节点的值element，前驱节点prev，后继结点next。
属性
// 记录LinkedList的大小
transient int size = 0;
// 指向链表的头节点
transient Node<E> first;
// 指向链表的尾节点
transient Node<E> last;
构造器
// 空参构造器
public LinkedList() {
}
// 根据指定的集合构建一个链表，链表中元素按照集合迭代器的返回顺序存放
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
第二个构造器是通过调用addAll方法完成对指定集合的添加。该方法的作用是将参数集合从指定位置开始插入到链表中。
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;
// 创建两个指针，succ指向待添加节点的位置的后继节点
// pred指向待添加节点的前一个节点
Node<E> pred, succ;
// 此处是对元素插入位置的一个分支判断
// 1、如果插入的位置是链表的尾部，则pred指向last，succ指向null
if (index == size) {
succ = null;
pred = last;
}
// 2、如果插入的位置位于链表的中间，则succ指向待添加节点后继节点，该后继节点就是原来位于index位置的那个节点，可以通过node(index)方法获得，然后pred基于succ获得待添加节点的前驱结点。
else {
succ = node(index);
pred = succ.prev;
}
// 遍历数组a，将其中的所有元素插入到链表中，采用尾插法
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;
}
// 如果插入元素的位置是从链表尾部开始的，那么循环遍历完以后，pred指向的就是链表的最后一个元素，直接重置last节点即可
if (succ == null) {
last = pred;
}
// 否则，将新插入的链表部分与先前index位置即其后部分的链表连接起来
// 此时pred指向的就是新插入部分的最后一个节点，而succ指向的是原来位于index位置的那个节点
else {
pred.next = succ;
succ.prev = pred;
}
// 修改链表的大小
size += numNew;
//modCount（修改的次数）自增1
modCount++;
return true;
}
分析一下node方法：
Node<E> node(int index) {
// assert isElementIndex(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;
}
}
该方法的作用是返回指定元素索引处的（非空）节点，所以它的参数是一个索引。此处寻找指定索引位置的节点，进行了一些优化。不再是拿着指定的索引值就从头去遍历链表，而是先判断这个指定的索引值位于链表中的前半部分还是后半部分，如果index位于前半部分则从头开始遍历查找（使用的是next指针）；如果index位于链表的后半部分，则从链表尾部节点开始从后向前遍历查找链表（使用的是prev指针）。
添加元素的方法
add(E e)
将元素添加到链表尾部
public boolean add(E e) {
linkLast(e);
return true;
}
// 将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;
size++;
modCount++;
}
offer(E e)
public boolean offer(E e) {
return add(e);
}
当LinkedList作为队列的时候，可以作为入队操作来使用。底层调用的是add方法，将元素添加到链表的尾部。
add(int index, E element)
在指定位置插入元素
public void add(int index, E element) {
// 插入位置的合法性检验：[0,size]
checkPositionIndex(index);
// 添加到链表尾部
if (index == size)
linkLast(element);
// 将元素插入到链表的中间位置
else
linkBefore(element, node(index));
}
// succ指向当前待插入节点的后继节点，它是通过node(index)方法获得的
void linkBefore(E e, Node<E> succ) {
// assert succ != null;
// 获得待插入节点的前驱节点
final Node<E> pred = succ.prev;
// 创建新节点
final Node<E> newNode = new Node<>(pred, e, succ);
succ.prev = newNode;
if (pred == null)
first = newNode;
else
pred.next = newNode;
size++;
modCount++;
}
addFirst(E e)
将元素添加到链表头部
public void addFirst(E e) {
linkFirst(e);
}
private void linkFirst(E e) {
final Node<E> f = first;
// 新建节点，以头节点为后继节点
final Node<E> newNode = new Node<>(null, e, f);
first = newNode;
//如果链表为空，last节点也指向该节点
if (f == null)
last = newNode;
//否则，将原来的头节点的前驱指针指向新节点，也就是指向前一个元素
else
f.prev = newNode;
size++;
modCount++;
}
push(E e)
public void push(E e) {
addFirst(e);
}
当链表作为栈使用时，该方法作为入栈操作来使用，实质就是将元素添加到链表头部。
根据位置获取数据的方法
get(int index)
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
根据指定索引返回数据。实质上调用的是node(index)方法，注意，由于node方法内部没有对索引位置值进行合法性检验，所以在调用node方法之前一定要对index进行合法性检验。
获取链表头节点的方法
public E getFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return f.item;
}
public E element() {
return getFirst();
}
public E peek() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
public E peekFirst() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
element方法底层调用的就是getFirst方法，所以它们可以看作是一样的。这两个方法获取头节点时，如果链表是一个空链表，则会抛出异常；
peek和peekFirst的内部逻辑是一样的，所以这两个方法作用也一样，它们在获取头节点时，如果遇到了空链表，则不会抛出异常，而是返回一个null。
获取链表尾部节点的方法
public E getLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return l.item;
}
public E peekLast() {
final Node<E> l = last;
return (l == null) ? null : l.item;
}
getLast() 方法在链表为空时，会抛出NoSuchElementException，而peekLast() 则不会，只是会返回 null。
根据对象获取索引的方法
indexOf(Object o)
public int indexOf(Object o) {
int index = 0;
// 如果寻找的是null值，从链表头开始遍历寻找链表中是否有null，若有则返回其索引位置，没有返回-1
if (o == null) {
for (Node<E> x = first; x != null; x = x.next) {
if (x.item == null)
return index;
index++;
}
}
// 从头遍历寻找与对象o相等的元素
else {
for (Node<E> x = first; x != null; x = x.next) {
if (o.equals(x.item))
return index;
index++;
}
}
return -1;
}
可以看到在链表中寻找与指定对象相等的元素时，如果指定元素是null，则直接用“==”判断是否相等；如果不是null，则使用equals方法判等，所以定义一个类的时候，一定要重写它的equals方法。
其中，LinkedList中的contains方法调用的也是indexOf方法，如果返回-1说明不包含指定的元素，否则就是包含。
public boolean contains(Object o) {
return indexOf(o) != -1;
}
lastIndexOf(Object o)
从尾部开始遍历寻找与指定对象相等的元素的位置。
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;
}
删除方法
删除头节点
// 链表作为栈使用时，可以作为出栈操作
public E pop() {
return removeFirst();
}
public E remove() {
return removeFirst();
}
public E removeFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}
//链表作为队列时，可以作为出队操作
public E poll() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
pop、remove、removeFirst方法在链表为空时执行将抛出NoSuchElementException异常，而poll方法则是返回null。
删除尾节点
public E removeLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return unlinkLast(l);
}
public E pollLast() {
final Node<E> l = last;
return (l == null) ? null : unlinkLast(l);
}
removeLast()在链表为空时将抛出NoSuchElementException，而pollLast()方法返回null。
删除指定元素
从此列表中删除第一次出现的指定元素，如果链表中有多个元素与指定元素相等，那么就只删除第一个出现的那个元素。如果删除了匹配对象，返回true，否则false。
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;
}
remove执行的删除操作最终都是由unlink方法完成的，下面分析一下unlink方法的源码：
E unlink(Node<E> x) {
// assert x != null;
final E element = x.item;
// 得到x的后继节点
final Node<E> next = x.next;
// 得到x的前驱节点
final Node<E> prev = x.prev;
// 如果删除的节点是头节点,令头节点指向该节点的后继节点
if (prev == null) {
first = next;
}
// 将前驱节点的后继指针指向x的后继节点，并将x的前驱指针指向null
else {
prev.next = next;
x.prev = null;
}
//如果删除的节点是尾节点,令尾节点指向该节点的前驱节点
if (next == null) {
last = prev;
}
// 将x节点的后继节点的前驱指针指向x节点的前驱节点，并将x的后继指针指向null
else {
next.prev = prev;
x.next = null;
}
x.item = null;
size--;
modCount++;
return element;
}
该方法的整个执行步骤是：
（1）获取指定对象的前驱节点和后继节点；
（2）判断当前指定对象是否是头节点：
1）如果是头节点，则将头节点指针指向当前节点的后继节点；
2）如果不是头节点，则将该节点的前驱节点的后继指针指向该节点的后继节点，并将当前节点的前驱指针设置为null；
（3）判断当前对象是否是尾部节点：
1）如果是尾部节点，则将尾指针指向该节点的前驱节点；
2）如果不是尾部节点，则将该节点的后继节点的前驱指针指向该节点的前驱节点，并将当前节点的后继指针设置为null；
（3）将当前节点值设置为null，以便于回收。
（4）链表大小减1，链表结构修改次数加1，并返回被删除的节点对象。
remove(int index)方法底层调用的是node(index)和ublink方法，先利用node获取指定索引位置的节点对象，然后用unlink方法将这个对象进行删除，只不过先进行了索引位置的合法性检验。
public E remove(int index) {
checkElementIndex(index);
return unlink(node(index));
}
总结
1、LinkedList可以存储null值
2、LinkedList底层是一个双向链表，线程不安全
3、LinkedList既可以作为队列使用，出队和入队的组合操作是poll和offer；也可以作为栈使用，出栈和入栈的组合操作是pop和push。
4、往链表中插入元素的方法是尾插法
5、链表的顺序访问效率高，随机访问的效率低。在依据index值进行随机访问时，进行了优化，先对index在链表中的大致位置进行了判断，如果index位于链表的左半部分就从头向后遍历；如果index位于链表的右半部分，就从后向前遍历。
6、链表比较浪费空间的原因是对于每一个节点对象，都包含了一个指向前驱和一个指向后继的指针。
7、LinkedList采用链表存储，所以对于add(E e)方法的插入，删除元素时间复杂度不受元素位置的影响，近似 O(1)，如果是要在指定位置i插入和删除元素的话时间复杂度近似为O(n)因为需要先移动到指定位置再插入。
参考文献：https://snailclimb.gitee.io/javaguide/#/docs/java/collection/LinkedList源码分析
