链表是对上一篇博文所说的顺序表的一种实现。
与ArrayList思路截然不同，链表的实现思路是：
- 不同元素实际上是存储在离散的内存空间中的。
- 每一个元素都有一个指针指向下一个元素，这样整个离散的空间就被“串”成了一个有顺序的表。
从链表的概念来讲，它可以算是一种递归的数据结构，因为链表拿掉第一个元素剩下的部分，依然构成一个链表。
时间空间复杂度
- 通过索引定位其中的一个元素。由于不能像ArrayList那样直接通过计算内存地址偏移量来定位元素，只能从第一个元素开始顺藤摸瓜来数，因此为O(n)。
-
插入元素。实际上插入元素需要看情况：
- 如果指定链表中某个元素将其插之其后，那么首先得找出该元素对应的节点，还是O(n)。
- 如果能够直接指定节点往其后插入（如通过迭代器），那么仅仅需要移动指针即可完成，O(1)。
- 移除元素。移除和插入类似，得看提供的参数是什么。如果提供的是元素所在的节点，那么也只需要O(1)。
LinkedList的继承结构
首先继承结构和ArrayList类似，实现了List接口。
但是，它继承的是继承了AbstractList类的AbstractSequentialList类，
这个类的作用也是给List中的部分函数提供默认实现，只是这个类对链表这种List的实现提供了更多贴合的默认函数实现。
还有可以注意到，LinkedList实现了Deque接口，这也很显然，链表这种结构天然就适合当做双端队列使用。
LinkedList源码分析
节点定义
先来看链表的节点定义：
private static class Node {
E item;
Node next;
Node prev;
Node(Node prev, E element, Node next) {
this.item = element;
this.next = next;
this.prev = prev;
}
} 可以看到，链表节点除了保存数据外，还需要保存指向前后节点的指针。
这里，链表即有后继指针也有前驱指针，因此这是一个双向链表。
一组节点之间按顺序用指针指起来，就形成了链表的链状结构。
属性和构造函数
transient int size = 0;
transient Node first;
transient Node last; 三个属性，first和last分别指向链条的首节点和尾节点。
这样有个好处，就是链表即可以使用头插法也可以采用尾插法。
size属性跟踪了链表的元素个数。虽然说遍历一遍链表也能统计到元素个数，
但是那是O(n)的费时操作。
因此，我们可以发现链表的size方法是O(1)的时间复杂度。
public LinkedList() {
}LinkedList的代码很简单，构造函数空空如也。
空表中，first和last字段都为null。
get和set方法
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
public E set(int index, E element) {
checkElementIndex(index);
Node x = node(index);
E oldVal = x.item;
x.item = element;
return oldVal;
}
Node node(int index) {
// assert isElementIndex(index);
if (index < (size >> 1)) {
Node x = first;
for (int i = 0; i < index; i++)
x = x.next;
return x;
} else {
Node x = last;
for (int i = size - 1; i > index; i--)
x = x.prev;
return x;
}
} get和set的思路都是先根据索引定位到链表节点，然后获得或设置节点中的数据，这抽象出了node函数，根据索引找到链表节点。
node的思路也很显然，遍历一遍即可得到。
这里做了一点优化，我们可以发现LinkedList的实现是一个双向链表，并且LinkedList持有了头尾指针。
那么，根据索引和size就可以知道该节点是在链表的前半部分还是后半部分，
从而决定从头节点开始遍历还是从尾节点开始遍历，这样最多遍历 N / 2次即可找到。
添加/删除
public boolean add(E e) {
linkLast(e);
return true;
}
public void add(int index, E element) {
checkPositionIndex(index);
if (index == size)
linkLast(element);
else
linkBefore(element, node(index));
}
void linkLast(E e) {
final Node l = last;
final Node 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) {
final Node pred = succ.prev;
final Node newNode = new Node<>(pred, e, succ);
succ.prev = newNode;
if (pred == null)
first = newNode;
else
pred.next = newNode;
size++;
modCount++;
} 添加/删除的思路都类似，删除的代码就不贴了。如果能够提供需要被操作的节点，就能直接移动下指针，O(1)完成。否则就需要遍历找到这个节点再操作。
需要关注两点：
- 有的操作是操作头指针，有的操作是操作尾指针。但是不管操作哪一个，都需要维护另外一个指针及size的值。
- 如果是删除，删除后及时把相关节点的item字段置为null，以帮助gc能更快的释放内存。
modCount字段分析
之前阅读ArrayList的代码时发现了modCount这一字段，它是定义在AbstractList类中的。之前不知道它起到什么作用，这次给弄明白了。
迭代器
迭代器迭代中表被修改
考虑以下这段代码：
List list = new LinkedList<>();
Iterator it = list.listIterator();
list.add(1);
it.next(); 在迭代器创建之后，对表进行了修改。这时候如果操作迭代器，则会得到异常java.util.ConcurrentModificationException。
这样设计是因为，迭代器代表表中某个元素的位置，内部会存储某些能够代表该位置的信息。当表发生改变时，该信息的含义可能会发生变化，这时操作迭代器就可能会造成不可预料的事情。
因此，果断抛异常阻止，是最好的方法。
实际上，这种迭代器迭代过程中表结构发生改变的情况，更经常发生在多线程的环境中。
记录表被修改的标记
这种机制的实现就需要记录表被修改，那么思路是使用状态字段modCount。
每当会修改表的操作执行时，都将此字段加1。使用者只需要前后对比该字段就知道中间这段时间表是否被修改。
如linkedList中的头插和尾插函数，就将modCount字段自增：
private void linkFirst(E e) {
final Node f = first;
final Node newNode = new Node<>(null, e, f);
first = newNode;
if (f == null)
last = newNode;
else
f.prev = newNode;
size++;
modCount++;
}
void linkLast(E e) {
final Node l = last;
final Node newNode = new Node<>(l, e, null);
last = newNode;
if (l == null)
first = newNode;
else
l.next = newNode;
size++;
modCount++;
} 迭代器
迭代器使用该字段来判断，
private class ListItr implements ListIterator {
private Node lastReturned;
private Node 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 void set(E e) {
if (lastReturned == null)
throw new IllegalStateException();
checkForComodification();
lastReturned.item = e;
}
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
} 迭代器开始时记录下初始的值：
private int expectedModCount = modCount;然后与现在的值对比判断是否被修改：
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}这是一个内部类，隐式持有LinkedList的引用，能够直接访问到LinkedList中的modCount字段。