以下内容基于jdk1.7.0_79源码；
什么是LinkedList
List接口的链表实现，并提供了一些队列，栈，双端队列操作的方法；
LinkedList补充说明
与ArrayList对比，LinkedList插入和删除操作更加高效，随机访问速度慢；
可以作为栈、队列、双端队列数据结构使用；
非同步，线程不安全；
与ArrayList、Vector一样，LinkedList的内部迭代器存在“快速失败行为”；
支持null元素、有顺序、元素可以重复；
LinkedList继承的类以及实现的接口
以上接口和类中，关于Iterable接口、Collection接口、List接口、 Cloneable、 java.io.Serializable接口、AbstractCollection类、AbstractList类的相关说明，在介绍ArrayList的时候，已经有了个大概说明，这里将主要了解下Queue接口、Deque接口、AbstractSequentialList类以及LinkedList类；
Queue接口
队列接口，定义了一些队列的基本操作，
注意使用时优先选择以下蓝色字体方法（offer、poll、peek），队列通常不允许null元素，因为我们通常调用poll方法是否返回null来判断队列是否为空，但是LinkedList是允许null元素的，所以，在使用LinkedList最为队列的实现时，不应该将null元素插入队列；
boolean add(E e);
将对象e插入队列尾部，成功返回true，失败（没有空间）抛出异常IllegalStateException；
boolean offer(E e);
将对象e插入队列尾部，成功返回true，失败（没有空间）返回false；
E remove();
获取并移除队列头部元素，如果队列为空，抛出NoSuchElementException异常；
E poll();
获取并移除队列头部元素，如果队列为空，返回null；
E element();
获取但不移除队列头部元素，如果队列为空，抛出NoSuchElementException异常；
E peek();
获取但不移除队列头部元素，如果队列为空，返回null；
举个简单的例子，基于LinkedList实现的队列，代码如下：
package com.pichen.basis.col;
import java.util.LinkedList;
import java.util.Queue;
public class LinkListTest {
public static void main(String[] args) {
Queue<Integer> linkedListQueue = new LinkedList<Integer>();
//入队
linkedListQueue.offer(3);
linkedListQueue.offer(4);
linkedListQueue.offer(2);
linkedListQueue.offer(1);
//出队
Integer tmp;
while((tmp = linkedListQueue.poll()) != null){
System.out.println(tmp);
}
System.out.println(linkedListQueue.peek());
}
}
Deque接口
双端队列接口，继承队列接口，支持在队列两端进行入队和出队操作；
除了Collection接口Queue接口中定义的方法外，Deque还包括以下方法
void addFirst(E e);
将对象e插入到双端队列头部，容间不足时，抛出IllegalStateException异常；
void addLast(E e);
将对象e插入到双端队列尾部，容间不足时，抛出IllegalStateException异常；
boolean offerFirst(E e);
将对象e插入到双端队列头部
boolean offerLast(E e);
将对象e插入到双端队列尾部；
E removeFirst();
获取并移除队列第一个元素，队列为空，抛出NoSuchElementException异常；
E removeLast();
获取并移除队列最后一个元素，队列为空，抛出NoSuchElementException异常；
E pollFirst();
获取并移除队列第一个元素，队列为空，返回null；
E pollLast();
获取并移除队列最后一个元素，队列为空，返回null；
E getFirst();
获取队列第一个元素，但不移除，队列为空，抛出NoSuchElementException异常；
E getLast();
获取队列最后一个元素，但不移除，队列为空，抛出NoSuchElementException异常；
E peekFirst();
获取队列第一个元素，队列为空，返回null；
E peekLast();
获取队列最后一个元素，队列为空，返回null；
boolean removeFirstOccurrence(Object o);
移除第一个满足 (o==null ? e==null : o.equals(e)) 的元素
boolean removeLastOccurrence(Object o);
移除最后一个满足 (o==null ? e==null : o.equals(e)) 的元素
void push(E e);
将对象e插入到双端队列头部；
E pop();
移除并返回双端队列的第一个元素
Iterator<E> descendingIterator();
双端队列尾部到头部的一个迭代器；
AbstractSequentialList类
一个抽象类，基于迭代器实现数据的随机访问,以下方法的含义, 之前也说过，简单地说，就是数据的随机存取（利用了一个索引index）；
public E get(int index)
public E set(int index, E element)
public void add(int index, E element)
public E remove(int index)
public boolean addAll(int index, Collection<? extends E> c)
LinkedList类
LinkedList的具体实现，
LinkedList中有两个关键成员属性，队头结点和队尾结点：
transient Node<E> first; //队头节点 transient Node<E> last; //队尾节点
LinkedList的节点内部类
具体代码如下，每个节点包含上一个节点的引用、下一个节点的引用以及该节点引用的具体对象；
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;
}
}
至于LinkedList提供的每个方法的含义，在前面队列、双端队列、集合等接口中都有说明了，这里简单的举一两个方法的具体实现，对照源码了解下，其实就是链表的操作：
poll方法,出队操作
public E poll() {
final Node<E> f = first;
return (f == null) ? null : unlinkFirst(f);
}
/**
* Unlinks non-null first node 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;
}
获取并移除双端队列头部元素，如上代码，主要实现在unlinkFirst方法内，首先直接获取被删节点，临时存储其具体引用的对象element和下个引用next，然后将被删节点对象引用和下个节点引用置null给gc回收，改变双端队列队头结点为被删节点的下个引用next，如果next为空，将双端队列的队尾结点last置null，否则将next节点的前引用置null；队列长度减减，操作次数加加（快速失败机制），返回被删节点引用的具体对象；
public E get(int index)方法，随机访问方法
public E get(int index) {
checkElementIndex(index);
return node(index).item;
}
/**
* Returns the (non-null) Node at the specified element index.
*/
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;
}
}
LinkedList随机访问性能较差，首先是判断索引index合法性，然后调用node(int index)方法，在node方法中，做了一点优化，先判断要访问节点的索引是在队列的前半部分还是后半部分，如果在前半部分则从队头开始遍历，否则从队尾开始遍历，如上代码所示。
注意事项
适用场合很重要，注意和ArrayList区分开来，根据集合的各自特点以及具体场景，选择合适的List实现；
这里举个简单例子，分别使用ArrayList和LinkedList，测试下两个集合随机访问的性能，可以发现使用LinkedList随机访问的效率较ArrayList差很多；
package com.pichen.basis.col;
import java.util.ArrayList;
import java.util.Arrays;
import java.util.Iterator;
import java.util.LinkedList;
import java.util.List;
import java.util.ListIterator;
import java.util.Stack;
import java.util.Vector;
public class Test {
public static void main(String[] args) {
//初始化linkedList和arrayList数据
LinkedList<Integer> linkedList = new LinkedList<Integer>();
for(int i = 0; i < 10000; i++){
linkedList.offerLast(i);
}
List<Integer> arrayList = new ArrayList<Integer>();
for(int i = 0; i < 10000; i++){
arrayList.add(i);
}
long s, e;
s = System.currentTimeMillis();
for(int i = 0; i < 10000; i++){
linkedList.get(i);
}
e = System.currentTimeMillis();
System.out.println("linkedList:" + (e - s) + "ms");
s = System.currentTimeMillis();
for(int i = 0; i < 10000; i++){
arrayList.get(i);
}
e = System.currentTimeMillis();
System.out.println("arrayList:" + (e - s) + "ms");
}
}
结果打印：
linkedList:56ms arrayList:1ms