何为LinkedList？
LinkedList本身是一个，由Java中的链表思想的数据结构对象，类似于链表，而在Java里面，没有指针，是通过引用来连接的。是一个链表，同时也实现了队列和栈的操作。另外，它也是可以随机访问的，只是和前两篇的ArrayList不同，它的随机访问是通过遍历从而获取特定元素的。接下来从特定方面来讲。
定义头：
/**
*
* 基于双向链表实现，允许所有元素包括null
* 在java中的链表又称为动态数组连接而成的链表。
* 实现不是同步的。
* 同样，它的iterator也是fail-fast的
*/
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
transient int size = 0;
transient Node<E> first;
transient Node<E> last;Deque：支持两端元素插入和移除的线性集合。名称deque是“双端队列”的缩写
默认长度为0，并且保存有头节点和尾节点。
Node节点
/**
* 内部类，也就是链表的节点信息，双向链表，即一个指向前一个节点，一个指向后一个节点。
* @author anla7856
*
* @param <E>
*/
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就是代表链表的一个节点，节点里存有item：信息，next：下一个节点，prev：前一个节点。
LinkedList的主要操作
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++;
}
/**
*把元素e插入为数组末尾元素。
*/
void linkLast(E e) {
final Node<E> l = last;
//这一句已经把newnode的pre指针接上了。
final Node<E> newNode = new Node<>(l, e, null);
last = newNode;
if (l == null)
first = newNode;
else
l.next = newNode;
size++;
modCount++;
}在链表开头插入节点以及在链表尾上插入节点
其他的操作和此操作原理类似，例如有
void linkBefore(E e, Node succ) ,将e插入到succ的前面
2）：删除节点
/**
* 把f的下一个节点作为头节点，返回f节点，可以类似于从头开始遍历
*/
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;
f.next = null; // help GC
first = next;
if (next == null)
last = null;
else
next.prev = null;
size--;
modCount++;
return element;
}
/**
* 把这个中间节点删除。
*/
E unlink(Node<E> x) {
// assert x != null;
final E element = x.item;
final Node<E> next = x.next;
final Node<E> prev = x.prev;
if (prev == null) {
first = next;
} else {
prev.next = next;
x.prev = null;
}
if (next == null) {
last = prev;
} else {
next.prev = prev;
x.next = null;
}
x.item = null;
size--;
modCount++;
return element;
}删除节点操作，如果e是边界节点，如unlinkFirst方法，则删除时，只需要把一个引用(prev或next)置为null即可，当然还要注意gc，把不要的节点置为null。
而如果删除e是中间节点，如unlink方法，则需要把e的前后两个节点串起来，也就是他们的prev和next方法需要连起来。
清空链表：
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++;
}把相应的位置引用置为null，便于垃圾回收。
3）：随机访问
/**
* 返回特殊顺序号的node节点，
* 实现思路，二分链表，然后遍历其中之一，
* 然后找到这个节点
*
*/
Node<E> node(int 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;
}
}
/**
* 随机设置值。
*/
public E set(int index, E element) {
checkElementIndex(index);
Node<E> x = node(index);
E oldVal = x.item;
x.item = element;
return oldVal;
}所以在LinkedList的随机访问里面，其实是通过遍历整个集合，再根据特定判断条件（index，或者object）来找到特定的Node节点，1再对Node节点进行操作的。
ListItr迭代器
具体的和一般的迭代器差不多，里面有除了有访问方法next，previous之外，还有remove和add方法
/**
* LinkedList的iterator，注意有fast-fail
* fast-fail中，只有遍历（访问）的时候才会检查ConcurrentModificationException异常
* 而在iterator中删除或者增加时，是不会检查的，因为此时，expectedModCount会自增，而modCount也会++
* 所以二者还是相等。
*/
private class ListItr implements ListIterator<E> {
...省略除此之外，LinkedList还有一个能够以相反顺序遍历集合的DescendingIterator，文章开头讲了LinkedList具有双向队列功能，所以当然也具有从后往前遍历利用prev引用从后往前遍历的功能。
而里面的实际操作，则是通过ListItr来实现的。
/**
* 能够以相反的顺序遍历的iterator，主要代码也是通过ListItr实现的。
*/
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();
}
}LLSpliterator
当然，LinkedList里面也有分割迭代器，大体的和其他集合类的迭代器相似，当然，由于是以链表的方式实现，所以数据量可能很大，所以在分割表获取迭代器方面，LLSpliterator迭代器有两个额外字段：
static final int BATCH_UNIT = 1 << 10; // 批处理数组的一次增加长度
static final int MAX_BATCH = 1 << 25; // 批处理数组最大长度，即a的LLSpliterator也具有fast-fail特性，另外，在trySplit方法，也与其他的集合不同：
/**
* 只有这个类返回是父类的spliterator，前几天看得两个都是直接返回自定义的linkedlist
* @return
*/
public Spliterator<E> trySplit() {
Node<E> p;
int s = getEst();
if (s > 1 && (p = current) != null) {
int n = batch + BATCH_UNIT;
if (n > s)
n = s;
if (n > MAX_BATCH)
n = MAX_BATCH;
Object[] a = new Object[n];
int j = 0;
// 把linkedlist都装到a里面。
do { a[j++] = p.item; } while ((p = p.next) != null && j < n);
current = p;
batch = j;
est = s - j;
return Spliterators.spliterator(a, 0, j, Spliterator.ORDERED);
}
return null;
}首先该方法返回的是父类的Spliterator而不是LLSpliterator，另一方面，当返回父类的迭代器后，进行操作的也有原LinkedList变为了Object[] a，所以最终相当于copy了一份LinkedList中数据，利用父类的Spliterator默认实现方法来进行并行迭代的操作。
虽然这样做了，但这样并不会出错，因为
1、LinkList没有变，则Object[] a 和原LinkedList相同，无所谓。
2、LinkList通过add或者remove等方法变了，那在进行tryAdvance和forEachRemaining就会抛出ConcurrentModificationException错误，因为是快速失败的。
总体来说，LinkedList实现比较简单的，但首先得熟练长或链表的操作，包括链表的建立（头插法，尾插法），删除，遍历，以及双向链表的结构特性等等。
感觉有收获喔^^