1.介绍及注意事项
链表由Josh Bloch书写，属于Java集合框架中的一种，LinkedList实现的是双链表，实现了所有的链表操作，可能够实现所有元素（包括）的基本操作。
链表是非线程同步的，多线程情况下需要使用外部同步。
使用迭代器遍历此类时具有快速失败的特性（遍历过程中移除节点会报错）
/**
* Doubly-linked list implementation of the {@code List} and {@code Deque}
* interfaces. Implements all optional list operations, and permits all
* elements (including {@code null}).
*
* <p>All of the operations perform as could be expected for a doubly-linked
* list. Operations that index into the list will traverse the list from
* the beginning or the end, whichever is closer to the specified index.
*
* <p><strong>Note that this implementation is not synchronized.</strong>
* If multiple threads access a linked list concurrently, and at least
* one of the threads modifies the list structurally, it <i>must</i> be
* synchronized externally. (A structural modification is any operation
* that adds or deletes one or more elements; merely setting the value of
* an element is not a structural modification.) This is typically
* accomplished by synchronizing on some object that naturally
* encapsulates the list.
*
* If no such object exists, the list should be "wrapped" using the
* {@link Collections#synchronizedList Collections.synchronizedList}
* method. This is best done at creation time, to prevent accidental
* unsynchronized access to the list:<pre>
* List list = Collections.synchronizedList(new LinkedList(...));</pre>
*
* <p>The iterators returned by this class's {@code iterator} and
* {@code listIterator} methods are <i>fail-fast</i>: if the list is
* structurally modified at any time after the iterator is created, in
* any way except through the Iterator's own {@code remove} or
* {@code add} methods, the iterator will throw a {@link
* ConcurrentModificationException}. Thus, in the face of concurrent
* modification, the iterator fails quickly and cleanly, rather than
* risking arbitrary, non-deterministic behavior at an undetermined
* time in the future.
*
* <p>Note that the fail-fast behavior of an iterator cannot be guaranteed
* as it is, generally speaking, impossible to make any hard guarantees in the
* presence of unsynchronized concurrent modification. Fail-fast iterators
* throw {@code ConcurrentModificationException} on a best-effort basis.
* Therefore, it would be wrong to write a program that depended on this
* exception for its correctness: <i>the fail-fast behavior of iterators
* should be used only to detect bugs.</i>
*
* <p>This class is a member of the
* <a href="{@docRoot}/../technotes/guides/collections/index.html" rel="external nofollow" >
* Java Collections Framework</a>.
*
* @author Josh Bloch
* @see List
* @see ArrayList
* @since 1.2
* @param <E> the type of elements held in this collection
*/
2.整体结构
LinkedList封装在Java.util包内，继承于AbstractSequentialList<E>抽象类（抽象类中定义了接口的基本方法，在子类中需要全部实现）
实现的接口有List<E>（List的基本方法）, Deque<E>（队列的方法）, Cloneable（用于对象的复制）, java.io.Serializable（对象序列化，可用以对象的深复制）。
LinkedList继承结构如下：
java.lang.Object
java.util.AbstractCollection<E>
java.util.AbstractList<E>
java.util.AbstractSequentialList<E>
java.util.LinkedList<E>
LinkedList整体包含的整体功能如下：
linkedList维护的是双向链表，双向链表结构图如图所示
可以看出，源码内包含了三个成员变量，size，first，last和serialVersionUID，其中size用以维护链表大小，first和last用以维护链表的头尾节点，serialVersionUID是一个是根据类名、接口名、成员方法及属性等来生成一个64位的哈希字段，用来Java运行时判断类的一致性。
源码包含了三个类，Node类实现链表的节点，ListItr类实现了迭代器接口，在利用迭代器遍历链表的时候使用，DescendingIterator 是降序迭代器，能够返回一个逆序的迭代器列表。
Node类的源码如下：
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;
}
}
可以看出，双向链表的单个节点需要维护两个指针和一个存储的值，prev需要指向前一个变量，如果是首节点则为null，next需要指向后一个变量，如果是尾节点则为null。Node<E>使用了泛型，泛型是Java SE 1.5的新特性，泛型的本质是参数化类型，也就是说所操作的数据类型被指定为一个参数，能够在实现参数“”。
ListItr实现的是ListIterator接口，ListIterator接口继承的是Iterator接口，能够实现向前或向后任意方向遍历的列表迭代器，在迭代过程中可以修改元素（不能够增加删除，增删会导致快速失败“fail-fast”），该接口相当于维护了一个游标，能够获取当前位置，或者指向前一个或者后一个，游标标示的是节点中间的位置（相当于链表的链），因此对于有n个元素的迭代器，游标位置可以有n+1个，下图表示了这种情况。
ListIterator接口的方法API如下所示：
void add(E e) //添加一个元素（可选操作）
boolean hasNext() //检查列表中是否还有下一个元素
boolean hasPrevoius() //检查列表中是否还有上一个元素
E next() //返回游标后的元素，并移动到下一个位置
int nextIndex() //返回游标后一个元素索引
E previous() //返回游标前的元素，并移动到前一个位置
int prevoiusIndex()//返回游标前一个元素索引
void remove() //移除被next()或previous()返回的元素（可选操作）
void set() //修改被next()或previous()返回的元素（可选操作）
ListItr类的源码注释如下：
private class ListItr implements ListIterator<E> {
private Node<E> lastReturned = null; //最后一个返回的节点
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指向的节点被删除了，需要指向下一个节点
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++;
} final void checkForComodification() {
if (modCount != expectedModCount)//检查修改的次数是否一致
throw new ConcurrentModificationException();
}
}
在ListItr中，重要的的功能有从index开始遍历ListItr(index)，移动到下一个元素next()，移动到前一个元素previous()，移除对象remove()，设置set(E e),添加对象add(E e),检查是否改动checkForComodification()等。
对于迭代器，首先需要维护的变量如下
源码如下:
private Node<E> lastReturned = null; //最后一个返回的节点
private Node<E> next;//下一个节点
private int nextIndex;//下一个指针
构造函数ListItr(int index)过程：
可以看出构造函数分为从中间开始和从末尾开始，如果从末尾开始，next要指向null，源码如下:
ListItr(int index) {
// assert isPositionIndex(index);
next = (index == size) ? null : node(index);//判断是否是末尾的位置
nextIndex = index;
}
向后遍历next()函数，其过程如下:
源码如下:
public E next() {
checkForComodification();//首先检查迭代对象是否被修改
if (!hasNext())//检查是否存在下一个节点
throw new NoSuchElementException();
//下面代码表示返回游标后的对象，并将游标后移一位
lastReturned = next;
next = next.next;
nextIndex++;
return lastReturned.item;
}
向前移动previous()过程如下:
源码如下:
public E previous() {
checkForComodification();//检查对象是否被修改
if (!hasPrevious())//检测对象是否存在
throw new NoSuchElementException();
//返回游标前一个节点，并将游标前移一位
lastReturned = next = (next == null) ? last : next.prev;
nextIndex--;
return lastReturned.item;
}
移除对象过程remove()过程如下:
源码如下:
public void remove() {
checkForComodification();//检测对象是否修改
if (lastReturned == null)//检测对象是否存在
throw new IllegalStateException(); Node<E> lastNext = lastReturned.next;//先将移除的代码后的节点信息保留下来
unlink(lastReturned);//移除该节点
if (next == lastReturned)//如果next指向的节点被删除了，需要指向下一个节点
next = lastNext;
else
nextIndex--;
lastReturned = null;//返回节点为空
expectedModCount++;
}
检查对吗通过设置修改变量，如在迭代器中修改会同时改变modCount和expectedModCount，源码如下:
public void remove() {
//省略
unlink(lastReturned);//此处包含modCount++
//省略
expectedModCount++;
}
public void add(E e) {
//省略
if (next == null)
linkLast(e);//此处包含modCount++
else
linkBefore(e, next);//此处包含modCount++
//省略
expectedModCount++;
}
而在LinkedList中的修改只改动了modeCount++，如
/**
* Unlinks non-null last node l.
*/
private E unlinkLast(Node<E> l) {
//省略
modCount++;
return element;
}
而且，在迭代器源码操作函数中都有改动检测代码，判断两个计数变量是否相同
checkForComodification();//检测对象是否修改
if (lastReturned == null)//检测对象是否存在
throw new IllegalStateException();
也就是说，在迭代器操作过程中，如果使用迭代器提供的remove和add方法，可以顺利通过，如果使用LinkedList提供的修改方法，会导致异常的产生，此举是为了保证在多线程环境中对象保持一致性。
第三个类是DescendingIterator implements Iterator<E>，实现逆序的迭代器，因此将next和previos功能反向即可，源码如下：
/**
* Adapter to provide descending iterators via ListItr.previous
*/
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();
}
}
由于在LinedList源码中是由其中主要几个函数实现的，主要的实现结构如下所示，粉色表示构造函数，黄色表示比较简单的函数
首先构造函数，可以看出，构造函数直接将所有节点添加进链表
public LinkedList() {
}
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}
针对较复杂的函数，可以看出，很多函数是分别有几个基本的函数实现的。
unlinkLast函数源码如下:
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;
}
linkBefore函数实现在链表第一个添加元素，源码如下：
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++;
}
同理，linkLast源码如下:
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++;
}
indexOf实现返回某个元素的所在位置，此函数直接从链表头部开始搜索开始就行:
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;
}
addAll函数实现添加所有的节点
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;//从最后位置加入，更新last指针
} else {
pred.next = succ;//将插入后的链表连接起来
succ.prev = pred;
} size += numNew;
modCount++;
return true;
}
node函数实现返回特定位置的节点
Node<E> node(int index) {
// assert isElementIndex(index); if (index < (size >> 1)) {//size>>1相当于/2，判断从链表的前方添加近还是后方添加近
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;
}
}
indexOf和lasIndexOf函数返回从前或从后的位置数目，源码如下:
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;
}
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;
}
unlinkFirst实现断开第一个节点的功能:
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;
}
linkFitst添加头节点，处理好fitst指针即可:
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++;
}
其他的函数较为简单，不做分析
