Collection容器家族(LinkedList源码详解)
一、LinkedList在Collection集合体系中的位置
Linked:链表，List:线性表；加在一起，就能理解出LinkedList集合，底层是以链表为存储结构的集合，不过这个链表是双向链表。LinkedList是由AbstractSequentialList超类特化而来。AbstractSequentialList前面有讲过，他就是一个简洁的基于迭代的线性表，去除了随机访问的可能。他实现了了List接口，这个接口以前详细的讲过；Serializable可序列化接口；Deque双向队列；什么是双向队列？通俗点说就是从正反两个方向都可以访问的队列。而Deque继承了队列Queue，Queu队列是单向队列。Queu实现了基本的队列方法。这里又引出了一个问题，什么是队列？通俗点将就是先进先出，后继后出。那么LinkedList继承了Deque势必也要去实现这些个方法。这些方法很全面以至于现在我们很常用LinkedList是现栈和队列的操作。
二、LinkedList的使用概述
在很多关于LinkedList的描述中，都称描述他为栈和队列，下面我将以LinkedList作为栈和队列两个方面来讲解它的方法。
看类，首先看成员变量，其次构造方法。然后是成员方法。
三、LinkedList的成员变量
transient int size = 0; // 集合中元素个数
transient Node<E> first; // 头结点
transient Node<E> last; // 尾节点链式存储节点的数据结构(类似于C语言中的结构体)
/**
* 链表节点类
*/
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;
}
}四、构造方法
public LinkedList() {
}无参构造，这个一看就懂。
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
} /**
* 功能：添加E，及其子类集合对象中的所有元素
*/
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
}
/**
* 功能：在指定索引处添加一个集合的元素
* 实现：
* 1.使用toArray()将集合转换成数组，如果数组长度为0，直接返回false
* 2.pred为添加元素的起始节点，succ为添加元素的结束节点
* 3.根据index索引调用node方法获取index索引处的节点，该节点的前驱就是pred，后继为succ
* 4.遍历待添加元素数组，将该元素依次添加到pred节点后
* 5.再将先添加的最后一个节点与succ节点连在一起
*/
public boolean addAll(int index, Collection<? extends E> c) {
checkPositionIndex(index);
Object[] a = c.toArray();
int numNew = a.length;
if (numNew == 0)
return false;
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;
}
if (succ == null) {
last = pred;
} else {
pred.next = succ;
succ.prev = pred;
}
size += numNew;
modCount++;
return true;
}带参构造，将Collection集合中的元素初始化给链表。
五、作为栈使用
对表头的压栈出栈操作
1.压栈操作
/**
* 功能：链接e作为个第一个元素
* 实现：
* 1.将头结点值保存在临时节点f中，创建新节点newNode，前驱为空，值为e，后继为f(也就是头节点)，将这个新节点作为头结点。
* 2.如果之前的头结点为空(即链表为空，没有元素)，将newNode节点赋值给尾节点(即链表中就一个元素，这个元素即是头结点也是尾节点)。
* 3.如果之前的头结点不为空，将之前的头结点的前驱指向newNode，也就是指向现在的新头结点。
* 4.链表元素个数+1，修改次数+1。至此完成在头部添加元素。
*/
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++;
}
/**
* 功能：插入指定的元素作为链表的头节点
* 实现：
* 1.调用上面讲过的linkFirst私有方法在插入元素作为头节点
*/
public void addFirst(E e) {
linkFirst(e);
}
/**
* 功能：添加元素在头结点
*/
public boolean offerFirst(E e) {
addFirst(e);
return true;
}
/**
* 功能：添加元素在链表尾部
*/
public boolean offerLast(E e) {
addLast(e);
return true;
}
/**
* 功能：添加元素作为头结点
*/
public void push(E e) {
addFirst(e);
}
2.出栈操作
/**
* 功能：删除队列第一个元素，类似于出队列操作
* 实现：
* 1.在操作的节点为头结点且不是空节点的情况下进行如下操作。
* 2.获取当前头结点值域，并将它下一个节点迁移作为头结点。
*/
private E unlinkFirst(Node<E> f) {
// assert f == first && f != null;
final E element = f.item; // 获取头结点元素，作为返回元素
final Node<E> next = f.next; // 获取头结点下一个节点
f.item = null; // 将当前头结点值域和链接下一个节点的指针域置空，GC垃圾回收器回收
f.next = null; // help GC
first = next; // 上面获取的节点作为新的头结点
if (next == null) // 如果当前节点为空，即空链表；将first指针和last指针指向相同的节点
last = null;
else // 如果不是空节点，将新的头结点前驱置空
next.prev = null;
size--; // 长度-1，修改次数+1，返回元素
modCount++;
return element;
}
/**
* 功能：移除并返回列表的头结点
* 实现：
* 1.检查：如果是空列表，抛出异常
* 2.调用上面讲过的unlinkFirst方法移除并返回第一个元素
*/
public E removeFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return unlinkFirst(f);
}
/**
* 功能：获取链表第一个元素，同时会删除。(即出队列操作)
* 实现：
* 1.如果链表为空，返回null，否者调用unlinkFirst方法返回并删除头节点
*/
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();
}
对表尾的压栈出栈操作
1.压栈操作
/**
* 功能：链接e作为最后一个元素
* 实现：
* 1.将尾节点保存到临时节点l中，创建新节点newNode，前驱指向l(也就是尾节点)、值为e、后继为空，将这个新节点作为尾节点。
* 2.如果之前的尾结点为空(即之前没有元素，现在就一个元素)，将头结点指向newNode，头结点和尾节点都是一个元素。
* 3.如果之前的尾节点不为空(链表中有元素)，将之前的尾节点后继指向新的尾节点。
* 4.链表元素个数+1，修改次数+1。至此完成在尾节点添加元素。
*/
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++;
}
/**
* 功能：插入指定的元素作为链表的尾节点
* 实现：
* 1.调用上面讲过的linkLast私有方法在插入元素作为头节点
*/
public void addLast(E e) {
linkLast(e);
}
/**
* 功能：在链表末尾添加元素，该方法使用linkLast实现
*/
public boolean add(E e) {
linkLast(e);
return true;
}
/**
* 功能：添加元素在链表尾
*/
public boolean offer(E e) {
return add(e);
}2.出栈操作
/**
* 功能：删除队列尾部最后一个元素，类似于出栈操作
* 实现：
* 1.在操作的节点为尾节点且不是空节点的情况下进行如下操作。
* 2.获取当前尾结点值域，并将它上一个节点迁移作为尾结点。
*
* 注：该方法和上一个方法属于同一个系列方法，故不赘述
*/
private E unlinkLast(Node<E> l) {
// assert l == last && l != null;
final E element = l.item;
final Node<E> prev = l.prev;
l.item = null;
l.prev = null; // help GC
last = prev;
if (prev == null)
first = null;
else
prev.next = null;
size--;
modCount++;
return element;
}
/**
* 功能：移除并返回列表的尾结点
* 实现：
* 1.检查：如果是空列表，抛出异常
* 2.调用上面讲过的unlinkFirst方法移除并返回尾节点
*/
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);
}写到这里，我不得不说，方法超级无敌的多，多也不算啥，但是最基本的就那几个，被其他接口的方法调来调去。
六、队列操作
1.查找元素的一些方法
/**
* 功能：获取链表的头节点的值域
* 实现：
* 1.检查：如果是空列表，即没有头节点，抛出异常
* 2.返回值域
*/
public E getFirst() {
final Node<E> f = first;
if (f == null)
throw new NoSuchElementException();
return f.item;
}
/**
* 功能：获取链表的尾节点的值域
* 实现：
* 1.检查：如果是空列表，即没有尾节点，抛出异常
* 2.返回值域
*/
public E getLast() {
final Node<E> l = last;
if (l == null)
throw new NoSuchElementException();
return l.item;
}
/**
* 功能：根据索引获取元素
* 实现：
* 1.使用node方法获取元素
*/
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
/**
* 功能：根据索引获取指定节点
* 实现：
* 1.实现方法采用二分查找的推广方法，可以减少迭代量(移位运算)
*/
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;
}
}
* 功能：返回指定元素在链表中第一次出现的索引
* 实现：
* 1.如果指定元素为空元素时，遍历链表，找到并返回索引
* 2.如果指定元素不为空元素时，遍历链表，找到并返回索引
* 3.如果没找到，返回-1
*/
public int indexOf(Object o) {
int index = 0;
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;
}
/**
* 功能：返回指定元素最后一次出现的索引
* 实现：
* 1.同indexOf方法，区别在于将链表从后往前迭代
*
* 反思：如果是我之前给我这个需求，我会做的很难。看到这种实现方法，有一种豁然开朗的感觉
*/
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;
}
/**
* 功能：返回链表的头节点
* 实现:
* 1.这个就很简单了，使用了一个三元运算符
*/
public E peek() {
final Node<E> f = first;
return (f == null) ? null : f.item;
}
/**
* 功能：获取链表的头结点元素值，只能获取头结点
* 实现：
* 1.调用getFirst方法获取
*/
public E element() {
return getFirst();
}2.ListIterator迭代器
/**
* 迭代器实现类
*/
private class ListItr implements ListIterator<E> {
private Node<E> lastReturned; // 保存移动指针索引节点后的前一个节点
private Node<E> next; // 当前索引对应的节点
private int nextIndex; // 索引
private int expectedModCount = modCount; // 预期修改次数
ListItr(int index) { // 初始化指定索引的元素和元素索引指针
// assert isPositionIndex(index);
next = (index == size) ? null : node(index);
nextIndex = index;
}
public boolean hasNext() { // 判断时候还有下一个元素
return nextIndex < size;
}
public E next() { // 获取下一个元素
checkForComodification();
if (!hasNext())
throw new NoSuchElementException();
lastReturned = next;
next = next.next;
nextIndex++;
return lastReturned.item;
}
public boolean hasPrevious() { // 时候还有前一个元素
return nextIndex > 0;
}
public E previous() { // 获取前一个元素
checkForComodification();
if (!hasPrevious())
throw new NoSuchElementException();
lastReturned = next = (next == null) ? last : next.prev;
nextIndex--;
return lastReturned.item;
}
public int nextIndex() { // 获取下一个节点索引
return nextIndex;
}
public int previousIndex() { // 获取上一个节点索引
return nextIndex - 1;
}
public void remove() { //移除节点
checkForComodification();
if (lastReturned == null)
throw new IllegalStateException();
Node<E> lastNext = lastReturned.next;
unlink(lastReturned);
if (next == lastReturned)
next = lastNext;
else
nextIndex--;
lastReturned = null;
expectedModCount++;
}
public void set(E e) { // 替换当前节点的值域
if (lastReturned == null)
throw new IllegalStateException();
checkForComodification();
lastReturned.item = e;
}
public void add(E e) { // 添加元素
checkForComodification();
lastReturned = null;
if (next == null)
linkLast(e);
else
linkBefore(e, next);
nextIndex++;
expectedModCount++;
}
public void forEachRemaining(Consumer<? super E> action) {
Objects.requireNonNull(action);
while (modCount == expectedModCount && nextIndex < size) {
action.accept(next.item);
lastReturned = next;
next = next.next;
nextIndex++;
}
checkForComodification();
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
}3.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();
}
}七、总结：
LinkedList是用链表来实现的，它的应用场景，不确定集合元素的数量，还要经常性的该表集合的结构(也就是删除，添加)，一般用作队列和栈。在这样的场景下无疑我们使用LinkedList是最合适的。
拿LinkedList和ArrayList做一下比较，
ArrayList我们无论是修改，查找，添加，在不改变结构的情况下，这些操作基本都是O(1)的级别，即使我查找一个不确定位置的元素，通过二分查找也能快速定位到元素。非常之方便，但是arrayList最忌讳的就是结构的修改。因为一旦我们修改结构就意味着可能要进行扩容和按位覆盖值，这显然不是我们想要的。
LinkedList我们无论是删除，添加，在哪添加，在哪删除，怎么修改结构尤其是作为队列和栈基本都会保持在O(1)的级别，但是一旦我们要查找一个元素，那就是需要慢慢的迭代。
它们两个各有各的优势，学会善于使用他们，能使程序的性能得到很大的保证。
