1. 基本用法
LinkedList实现了List、Deque、Queue接口，可以按照队列、栈和双端队列的方式进行操作。LinkedList有两个构造方法，一个是默认构造，另一个接受Collection:
public LinkedList() public LinkedList(Collection<? extends E> c)
可以按照List操作：
List<Integer> list = new LinkedList<>(); List<Integer> list1 = new LinkedList<>(Arrays.asList(2, 3, 4, 5));
LinkedList还实现了队列接口Queue，队列的特点是先进先出，在尾部添加数据，在头部删除数据，其接口定义为：
public interface Queue<E> extends Collection<E> { // 在尾部添加元素 boolean add(E e); // 在尾部添加元素 boolean offer(E e); // 返回头部元素，并且从队列中删除 E remove(); // 返回头部元素，并且从队列中删除 E poll(); // 返回头部元素，但不改变队列 E element(); // 返回头部元素，但不改变队列 E peek(); }
Queue接口扩展了Collection,主要有三种操作，在尾部添加数据（add、offer）、查看头部元素（element、peek）和删除头部元素（remove、poll）。每种操作都有两种形式，区别在于特殊情况的处理不同。特殊情况是指当队列为空或者为满时，为空就是没有元素数据，为满是指队列有长度大小限制，而且已经占满了。LinkedList的实现中，队列长度没有限制，但是其他的Queue的实现可能有。在队列为空时，remove和element会抛出异常NoSuchElementException，而poll和peek返回null；在队列为满时，add会抛出IllegalStateException，而offer只是返回false。
把LinkedList当做Queue使用：
Queue<String> queue = new LinkedList<>(); queue.offer("a"); queue.offer("b"); queue.offer("c"); while (queue.peek() != null) { System.out.println(queue.poll()); }
栈是一种和队列特点相反的数据结构，它的特点是先进后出，后进先出。Java中没有单独的栈接口，栈的相关方法包括在了表示双端队列的接口Deque中，主要有三个方法：
// 入栈 void push(E e); // 出栈 E pop(); // 查看 E peek();
push表示入栈，在头部添加元素，栈的空间可能是有限的，如果栈满了，push会抛出IllegalStateException；pop表示出栈，返回头部元素，并且从栈中删除，如果栈为空会抛出NoSuchElementException；peek查看栈头部元素，不修改栈，如果栈为空，返回特殊值null。使用方法如下：
Deque<Integer> stack = new LinkedList<>(); stack.push(1); stack.push(2); stack.push(3); while (stack.peek() != null) { System.out.println(stack.pop()); } /** * output: * 3 * 2 * 1 */
Java中还有一个Stack类，就是栈的意思，它也实现了栈的一些方法，如push、pop、peek等，但它没有实现Deque接口，他是Vector的子类它增加的这些方法也通过synchronized实现了线程安全。由于Vector和Stack内部使用了大量的syncronized做同步操作，效率比较低，已经过时了，具体就不学习了。
栈和队列都是在两端进行操作，栈只操作头部，队列两端都操作，但只在尾部添加、头部只查看和删除元素。有一个更为通用的操作两端的接口Deque。接口定义如下：
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(); }
根据方法名很容易知道作用，稍微不太清晰的做了注释，descendingIterator()方法示例如下：
Deque<String> deque = new LinkedList<>(Arrays.asList("a", "b", "c", "d")); Iterator<String> it = deque.descendingIterator(); while (it.hasNext()) { System.out.print(it.next() + " "); } /** * output: * d c b a */
下面看下实现原理。
2. 原理
先来看下LinkedList的内部组成，再分析一些主要方法的实现，代码基于JDK8。
2.1内部组成
我们知道，ArrayList内部是数组，元素在内存中是连续存放的，基于索引的访问效率非常高，但LinkedList不是。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; } }
Node类表示节点，item指向实际的元素，next后一个节点，prev指向前一个节点。LinkedList内部组成就是如下三个实例变量：
transient int size = 0; transient Node<E> first; transient Node<E> last;
size表示链表长度，默认为0，first指向头节点，last指向尾节点，初始值都是null。LinkedList的所有public方法内部操作的就是这三个实例变量，来看下具体方法：
2.2 add方法
public boolean add(E e) { linkLast(e); return true; } void linkLast(E e) { // 将尾节点赋给l变量 final Node<E> l = last; // 新建节点，将l赋给新建节点的pre前驱节点，e为当前节点的元素值，新建节点没有后继节点，所以为null final Node<E> newNode = new Node<>(l, e, null); // 将新建节点赋给尾节点 last = newNode; // 如果尾节点不存在，就将新建节点作为头结点赋给first实例变量 if (l == null) first = newNode; // 如若尾节点存在，就将新建节点作为尾节点的后继节点赋给l.next else l.next = newNode; // 链表长度加1 size++; // 修改次数加1 modCount++; }
代码的基本步骤见代码中注释，modCount变量用来记录修改次数，便于在迭代中检测结构性变化。我们根据图示来理解下。比如如下代码：
List<String> list = new LinkedList<String>(); list.add("a"); list.add("b");
当新建list对象后内部结构如图一，头结点和尾节点都是null；当添加“a”后内部结构如图二，size加1，头结点和尾节点都指向同一个Node节点；当添加完“b”后内部结构如图三所示。
2.3 根据索引访问元素
来看下get方法：
public E get(int index) { // 检查索引位置的有效性，若无效，抛出异常 checkElementIndex(index); // 索引有效，执行node方法，查找指定索引位置的元素并返回 return node(index).item; } private void checkElementIndex(int index) { if (!isElementIndex(index)) // 抛出未受检异常，索引越界异常 throw new IndexOutOfBoundsException(outOfBoundsMsg(index)); } private boolean isElementIndex(int index) { return index >= 0 && index < size; } Node<E> node(int index) { // 若索引位置在前半部分，则从头结点开始查找（右移一位相当于除以2），若找到返回节点 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; } }
与ArrayList不同，ArrayList中数组元素连续存放，可以根据索引直接定位，而在LinkedList中，则必须从头到尾顺着连接查找，效率比较低。
2.4 按内容查找元素
看下indexOf的代码：
public int indexOf(Object o) { int index = 0; // 查找元素为null时 if (o == null) { for (Node<E> x = first; x != null; x = x.next) { if (x.item == null) return index; index++; } // 查找元素不为null时 } else { for (Node<E> x = first; x != null; x = x.next) { if (o.equals(x.item)) return index; index++; } } // 买找到指定元素返回-1 return -1; }
代码比较简单，有两种情况，都是从头节点开始找，见代码注释。
2.5 插入元素
add是在尾部添加元素，如果在头部或者中间插入元素可以使用如下重载方法：
public void add(int index, E element) { checkPositionIndex(index); // 这就是在尾部添加元素 if (index == size) linkLast(element); // 主要看这个 else linkBefore(element, node(index)); } void linkBefore(E e, Node<E> succ) { // succ不为空，就把succ的前驱节点赋给pred final Node<E> pred = succ.prev; // 新建节点，将pred指定为新建节点的前驱节点，succ为后继节点 final Node<E> newNode = new Node<>(pred, e, succ); // 将后的前驱指向新建节点 succ.prev = newNode; // 将前驱的后继指向新建节点，若前驱为空，修改头结点指向新节点 if (pred == null) first = newNode; else pred.next = newNode; // 增加长度 size++; modCount++; }
下面通过图示来加深理解，比如添加一个元素
list.add(1, "c");
可以看出，在中间插入元素，LinkedList只需按需分配内存，修改前驱和后继节点的链接，而ArrayList则可能需要分配很多的额外空间，且移动、复制所有后继元素。
2.6 删除元素
再来看看删除元素的代码：
public E remove(int index) { // 同上检查索引是否有效 checkElementIndex(index); // node方法先查找节点，再执行unlink删除指定节点 return unlink(node(index)); } E unlink(Node<E> x) { // x节点不为空,取得节点元素值 final E element = x.item; // 取得前驱节点 final Node<E> next = x.next; // 取得后继节点 final Node<E> prev = x.prev; // 指定前驱的后继为x的后继（不在指向x）,若前驱为空，修改头节点指向x的后继 if (prev == null) { first = next; } else { prev.next = next; x.prev = null; } // 指定后继的前驱为x的前驱（不再指向x）,若后继为空，修改尾节点指向x的前驱 if (next == null) { last = prev; } else { next.prev = prev; x.next = null; } // x节点元素值设为null，便于垃圾回收 x.item = null; // 链表长度减1 size--; // 修改次数加1 modCount++; // 返回删除的节点值 return element; }
分析逻辑见代码注释，基本思路就是让x的前驱和后继直接链接起来，再把x的前驱、后继节点、item都设置为null，便于垃圾回收。下面通过图示加深理解，比如删除一个元素：
list.remove(1);
3. LinkedList特点总结
用法上LinkedList是一个List，有序有重复元素，也实现了Deque接口，可以作为队列、栈和双端队列使用。实现原理上，LinkedList内部是一个双向链表，并维护了长度、头结点和尾节点。有如下特点：
1. 按需分配空间，不需要预先分配很多空间。
2. 不可以随机访问，按照索引位置访问效率比较低，必须从头或尾顺着链接找，效率为O(N/2)。
3. 不管列表是否已排序，只要按照内容查找元素，效率都比较低，必须逐个比较，效率为O(N)。
---------- I love three things in this world. Sun, moon and you. Sun for morning, moon for night , and you forever .