双向链表LinkedList
LinkedList的定义
public class LinkedList<E> extends AbstractSequentialList<E>
implements List<E>, Deque<E>, Cloneable, java.io.Serializable{}
public class ArrayList<E> extends AbstractList<E>
implements List<E>, RandomAccess, Cloneable, java.io.Serializable{}LinkedList与ArrayList对比发现：
- 它们继承的基类不同，LinkedList继承自AbstractSequentialList基类，AbstractSequentialList是AbstractList子类，这个类后面再说。
- LinkedList实现了Deque接口，代表它是一个队列，准确地说它是一个双端队列。
- LinkedList没有实现RandomAccess可随机访问标记接口，表示使用LinkedList的get(int index)获取集合中元素的方法效率非常低。
Queue队列接口
队列是一种FIFO(先入先出)的数据结构，和它相对应的是一种叫做栈(LIFO后入先出)的数据结构。
对于栈来说，我们想一想它应该有哪些方法?
- void push(E e); 向栈顶添加元素。
- E pop(); 移除栈顶元素，并返回它。
- E peek(); 查看栈顶元素。
- boolean isEmpty(); 栈是不是为空。
- int size(); 栈中元素的数量。
要实现一个栈，实现这5个方法就可以了。
队列与栈的方法应该差不多，只不过每次添加的时候，都是向队列尾新添元素，而不是队列头。
- boolean offer(E e); 向队列尾添加元素。
- E poll();移除队列头元素，并返回它。
- E peek(); 查看队列头元素。
- boolean isEmpty(); 队列是不是为空。
- int size(); 队列中元素的数量。
public interface Queue<E> extends Collection<E> {
// 向队列末尾新添加元素,返回true表示添加成功
// 不会返回false，因为添加失败直接抛出IllegalStateException异常。
// 一般调用offer方法实现。
boolean add(E e);
// 向队列末尾新添加元素，返回true表示添加成功，返回false，添加失败
boolean offer(E e);
// 这个与Collection中的remove方法不一样，因为Collection中的remove方法都要提供一个元素或者集合，用于删除。
// 这里不穿任何参数，就是代表删除队列第一个元素(即队列头)，并返回它
// 还需要注意的时，如果队列是空的，即队列头是null，这个方法会抛出NoSuchElementException异常。
E remove();
// 这个方法也是删除队列第一个元素(即队列头)，并返回它
// 但是它和remove()方法不同的时，如果队列是空的，即队列头是null，它不会抛出异常，而是会返回null。
E poll();
// 查看队列头的元素，如果队列是空的，就抛出异常
E element();
// 查看队列头的元素。如果队列是空的，不会抛出异常，而是返回null
E peek();
}可以看出继承自Collection接口，那么size()和isEmpty()方法都由Collection接口提供，但是Queue接口还提供了三个好像重复的方法。
- 向队列尾添加元素的方法：add(E e)与offer(E e)。区别就是队列是满的，添加失败时，add方法会抛出异常，而offer方法只会返回false。
- 移除队列头元素的方法：remove()与poll()。区别就是队列为空的时候，remove方法会抛出异常，poll方法只会返回null。
- 查看队列头元素的方法：element()与peek()。区别就是队列为空的时候，element方法会抛出异常，peek方法只会返回null。
下面是AbstractQueue中的实现：
public abstract class AbstractQueue<E>
extends AbstractCollection<E>
implements Queue<E> {
protected AbstractQueue() {
}
// 直接调用offer方法来实现，如果队列是满的，添加失败，
// 则抛出IllegalStateException异常
public boolean add(E e) {
if (offer(e))
return true;
else
throw new IllegalStateException("Queue full");
}
// 直接调用poll方法来实现，如果队列是空的，移除元素失败，
// 则抛出NoSuchElementException异常
public E remove() {
E x = poll();
if (x != null)
return x;
else
throw new NoSuchElementException();
}
// 直接调用peek方法来实现，如果队列是空的,查看元素失败，
// 则抛出NoSuchElementException异常
public E element() {
E x = peek();
if (x != null)
return x;
else
throw new NoSuchElementException();
}
......
}双端队列
它与普通队列相比较，它既可以在队列头添加元素，也可以在队列尾添加元素；既可以在队列头删除元素，也可以在队列尾删除元素。
注意一下，因为双端队列特性，所以它很容易实现一个栈，也就是说它本身可以当做栈使用。
根据双端队列的特性，它比普通队列应该多了三个方法。
- boolean offerFirst(E e); 向队列头添加元素。
- boolean offerLast(E e); 向队列尾添加元素。
- E pollFirst();移除队列头元素，并返回它。
- E pollLast();移除队列尾元素，并返回它。
- E peekFirst(); 查看队列头元素。
- E peekLast(); 查看队列尾元素。
- boolean isEmpty(); 队列是不是为空。
- int size(); 队列中元素的数量。
public interface Deque<E> extends Queue<E> {
// 向队列头添加元素
void addFirst(E e);
// 向队列末尾新添加元素
void addLast(E e);
// 向队列头添加元素,和addFirst(E e)作用一样，就是直接调用addFirst(E e)方法来实现。
boolean offerFirst(E e);
// 向队列末尾新添加元素，和addLast(E e)作用一样，就是直接调用addLast(E e)方法来实现。
boolean offerLast(E e);
// 删除队列第一个元素(即队列头)，并返回它, 如果队列是空的,这个方法会抛出NoSuchElementException异常。
// 注，与Queue接口中remove()作用一样，remove()方法就是调用removeFirst()方法来实现的
E removeFirst();
// 删除队列最后一个元素(即队列尾)，并返回它, 如果队列是空的,这个方法会抛出NoSuchElementException异常。
E removeLast();
// 删除队列第一个元素(即队列头)，并返回它, 如果队列是空的,它不会抛出异常，而是会返回null。
// 注，与Queue接口中poll()作用一样，
E pollFirst();
// 删除队列最后一个元素(即队列尾)，并返回它, 如果队列是空的,它不会抛出异常，而是会返回null。
E pollLast();
// 查看队列头的元素，如果队列是空的，就抛出异常
// 注，与Queue接口中element()作用一样，
E getFirst();
// 查看队列尾的元素，如果队列是空的，就抛出异常
E getLast();
// 查看队列头的元素。如果队列是空的，不会抛出异常，而是返回null
E peekFirst();
// 查看队列尾的元素。如果队列是空的，不会抛出异常，而是返回null
E peekLast();
// 从队列头都开始遍历，找到与o相等的第一个元素删除它，并返回true，如果没找到就返回false，最多只删除一个元素
// 注，与Collection中remove(Object o)方法作用一样
boolean removeFirstOccurrence(Object o);
// 从队列尾都开始遍历，找到与o相等的第一个元素删除它，并返回true，如果没找到就返回false，最多只删除一个元素
boolean removeLastOccurrence(Object o);
// *** Queue methods ***
boolean add(E e);
boolean offer(E e);
E remove();
E poll();
E element();
E peek();
// *** Stack methods ***
// 向栈顶添加元素。与addFirst(E e)方法作用一样
void push(E e);
// 移除栈顶元素，并返回它。如果栈为空的话，会抛出NoSuchElementException异常
// 注，与removeFirst()方法一样
E pop();
// *** Collection methods ***
boolean remove(Object o);
boolean contains(Object o);
public int size();
Iterator<E> iterator();
Iterator<E> descendingIterator();
}可以看出定义的接口中的方法比我们预计的多得多，主要是添加了一些队列为空时，获取元素会抛出异常的方法，还顺便定义了栈的方法，因为双端队列很容易实现一个栈的功能。
双端队列Deque与普通队列Queue相比较，就是多了从队列头插入，从队列尾删除，从队列尾查看的功能。
抽象类AbstractSequentialList
AbstractSequentialList这个类表示它的子类是使用链表这种数据结构来存储集合元素的，而不是使用数组这种数据结构。这有什么不同呢？
- 数组的插入和删除的效率都不高，因为可能涉及到数组元素的移动。但是访问效率非常高，它支持随机访问，就是通过数组的下标直接获取对应的元素。
- 链表的插入和删除的效率都很高，因为只需要改变元素之间指向就可以了。但是访问效率不高，它不支持随机访问，必须从链表头或者链表尾开始一次访问。
还记得我们在AbstractList方法中，怎么实现迭代器的么？使用一个cursor属性来记录索引位置，然后通过调用List集合的get(int index)来获取对应的元素。这里就不行了，因为通过get(int index)方法获取集合元素的效率非常低。而遍历链表的方式就是获取链表中一个元素，然后通过指向下一个元素的引用，不断获取下一个元素，直到为空，表示已经到了链表尾，而不是通过索引的方式。
所以我们思考一下AbstractSequentialList会做哪些事情。
- 将获取迭代器的方法设置成abstract抽象方法，强制子类提供迭代器方法，因为不能用索引这种低效率的方式获取元素，所以强制子类去实现。
// 调用listIterator方法，返回一个迭代器
public Iterator<E> iterator() {
return listIterator();
}
// 子类必须复写这个方法，提供一个ListIterator迭代器。
public abstract ListIterator<E> listIterator(int index);- List集合可以通过索引得到集合中的元素，AbstractSequentialList集合也必须支持这种方式，虽然效率低。这时就可以通过ListIterator迭代器实现对应方法。
这里就与AbstractList中内部迭代器ListIterator类不同，AbstractList中迭代器是通过调用AbstractList中get(int index)和set(int index, E element)方法来实现对应功能的，所以AbstractList子类必须复写这些方法。而AbstractSequentialList是通过迭代器来实现本AbstractSequentialList对应方法，所以子类必须实现一个自定义迭代器。
public abstract class AbstractSequentialList<E> extends AbstractList<E> {
protected AbstractSequentialList() {
}
// 调用迭代器listIterator获取
public E get(int index) {
try {
// 迭代器会先根据index值，从链表头开始遍历，直到移动到index位置，将元素返回，所以效率不高。
return listIterator(index).next();
} catch (NoSuchElementException exc) {
throw new IndexOutOfBoundsException("Index: "+index);
}
}
// 调用迭代器listIterator的set设置
public E set(int index, E element) {
try {
ListIterator<E> e = listIterator(index);
E oldVal = e.next();
e.set(element);
return oldVal;
} catch (NoSuchElementException exc) {
throw new IndexOutOfBoundsException("Index: "+index);
}
}
// 调用迭代器listIterator的add方法添加元素
public void add(int index, E element) {
try {
listIterator(index).add(element);
} catch (NoSuchElementException exc) {
throw new IndexOutOfBoundsException("Index: "+index);
}
}
// 调用迭代器listIterator的remove方法移除元素
public E remove(int index) {
try {
ListIterator<E> e = listIterator(index);
E outCast = e.next();
e.remove();
return outCast;
} catch (NoSuchElementException exc) {
throw new IndexOutOfBoundsException("Index: "+index);
}
}
// Bulk Operations
public boolean addAll(int index, Collection<? extends E> c) {
try {
boolean modified = false;
ListIterator<E> e1 = listIterator(index);
Iterator<? extends E> e2 = c.iterator();
while (e2.hasNext()) {
e1.add(e2.next());
modified = true;
}
return modified;
} catch (NoSuchElementException exc) {
throw new IndexOutOfBoundsException("Index: "+index);
}
}
// 会调用listIterator方法，返回一个迭代器
public Iterator<E> iterator() {
return listIterator();
}
// 子类必须复写这个方法，提供一个ListIterator迭代器。
public abstract ListIterator<E> listIterator(int index);
}单向链表和双向链表
单向链表
简单的说，元素除了包含本身的数据item，还有一个指向下一个元素的引用next。数据结构就像这样：
class Node<E> {
E item;
Node<E> next;
Node( E element, Node<E> next) {
this.item = element;
this.next = next;
}
}然后我们在看看单向链表插入和删除。
1、插入：单向链表的插入，我们只需要改变两个引用就可以了。
private void insert(Node<E> prevNode, Node<E> node, Node<E> newNode) {
// prevNode表示插入点前一个元素
// node表示插入点元素
// newNode表示要添加的元素，将它放入插入点(即前一个元素的next指向)
// 并将newNode的next指向原来元素node
if (prevNode != null) prevNode.next = newNode;
newNode.next = node;
}在链表node元素前添加一个元素，就是将node元素前一个元素的next指向新元素newNode，再将新元素newNode的next指向node元素，这样就把新元素newNode插入到链表中了。
注意要做一下前元素非空判断，如果前元素为空表示插入点是链表头。
根据我的经验，先不考虑null的情况，改变对应引用，这里就是prevNode.next = newNode，newNode.next = node。然后我们再看看那些需要考虑null的情况。
比如这里prevNode就需要考虑null情况，否则会发生空指针异常。prevNode为空其实表示在链表头。newNode是不允许为空。而node是不是为空对我们程序没有任何影响。
2、删除：单向链表的删除，也只需要改变两个引用就可以了。
private void delete(Node<E> prevNode, Node<E> node) {
// prevNode表示被删除元素的前一个元素
// node表示被删除的元素
if (prevNode != null) prevNode.next = node.next;
node.next = null;
}删除一个单向链表元素，就是将它的前一个元素的next指向它的next，这样就在整个链表中查找不到这个元素了，然后将它的next设置为null。
当前一个元素为null，表示被删除元素是链表头，那么需要将表头的next指向被删除元素的next，这里没有体现。
双向链表
与单向链表相比，它的元素多了一个指向上一个元素的引用prev。数据结构就像这样：
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;
}
}然后我们再看看双向链表插入和删除。
1、插入：双向链表的插入，我们需要改变四个引用。
private void insert(Node<E> node, Node<E> newNode) {
// node表示插入点元素
// newNode表示要添加的元素，将它插入到node元素之前
// 将node前一个元素的next指向新元素newNode
if(node.prev != null) node.prev.next = newNode;
// 将新元素newNode的prev指向node前一个元素
newNode.prev = node.prev;
// 将node的prev指向新元素newNode，现在node的前一个元素变成新元素newNode
node.prev = newNode;
// 将新元素的next指向node，所以新元素的下一个元素是node
newNode.next = node;
}要在元素node前插入一个新元素newNode。那么就需要四步：
- 将node前一个元素的next指向新元素newNode
- 将新元素newNode的prev指向node前一个元素
- node元素的prev指向新元素
- 新元素newNode的next指向node
2、删除：双向链表的删除，也需要改变四个引用。
private void delete(Node<E> node) {
// node表示要删除的元素
// 将node前一个元素的next指向node下一个元素
if (node.prev != null) node.prev.next = node.next;
// 将node下一个元素的pre指向node前一个元素
if (node.next != null) node.next.prev = node.prev;
// 将node的prev和next都置位null
node.prev = null;
node.next = null;
}注意只考虑本节点元素情况，没有考虑链表头的赋值。
LinkedList 类
成员属性
// 集合数量
transient int size = 0;
// 双向链表的表头
transient Node<E> first;
// 双向链表的表尾
transient Node<E> last;
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;
}
}通过一个双向链表来记录集合中的元素。
构造函数
public LinkedList() {
}
public LinkedList(Collection<? extends E> c) {
this();
addAll(c);
}LinkedList的构造函数比较简单，因为它不用像ArrayList那样，要确定初始数组的长度。
添加元素
public boolean add(E e) {
linkLast(e);
return true;
}
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++;
}向链表尾添加一个新元素newNode,要进行以下几个步骤：
- 将链表尾last赋值给变量l，因为表尾last要指向新元素newNode
- 创建新元素newNode，根据Node的构造函数，我们知道新元素newNode的prev指向l(即表尾)，next还是为null。
- 将表尾last指向新元素newNode
- 将原表尾l的next指向新元素，这时要考虑一种情况，原表尾l为null，即整个链表是空的，那么这个时候，我们只需要将表头first也指向新元素newNode就可以了。
- 集合数量size加1，以及modCount自增表示集合已经修改了。
注意，这里好像只改变了三个引用，缺少了新元素newNode下一个元素的prev指向新元素newNode。这是因为在表尾，不存在下一个元素。
public void add(int index, E element) {
checkPositionIndex(index);
if (index == size)
linkLast(element);
else
linkBefore(element, node(index));
}在链表指定索引位置插入元素，如果index等于size，表示在表尾插入元素，直接调用linkLast(element)方法，否则先调用node(index)方法，找到index索引对应元素node，并将要添加元素element插入到元素node之前。
Node<E> node(int index) {
// 如果index小于集合数量的一半，那么从表头开始遍历，一直到index位置。
// 否则从表尾开始遍历，一直到index位置。这样我们每次最多遍历size/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;
}
}这里用了个巧妙方法，先判断index在集合的前一半还是后一半，决定从链表头还是链表尾遍历。
void linkBefore(E e, Node<E> succ) {
// e表示新添加的元素
// succ表示被插入的元素(即新元素插入到这个元素之前)
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++;
}
