LinkedList简介
LinkedList是基于双向循环链表（从源码中可以很容易看出）实现的，除了可以当做链表来操作外，它还可以当做栈、队列和双端队列来使用。
LinkedList同样是非线程安全的，只在单线程下适合使用。
LinkedList实现了Serializable接口，因此它支持序列化，能够通过序列化传输，实现了Cloneable接口，能被克隆。
LinkedList源码
以下是linkedList源码（加入简单代码注释）：
/*
* @(#)LinkedList.java 1.67 06/04/21
*
* Copyright 2006 Sun Microsystems, Inc. All rights reserved.
* SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*/ package java.util; /**
* @author Josh Bloch
* @version 1.67, 04/21/06
* @see List
* @see ArrayList
* @see Vector
* @since 1.2
* @param <E> the type of elements held in this collection
*/ public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
{
// 链表的表头，表头不包含任何数据。Entry是个链表类数据结构。
private transient Entry<E> header = new Entry<E>(null, null, null);
// LinkedList中元素个数
private transient int size = 0; // 默认构造函数：创建一个空的链表
public LinkedList() {
header.next = header.previous = header;
} // 包含“集合”的构造函数:创建一个包含“集合”的LinkedList
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
} // 获取LinkedList的第一个元素
public E getFirst() {
if (size==0)
throw new NoSuchElementException(); // 由于LinkedList是双向链表；链表的表头header中不包含数据。这里返回header所指下一个节点所包含的数据。
return header.next.element;
} // 获取LinkedList的最后一个元素
public E getLast() {
if (size==0)
throw new NoSuchElementException(); // 由于LinkedList是双向链表；而表头header不包含数据。这里返回表头header的前一个节点所包含的数据。
return header.previous.element;
} // 删除LinkedList的第一个元素
public E removeFirst() {
return remove(header.next);
} // 删除LinkedList最后一个元素
public E removeLast() {
return remove(header.previous);
} // 添加元素到起始位置
public void addFirst(E e) {
addBefore(e, header.next);
} // 添加元素到最后一个位置
public void addLast(E e) {
addBefore(e, header);
} // 是否包含元素o
public boolean contains(Object o) {
return indexOf(o) != -1;
} // LinkedList大小
public int size() {
return size;
} // 将e添加到LinkedList中
public boolean add(E e) {
// 将节点(节点数据是e)添加到表头(header)之前。即双向链表的末端。
addBefore(e, header);
return true;
} // 删除元素o
// 从链表开始查找，如存在元素(o)则删除该元素并返回true；否则，返回false。
public boolean remove(Object o) {
if (o==null) {
for (Entry<E> e = header.next; e != header; e = e.next) {
if (e.element==null) {
remove(e);
return true;
}
}
} else {
for (Entry<E> e = header.next; e != header; e = e.next) {
if (o.equals(e.element)) {
remove(e);
return true;
}
}
}
return false;
} // 将“集合(c)”添加到LinkedList中。
// 实际上，是从双向链表的末尾开始，将“集合(c)”添加到双向链表中。
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
} // 从双向链表的index开始，将“集合(c)”添加到双向链表中。
public boolean addAll(int index, Collection<? extends E> c) {
if (index < 0 || index > size)
throw new IndexOutOfBoundsException("Index: "+index+
", Size: "+size);
Object[] a = c.toArray();
int numNew = a.length;
if (numNew==0)
return false;
modCount++; // 设置“当前要插入节点的后一个节点”
Entry<E> successor = (index==size ? header : entry(index));
// 设置“当前要插入节点的前一个节点”
Entry<E> predecessor = successor.previous;
// 将集合(c)全部插入双向链表中
for (int i=0; i<numNew; i++) {
Entry<E> e = new Entry<E>((E)a[i], successor, predecessor);
predecessor.next = e;
predecessor = e;
}
successor.previous = predecessor; // 调整LinkedList的实际大小
size += numNew;
return true;
} // 清空双向链表
public void clear() {
Entry<E> e = header.next;
// 从表头开始，逐个向后遍历；对遍历到的节点执行一下操作;
// (01) 设置前一个节点为null
// (02) 设置当前节点的内容为null
// (03) 设置后一个节点为“新的当前节点”
while (e != header) {
Entry<E> next = e.next;
e.next = e.previous = null;
e.element = null;
e = next;
}
header.next = header.previous = header;
size = 0;
modCount++;
} // Positional Access Operations // 返回LinkedList指定位置的元素
public E get(int index) {
return entry(index).element;
} // 设置index位置对应的节点的值为element
public E set(int index, E element) {
Entry<E> e = entry(index);
E oldVal = e.element;
e.element = element;
return oldVal;
} // 在index前添加节点，且节点的值为element
public void add(int index, E element) {
addBefore(element, (index==size ? header : entry(index)));
} // 删除index位置的节点
public E remove(int index) {
return remove(entry(index));
} // 获取双向链表中指定位置的节点
private Entry<E> entry(int index) {
if (index < 0 || index >= size)
throw new IndexOutOfBoundsException("Index: "+index+
", Size: "+size);
Entry<E> e = header;
// 获取index处的节点。
// 若index < 双向链表长度的1/2,则从前先后查找;
// 否则，从后向前查找。
// 二分法查找
if (index < (size >> 1)) {
for (int i = 0; i <= index; i++)
e = e.next;
} else {
for (int i = size; i > index; i--)
e = e.previous;
}
return e;
} // Search Operations // 从前向后查找，返回“值为对象(o)的节点对应的索引”
// 不存在就返回-1
public int indexOf(Object o) {
int index = 0;
if (o==null) {
for (Entry e = header.next; e != header; e = e.next) {
if (e.element==null)
return index;
index++;
}
} else {
for (Entry e = header.next; e != header; e = e.next) {
if (o.equals(e.element))
return index;
index++;
}
}
return -1;
} // 从后向前查找，返回“值为对象(o)的节点对应的索引”
// 不存在就返回-1
public int lastIndexOf(Object o) {
int index = size;
if (o==null) {
for (Entry e = header.previous; e != header; e = e.previous) {
index--;
if (e.element==null)
return index;
}
} else {
for (Entry e = header.previous; e != header; e = e.previous) {
index--;
if (o.equals(e.element))
return index;
}
}
return -1;
} // Queue operations. // 返回第一个节点
// 若LinkedList的大小为0,则返回null
public E peek() {
if (size==0)
return null;
return getFirst();
} // 返回第一个节点
// 若LinkedList的大小为0,则抛出异常
public E element() {
return getFirst();
} // 删除并返回第一个节点
// 若LinkedList的大小为0,则返回null
public E poll() {
if (size==0)
return null;
return removeFirst();
} // 删除并返回第一个节点
// 若LinkedList的大小为0,则抛出异常
public E remove() {
return removeFirst();
} // 将e添加双向链表末尾
public boolean offer(E e) {
return add(e);
} // Deque operations
// 将e添加双向链表开头
public boolean offerFirst(E e) {
addFirst(e);
return true;
} // 将e添加双向链表末尾
public boolean offerLast(E e) {
addLast(e);
return true;
} // 返回第一个节点
// 若LinkedList的大小为0,则返回null
public E peekFirst() {
if (size==0)
return null;
return getFirst();
} // 返回最后一个节点
// 若LinkedList的大小为0,则返回null
public E peekLast() {
if (size==0)
return null;
return getLast();
} // 删除并返回第一个节点
// 若LinkedList的大小为0,则返回null
public E pollFirst() {
if (size==0)
return null;
return removeFirst();
} // 删除并返回最后一个节点
// 若LinkedList的大小为0,则返回null
public E pollLast() {
if (size==0)
return null;
return removeLast();
} // 将e插入到双向链表开头
public void push(E e) {
addFirst(e);
} // 删除并返回第一个节点
public E pop() {
return removeFirst();
} // 从LinkedList开始向后查找，删除第一个值为元素(o)的节点
// 从链表开始查找，如存在节点的值为元素(o)的节点，则删除该节点
public boolean removeFirstOccurrence(Object o) {
return remove(o);
} // 从LinkedList末尾向前查找，删除第一个值为元素(o)的节点
public boolean removeLastOccurrence(Object o) {
if (o==null) {
for (Entry<E> e = header.previous; e != header; e = e.previous) {
if (e.element==null) {
remove(e);
return true;
}
}
} else {
for (Entry<E> e = header.previous; e != header; e = e.previous) {
if (o.equals(e.element)) {
remove(e);
return true;
}
}
}
return false;
} // 返回“index到末尾的全部节点”对应的ListIterator对象(List迭代器)
public ListIterator<E> listIterator(int index) {
return new ListItr(index);
} // List迭代器
private class ListItr implements ListIterator<E> {
// 上一次返回的节点
private Entry<E> lastReturned = header;
// 下一个节点
private Entry<E> next;
// 下一个节点对应的索引值
private int nextIndex;
// 期望的改变计数。用来实现fail-fast机制。
private int expectedModCount = modCount; // 构造函数。
// 从index位置开始进行迭代
ListItr(int index) {
// index的有效性处理
if (index < 0 || index > size)
throw new IndexOutOfBoundsException("Index: "+index+
", Size: "+size);
// 若 “index 小于 ‘双向链表长度的一半’”，则从第一个元素开始往后查找；
// 否则，从最后一个元素往前查找。
if (index < (size >> 1)) {
next = header.next;
for (nextIndex=0; nextIndex<index; nextIndex++)
next = next.next;
} else {
next = header;
for (nextIndex=size; nextIndex>index; nextIndex--)
next = next.previous;
}
} // 是否存在下一个元素
public boolean hasNext() {
// 通过元素索引是否等于“双向链表大小”来判断是否达到最后。
return nextIndex != size;
} // 获取下一个元素
public E next() {
checkForComodification();
if (nextIndex == size)
throw new NoSuchElementException(); // next指向链表的下一个元素
lastReturned = next;
next = next.next;
nextIndex++;
return lastReturned.element;
} public boolean hasPrevious() {
return nextIndex != 0;
} // 是否存在上一个元素
public E previous() {
if (nextIndex == 0)
throw new NoSuchElementException(); // next指向链表的上一个元素
lastReturned = next = next.previous;
nextIndex--;
checkForComodification();
return lastReturned.element;
} // 获取下一个元素的索引
public int nextIndex() {
return nextIndex;
} // 获取上一个元素的索引
public int previousIndex() {
return nextIndex-1;
} // 删除当前元素。
// 删除双向链表中的当前节点
public void remove() {
checkForComodification();
Entry<E> lastNext = lastReturned.next;
try {
LinkedList.this.remove(lastReturned);
} catch (NoSuchElementException e) {
throw new IllegalStateException();
}
if (next==lastReturned)
next = lastNext;
else
nextIndex--;
lastReturned = header;
expectedModCount++;
} // 设置当前节点为e
public void set(E e) {
if (lastReturned == header)
throw new IllegalStateException();
checkForComodification();
lastReturned.element = e;
} // 将e添加到当前节点的前面
public void add(E e) {
checkForComodification();
lastReturned = header;
addBefore(e, next);
nextIndex++;
expectedModCount++;
} // 判断 “modCount和expectedModCount是否相等”，依次来实现fail-fast机制。
final void checkForComodification() {
if (modCount != expectedModCount)
throw new ConcurrentModificationException();
}
} // 双向链表的节点所对应的数据结构。
// 包含3部分：上一节点，下一节点，当前节点值。
private static class Entry<E> {
// 当前节点值
E element;
// 下一节点
Entry<E> next;
// 上一节点
Entry<E> previous; /**
* 链表节点的构造函数。
* @param element
* 当前节点值
* @param next
* 下一节点
* @param previous
* 上一节点
*/
Entry(E element, Entry<E> next, Entry<E> previous) {
this.element = element;
this.next = next;
this.previous = previous;
}
} // 将节点(节点数据是e)添加到entry节点之前。
private Entry<E> addBefore(E e, Entry<E> entry) {
// 新建节点newEntry，将newEntry插入到节点e之前；并且设置newEntry的数据是e
Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);
newEntry.previous.next = newEntry;
newEntry.next.previous = newEntry;
// 修改LinkedList大小
size++;
// 修改LinkedList的修改统计数：用来实现fail-fast机制。
modCount++;
return newEntry;
} // 将节点从链表中删除
private E remove(Entry<E> e) {
if (e == header)
throw new NoSuchElementException(); E result = e.element;
e.previous.next = e.next;
e.next.previous = e.previous;
e.next = e.previous = null;
e.element = null;
size--;
modCount++;
return result;
} // 反向迭代器
public Iterator<E> descendingIterator() {
return new DescendingIterator();
} // 反向迭代器实现类。
private class DescendingIterator implements Iterator {
final ListItr itr = new ListItr(size());
// 反向迭代器是否下一个元素。
// 实际上是判断双向链表的当前节点是否达到开头
public boolean hasNext() {
return itr.hasPrevious();
}
// 反向迭代器获取下一个元素。
// 实际上是获取双向链表的前一个节点
public E next() {
return itr.previous();
}
// 删除当前节点
public void remove() {
itr.remove();
}
} // 克隆函数。返回LinkedList的克隆对象。
public Object clone() {
LinkedList<E> clone = null;
// 克隆一个LinkedList克隆对象
try {
clone = (LinkedList<E>) super.clone();
} catch (CloneNotSupportedException e) {
throw new InternalError();
} // 新建LinkedList表头节点
clone.header = new Entry<E>(null, null, null);
clone.header.next = clone.header.previous = clone.header;
clone.size = 0;
clone.modCount = 0; // 将链表中所有节点的数据都添加到克隆对象中
for (Entry<E> e = header.next; e != header; e = e.next)
clone.add(e.element); return clone;
} // 返回LinkedList的Object[]数组
public Object[] toArray() {
Object[] result = new Object[size];
int i = 0;
for (Entry<E> e = header.next; e != header; e = e.next)
result[i++] = e.element;
return result;
} // 返回LinkedList的模板数组。所谓模板数组，即可以将T设为任意的数据类型
public <T> T[] toArray(T[] a) {
// 若数组a的大小 < LinkedList的元素个数(意味着数组a不能容纳LinkedList中全部元素)
// 则新建一个T[]数组，T[]的大小为LinkedList大小，并将该T[]赋值给a。
if (a.length < size)
a = (T[])java.lang.reflect.Array.newInstance(
a.getClass().getComponentType(), size);
int i = 0;
// 将链表中所有节点的数据都添加到数组a中
Object[] result = a;
for (Entry<E> e = header.next; e != header; e = e.next)
result[i++] = e.element; if (a.length > size)
a[size] = null; return a;
} private static final long serialVersionUID = 876323262645176354L; // java.io.Serializable的写入函数
// 将LinkedList的“容量，所有的元素值”都写入到输出流中
private void writeObject(java.io.ObjectOutputStream s)
throws java.io.IOException {
// Write out any hidden serialization magic
s.defaultWriteObject(); // 写入“容量”
s.writeInt(size); // 将链表中所有节点的数据都写入到输出流中
for (Entry e = header.next; e != header; e = e.next)
s.writeObject(e.element);
} // java.io.Serializable的读取函数：根据写入方式反向读出
// 先将LinkedList的“容量”读出，然后将“所有的元素值”读出
private void readObject(java.io.ObjectInputStream s)
throws java.io.IOException, ClassNotFoundException {
// Read in any hidden serialization magic
s.defaultReadObject(); // 从输入流中读取“容量”
int size = s.readInt(); // 新建链表表头节点
header = new Entry<E>(null, null, null);
header.next = header.previous = header; // 从输入流中将“所有的元素值”并逐个添加到链表中
for (int i=0; i<size; i++)
addBefore((E)s.readObject(), header);
}
}
LinkedList详细分析
一、什么是链表
链表是由一系列非连续的节点组成的存储结构，简单分下类的话，链表又分为单向链表和双向链表，而单向/双向链表又可以分为循环链表和非循环链表，下面简单就这四种链表进行图解说明。
1.单向链表
单向链表就是通过每个结点的指针指向下一个结点从而链接起来的结构，最后一个节点的next指向null。
2.单向循环链表
单向循环链表和单向列表的不同是，最后一个节点的next不是指向null，而是指向head节点，形成一个“环”。
3.双向链表
从名字就可以看出，双向链表是包含两个指针的，pre指向前一个节点，next指向后一个节点，但是第一个节点head的pre指向null，最后一个节点的tail指向null。
4.双向循环链表
双向循环链表和双向链表的不同在于，第一个节点的pre指向最后一个节点，最后一个节点的next指向第一个节点，也形成一个“环”。而LinkedList就是基于双向循环链表设计的。
二、定义
看一下LinkedList的定义部分：
public class LinkedList<E>
extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable
可以看出LinkedList 继承AbstractSequentialList 抽象类，实现了List，Deque，Cloneable，Serializable 几个接口，AbstractSequentialList 继承 AbstractList，是对其中方法的再抽象，其主要作用是最大限度地减少了实现受“连续访问”数据存储（如链接列表）支持的此接口所需的工作，简单说就是，如果需要快速的添加删除数据等，用AbstractSequentialList抽象类，若是需要快速随机的访问数据等用AbstractList抽象类。
Deque 是一个双向队列，也就是既可以先入先出，又可以先入后出，再直白一点就是既可以在头部添加元素又在尾部添加元素，既可以在头部获取元素又可以在尾部获取元素。看下Deque的源码（已删除注释）：
/*
* @(#)Deque.java 1.5 06/04/21
*
* Copyright 2006 Sun Microsystems, Inc. All rights reserved.
* SUN PROPRIETARY/CONFIDENTIAL. Use is subject to license terms.
*/ package java.util; /**
* @author Doug Lea
* @author Josh Bloch
* @since 1.6
* @param <E> the type of elements held in this collection
*/ public interface Deque<E> extends Queue<E> {
void addFirst(E e);
void addLast(E e);
boolean offerFirst(E e);
boolean offerLast(E e);
E removeFirst();
E removeLast();
E pollFirst();
E pollLast();
E getFirst();
E getLast();
E peekFirst();
E peekLast();
boolean removeFirstOccurrence(Object o);
boolean removeLastOccurrence(Object o);
boolean add(E e);
boolean offer(E e);
E remove();
E poll();
E element();
E peek();
void push(E e);
E pop();
boolean remove(Object o);
boolean contains(Object o);
public int size();
Iterator<E> iterator();
Iterator<E> descendingIterator();
}
三、内部类
LinkedList总共有三个内部类，ListItr，Entry<E>和DescendingIterator，这三个内部类分别实现了List迭代器，双向链表的节点所对应的数据结构和反向迭代器。
3.1内部类ListItr
源码在上面的代码中已经给出，这里不再给出，分析一下
3.1.1构造函数
ListItr(int index) {
if (index < 0 || index > size)
throw new IndexOutOfBoundsException("Index: "+index+
", Size: "+size);
if (index < (size >> 1)) {
next = header.next;
for (nextIndex=0; nextIndex<index; nextIndex++)
next = next.next;
} else {
next = header;
for (nextIndex=size; nextIndex>index; nextIndex--)
next = next.previous;
}
}
在这里，这个构造函数只做了一件事情，就是加速查找，重点是这句话if (index < 0 || index > size)如果给出的index索引小于双向链表长度的一半，则从头向后查找，如果大于，则从尾向前查找。
3.1.2成员变量
这个内部类当中的其他方法这里就不介绍了，set()，get()，add()等等这些方法，在最开始的注释代码中写的很清晰了，这里说其中的一个成员变量private int expectedModCount = modCount;
首先来看一下这个modCount是个什么东西：它是LinkedList继承的父类的父类AbstractList<E>中的一个成员变量protected transient int modCount = 0;它是用来记录AbstractList结构性变化的次数。
在AbstractList的所有涉及结构变化的方法中都增加modCount的值，包括：add()、remove()、addAll()、removeRange()及clear()方法。这些方法每调用一次，modCount的值就加1。
而在这里ListItr自己同时维护了一个expectedModCount，初始值是取的modCount，而当ListItr结构性变化的时候expectedModCount也会自动修改，包括next()，previous()，remove()，add(E e)等方法，而同样在这些方法里面的第一步都会去调用checkForComodification()这个方法进行修改的同步检查，如果不同步将会抛出ConcurrentModificationException()这个异常。
3.2内部类Entry<E>
3.2.1构造方法
Entry(E element, Entry<E> next, Entry<E> previous) {
this.element = element;
this.next = next;
this.previous = previous;
}
}
这个构造函数使用到了三个参数，分别是当前节点值，下一节点和上一节点。
3.2.2addBefore(E e, Entry<E> entry)
在这个内部类中，实现了将将节点e添加到entry节点之前的这个方法，这个方法在LinkedList所有添加操作相关的方法中都调用了，源码：
private Entry<E> addBefore(E e, Entry<E> entry) {
Entry<E> newEntry = new Entry<E>(e, entry, entry.previous);
newEntry.previous.next = newEntry;
newEntry.next.previous = newEntry;
size++;
modCount++;
return newEntry;
}
在这个方法一开始的地方就new了一个新的Entry对象出来，经典的双向列表固定位置添加新节点，并且更新前驱结点的next域和后驱结点的previous域，并且将记录操作数的modCount自增1。
3.3内部类DescendingIterator
反向迭代器实现类，这个类比较简单，直接调用的ListItr的方法，在此不再赘述。
四、增加
/**
* Appends the specified element to the end of this list.
*
* <p>This method is equivalent to {@link #addLast}.
*
* @param e element to be appended to this list
* @return <tt>true</tt> (as specified by {@link Collection#add})
*/
public boolean add(E e) {
addBefore(e, header);
return true;
}
/**
* Inserts the specified element at the specified position in this list.
* Shifts the element currently at that position (if any) and any
* subsequent elements to the right (adds one to their indices).
*
* @param index index at which the specified element is to be inserted
* @param element element to be inserted
* @throws IndexOutOfBoundsException {@inheritDoc}
*/
public void add(int index, E element) {
addBefore(element, (index==size ? header : entry(index)));
}
第一个add在尾部增加元素比较好理解：在header前添加元素e，header前就是最后一个结点，就是在最后一个结点的后面添加元素e；而第二个增加就不是那么简单了，同样都是调用Entry的addBefore方法，第二个方法增加了一句判断条件index==size ? header : entry(index)，这个条件实际上的意思就是如果index等于list元素个数，则在队尾添加元素(header之前)，否则在index节点前添加元素。
到这里可以发现一点，header作为双向循环链表的头结点是不保存数据的，也就是说hedaer中的element永远等于null。
/**
* Appends all of the elements in the specified collection to the end of
* this list, in the order that they are returned by the specified
* collection's iterator. The behavior of this operation is undefined if
* the specified collection is modified while the operation is in
* progress. (Note that this will occur if the specified collection is
* this list, and it's nonempty.)
*
* @param c collection containing elements to be added to this list
* @return <tt>true</tt> if this list changed as a result of the call
* @throws NullPointerException if the specified collection is null
*/
public boolean addAll(Collection<? extends E> c) {
return addAll(size, c);
} /**
* Inserts all of the elements in the specified collection into this
* list, starting at the specified position. Shifts the element
* currently at that position (if any) and any subsequent elements to
* the right (increases their indices). The new elements will appear
* in the list in the order that they are returned by the
* specified collection's iterator.
*
* @param index index at which to insert the first element
* from the specified collection
* @param c collection containing elements to be added to this list
* @return <tt>true</tt> if this list changed as a result of the call
* @throws IndexOutOfBoundsException {@inheritDoc}
* @throws NullPointerException if the specified collection is null
*/
public boolean addAll(int index, Collection<? extends E> c) {
if (index < 0 || index > size)
throw new IndexOutOfBoundsException("Index: "+index+
", Size: "+size);
Object[] a = c.toArray();
int numNew = a.length;
if (numNew==0)
return false;
modCount++; Entry<E> successor = (index==size ? header : entry(index));
Entry<E> predecessor = successor.previous;
for (int i=0; i<numNew; i++) {
Entry<E> e = new Entry<E>((E)a[i], successor, predecessor);
predecessor.next = e;
predecessor = e;
}
successor.previous = predecessor; size += numNew;
return true;
}
第一个addAll方法是调用了第二个，仔细研究一下第二个addAll的方法，首先第一句话是越界检查，第二局判断是对添加的Collection做非0校验，Entry<E> successor = (index==size ? header : entry(index));这句话的含义是：获取要插入index位置的下一个节点，如果index正好是lsit尾部的位置那么下一个节点就是header，否则需要查找index位置的节点，而Entry<E> predecessor = successor.previous;这句话的含义是：获取要插入index位置的上一个节点，因为是插入，所以上一个点击就是未插入前下一个节点的上一个。
五、删除、修改、查询
5.1删除
private E remove(Entry<E> e) {
if (e == header)
throw new NoSuchElementException();
E result = e.element;
e.previous.next = e.next;
e.next.previous = e.previous;
e.next = e.previous = null;
e.element = null;
size--;
modCount++;
return result;
}
在这里删除本质上的意思就是前一节点和后一节点组合在一起就好了，互相修改一下前驱结点和后置节点
5.2修改
/**
* Replaces the element at the specified position in this list with the
* specified element.
*
* @param index index of the element to replace
* @param element element to be stored at the specified position
* @return the element previously at the specified position
* @throws IndexOutOfBoundsException {@inheritDoc}
*/
public E set(int index, E element) {
Entry<E> e = entry(index);
E oldVal = e.element;
e.element = element;
return oldVal;
}
set方法看起来简单了很多，只要修改该节点上的元素就好了。
5.3查找
/**
* Returns the indexed entry.
*/
private Entry<E> entry(int index) {
if (index < 0 || index >= size)
throw new IndexOutOfBoundsException("Index: "+index+
", Size: "+size);
Entry<E> e = header;
if (index < (size >> 1)) {
for (int i = 0; i <= index; i++)
e = e.next;
} else {
for (int i = size; i > index; i--)
e = e.previous;
}
return e;
}
LinkedList是通过从header开始index计为0，然后一直往下遍历（next），直到到底index位置。为了优化查询效率，LinkedList采用了二分查找（这里说的二分只是简单的一次二分），判断index与size中间位置的距离，采取从header向后还是向前查找。
基于双向循环链表实现的LinkedList，通过索引Index的操作时低效的，index所对应的元素越靠近中间所费时间越长。而向链表两端插入和删除元素则是非常高效的（如果不是两端的话，都需要对链表进行遍历查找）。
六、是否包含
/**
* Returns <tt>true</tt> if this list contains the specified element.
* More formally, returns <tt>true</tt> if and only if this list contains
* at least one element <tt>e</tt> such that
* <tt>(o==null ? e==null : o.equals(e))</tt>.
*
* @param o element whose presence in this list is to be tested
* @return <tt> true</tt> if this list contains the specified element
*/
public boolean contains(Object o) {
return indexOf(o) != -1;
} /**
* Returns the index of the first occurrence of the specified element
* in this list, or -1 if this list does not contain the element.
* More formally, returns the lowest index <tt>i</tt> such that
* <tt>(o==null ? get(i)==null : o.equals(get(i)))</tt>,
* or -1 if there is no such index.
*
* @param o element to search for
* @return the index of the first occurrence of the specified element in
* this list, or -1 if this list does not contain the element
*/
public int indexOf(Object o) {
int index = 0;
if (o==null) {
for (Entry e = header .next; e != header; e = e.next ) {
if (e.element ==null)
return index;
index++;
}
} else {
for (Entry e = header .next; e != header; e = e.next ) {
if (o.equals(e.element ))
return index;
index++;
}
}
return -1;
} /**
* Returns the index of the last occurrence of the specified element
* in this list, or -1 if this list does not contain the element.
* More formally, returns the highest index <tt>i</tt> such that
* <tt>(o==null ? get(i)==null : o.equals(get(i)))</tt>,
* or -1 if there is no such index.
*
* @param o element to search for
* @return the index of the last occurrence of the specified element in
* this list, or -1 if this list does not contain the element
*/
public int lastIndexOf(Object o) {
int index = size ;
if (o==null) {
for (Entry e = header .previous; e != header; e = e.previous ) {
index--;
if (e.element ==null)
return index;
}
} else {
for (Entry e = header .previous; e != header; e = e.previous ) {
index--;
if (o.equals(e.element ))
return index;
}
}
return -1;
}
indexOf查询元素位于容器的索引位置，都是需要对链表进行遍历操作，也都是低效的操作，慎用。
七、LinkedList实现的双端队列
/**
* Retrieves, but does not remove, the head (first element) of this list.
* @return the head of this list, or <tt>null</tt> if this list is empty
* @since 1.5
*/
public E peek() {
if (size==0)
return null;
return getFirst();
} /**
* Retrieves, but does not remove, the head (first element) of this list.
* @return the head of this list
* @throws NoSuchElementException if this list is empty
* @since 1.5
*/
public E element() {
return getFirst();
} /**
* Retrieves and removes the head (first element) of this list
* @return the head of this list, or <tt>null</tt> if this list is empty
* @since 1.5
*/
public E poll() {
if (size==0)
return null;
return removeFirst();
} /**
* Retrieves and removes the head (first element) of this list.
*
* @return the head of this list
* @throws NoSuchElementException if this list is empty
* @since 1.5
*/
public E remove() {
return removeFirst();
} /**
* Adds the specified element as the tail (last element) of this list.
*
* @param e the element to add
* @return <tt>true</tt> (as specified by {@link Queue#offer})
* @since 1.5
*/
public boolean offer(E e) {
return add(e);
} // Deque operations
/**
* Inserts the specified element at the front of this list.
*
* @param e the element to insert
* @return <tt>true</tt> (as specified by {@link Deque#offerFirst})
* @since 1.6
*/
public boolean offerFirst(E e) {
addFirst(e);
return true;
} /**
* Inserts the specified element at the end of this list.
*
* @param e the element to insert
* @return <tt>true</tt> (as specified by {@link Deque#offerLast})
* @since 1.6
*/
public boolean offerLast(E e) {
addLast(e);
return true;
} /**
* Retrieves, but does not remove, the first element of this list,
* or returns <tt>null</tt> if this list is empty.
*
* @return the first element of this list, or <tt>null</tt>
* if this list is empty
* @since 1.6
*/
public E peekFirst() {
if (size==0)
return null;
return getFirst();
} /**
* Retrieves, but does not remove, the last element of this list,
* or returns <tt>null</tt> if this list is empty.
*
* @return the last element of this list, or <tt>null</tt>
* if this list is empty
* @since 1.6
*/
public E peekLast() {
if (size==0)
return null;
return getLast();
} /**
* Retrieves and removes the first element of this list,
* or returns <tt>null</tt> if this list is empty.
*
* @return the first element of this list, or <tt>null</tt> if
* this list is empty
* @since 1.6
*/
public E pollFirst() {
if (size==0)
return null;
return removeFirst();
} /**
* Retrieves and removes the last element of this list,
* or returns <tt>null</tt> if this list is empty.
*
* @return the last element of this list, or <tt>null</tt> if
* this list is empty
* @since 1.6
*/
public E pollLast() {
if (size==0)
return null;
return removeLast();
} /**
* Pushes an element onto the stack represented by this list. In other
* words, inserts the element at the front of this list.
*
* <p>This method is equivalent to {@link #addFirst}.
*
* @param e the element to push
* @since 1.6
*/
public void push(E e) {
addFirst(e);
} /**
* Pops an element from the stack represented by this list. In other
* words, removes and returns the first element of this list.
*
* <p>This method is equivalent to {@link #removeFirst()}.
*
* @return the element at the front of this list (which is the top
* of the stack represented by this list)
* @throws NoSuchElementException if this list is empty
* @since 1.6
*/
public E pop() {
return removeFirst();
}
很简单，逻辑都是基于上面讲的链表操作的。
八、总结
8.1从源码中很明显可以看出，LinkedList的实现是基于双向循环链表的，且头结点中不存放数据
8.2注意两个不同的构造方法。无参构造方法直接建立一个仅包含head节点的空链表，包含Collection的构造方法，先调用无参构造方法建立一个空链表，而后将Collection中的数据加入到链表的尾部后面。
8.3在查找和删除某元素时，源码中都划分为该元素为null和不为null两种情况来处理，LinkedList中允许元素为null。
8.4LinkedList是基于链表实现的，因此不存在容量不足的问题，所以这里没有扩容的方法。
8.5注意源码中的Entry<E> entry(int index)方法。该方法返回双向链表中指定位置处的节点，而链表中是没有下标索引的，要指定位置出的元素，就要遍历该链表，从源码的实现中，我们看到这里有一个加速动作。源码中先将index与长度size的一半比较，如果index<size/2，就只从位置0往后遍历到位置index处，而如果index>size/2，就只从位置size往前遍历到位置index处。这样可以减少一部分不必要的遍历，从而提高一定的效率（实际上效率还是很低）。
8.6注意链表类对应的数据结构Entry。
8.7LinkedList是基于链表实现的，因此插入删除效率高，查找效率低（虽然有一个加速动作）。
8.8要注意源码中还实现了栈和队列的操作方法，因此也可以作为栈、队列和双端队列来使用。
————————————————————————————————————————————————————
参考资料：