Java Collections Framework之Deque(LinkedList实现)源码分析（基于JDK1.6）(已补充)

deque 是“double ended queue（双端队列）”的缩写，通常读为“deck”

双端队列就是一个两端都是结尾的队列。队列的每一瑞都可以插入数据项和移除数据项。这些方法可以叫作insertLeft()和insertRight()，以及removeLeft()和removeRight()。如果严格禁止调用insertLeft()和removeLeft()方法（或禁用右段的操作），双端队列功能就和栈一样。禁止调用insertLeft()和removeRight()（或相反的另一对方法），它的功能就和队列一样了。双端队列与栈或队列相比，是一种多用途的数据结构，在容器类库中有时会用双端队列来提供栈和队列两种功能。

public interface Deque

extends Queue

一个线性 collection，支持在两端插入和移除元素。名称 deque 是“double ended queue（双端队列）”的缩写，通常读为“deck”。大多数Deque 实现对于它们能够包含的元素数没有固定限制，但此接口既支持有容量限制的双端队列，也支持没有固定大小限制的双端队列。

此接口定义在双端队列两端访问元素的方法。提供插入、移除和检查元素的方法。每种方法都存在两种形式：一种形式在操作失败时抛出异常，另一种形式返回一个特殊值（null 或false，具体取决于操作）。插入操作的后一种形式是专为使用有容量限制的Deque 实现设计的；在大多数实现中，插入操作不能失败。

下表总结了上述 12 种方法：

	第一个元素（头部）		最后一个元素（尾部）
	抛出异常	特殊值	抛出异常	特殊值
插入	addFirst(e)	offerFirst(e)	addLast(e)	offerLast(e)
移除	removeFirst()	pollFirst()	removeLast()	pollLast()
检查	getFirst()	peekFirst()	getLast()	peekLast()

此接口扩展了 Queue 接口。在将双端队列用作队列时，将得到 FIFO（先进先出）行为。将元素添加到双端队列的末尾，从双端队列的开头移除元素。从Queue 接口继承的方法完全等效于Deque 方法，如下表所示：

Queue 方法	等效 Deque 方法
add(e)	addLast(e)
offer(e)	offerLast(e)
remove()	removeFirst()
poll()	pollFirst()
element()	getFirst()
peek()	peekFirst()

双端队列也可用作 LIFO（后进先出）堆栈。应优先使用此接口而不是遗留 Stack 类。在将双端队列用作堆栈时，元素被推入双端队列的开头并从双端队列开头弹出。堆栈方法完全等效于 Deque 方法，如下表所示：

堆栈方法	等效 Deque 方法
push(e)	addFirst(e)
pop()	removeFirst()
peek()	peekFirst()

注意，在将双端队列用作队列或堆栈时，peek 方法同样正常工作；无论哪种情况下，都从双端队列的开头抽取元素。

此接口提供了两种移除内部元素的方法：removeFirstOccurrence 和removeLastOccurrence。

与 List 接口不同，此接口不支持通过索引访问元素。

虽然 Deque 实现没有严格要求禁止插入 null 元素，但建议最好这样做。建议任何事实上允许 null 元素的 Deque 实现用户最好不 要利用插入 null 的功能。这是因为各种方法会将null 用作特殊的返回值来指示双端队列为空。

Deque 实现通常不定义基于元素的 equals 和 hashCode 方法，而是从 Object 类继承基于身份的equals 和hashCode 方法。

此接口是 Java Collections Framework 的成员。

先看LinkedList类的定义。

1 public class LinkedList
2     extends AbstractSequentialList
3     implements List, Deque, Cloneable, java.io.Serializable

   LinkedList继承自AbstractSequenceList、实现了List及Deque接口。其实AbstractSequenceList已经实现了List接口，这里标注出List只是更加清晰而已。AbstractSequenceList提供了List接口骨干性的实现以减少实现List接口的复杂度。Deque接口定义了双端队列的操作。

    LinkedList中之定义了两个属性：

1 private transient Entry header = new Entry(null, null, null);
2 private transient int size = 0;

    size肯定就是LinkedList对象里面存储的元素个数了。LinkedList既然是基于链表实现的，那么这个header肯定就是链表的头结点了，Entry就是节点对象了。一下是Entry类的代码。

 1 private static class Entry {
 2     E element;
 3     Entry next;
 4     Entry previous;
 5 
 6     Entry(E element, Entry next, Entry previous) {
 7         this.element = element;
 8         this.next = next;
 9         this.previous = previous;
10     }
11 }

    只定义了存储的元素、前一个元素、后一个元素，这就是双向链表的节点的定义，每个节点只知道自己的前一个节点和后一个节点。

    来看LinkedList的构造方法。

1 public LinkedList() {
2     header.next = header.previous = header;
3 }
4 public LinkedList(Collectionextends E> c) {
5     this();
6     addAll(c);
7 }

   LinkedList提供了两个构造方法。第一个构造方法不接受参数，只是将header节点的前一节点和后一节点都设置为自身（注意，这个是一个双向循环链表，如果不是循环链表，空链表的情况应该是header节点的前一节点和后一节点均为null），这样整个链表其实就只有header一个节点，用于表示一个空的链表。第二个构造方法接收一个Collection参数c，调用第一个构造方法构造一个空的链表，之后通过addAll将c中的元素全部添加到链表中。来看addAll的内容。

 1 public boolean addAll(Collectionextends E> c) {
 2     return addAll(size, c);
 3 }
 4 // index参数指定collection中插入的第一个元素的位置
 5 public boolean addAll(int index, Collectionextends E> c) {
 6     // 插入位置超过了链表的长度或小于0，报IndexOutOfBoundsException异常
 7     if (index < 0 || index > size)
 8         throw new IndexOutOfBoundsException("Index: "+index+
 9                                                 ", Size: "+size);
10     Object[] a = c.toArray();
11 int numNew = a.length;
12 // 若需要插入的节点个数为0则返回false，表示没有插入元素
13     if (numNew==0)
14         return false;
15     modCount++;
16     // 保存index处的节点。插入位置如果是size，则在头结点前面插入，否则获取index处的节点
17 Entry successor = (index==size ? header : entry(index));
18 // 获取前一个节点，插入时需要修改这个节点的next引用
19 Entry predecessor = successor.previous;
20 // 按顺序将a数组中的第一个元素插入到index处，将之后的元素插在这个元素后面
21     for (int i=0; i) {
22 // 结合Entry的构造方法，这条语句是插入操作，相当于C语言中链表中插入节点并修改指针
23         Entry e = new Entry((E)a[i], successor, predecessor);
24         // 插入节点后将前一节点的next指向当前节点，相当于修改前一节点的next指针
25         predecessor.next = e;
26         // 相当于C语言中成功插入元素后将指针向后移动一个位置以实现循环的功能
27         predecessor = e;
28 }
29 // 插入元素前index处的元素链接到插入的Collection的最后一个节点
30 successor.previous = predecessor;
31 // 修改size
32     size += numNew;
33     return true;
34 }

    构造方法中的调用了addAll(Collectionc)方法，而在addAll(Collectionc)方法中仅仅是将size当做index参数调用了addAll(int index,Collectionc)方法。

 1 private Entry entry(int index) {
 2         if (index < 0 || index >= size)
 3             throw new IndexOutOfBoundsException("Index: "+index+
 4                                                 ", Size: "+size);
 5         Entry e = header;
 6         // 根据这个判断决定从哪个方向遍历这个链表
 7         if (index < (size >> 1)) {
 8             for (int i = 0; i <= index; i++)
 9                 e = e.next;
10         } else {
11             // 可以通过header节点向前遍历，说明这个一个循环双向链表，header的previous指向链表的最后一个节点，这也验证了构造方法中对于header节点的前后节点均指向自己的解释
12             for (int i = size; i > index; i--)
13                 e = e.previous;
14         }
15         return e;
16     }

    结合上面代码中的注释及双向循环链表的知识，应该很容易理解LinkedList构造方法所涉及的内容。下面开始分析LinkedList的其他方法。

 addFirst(E e)

1 public void addFirst(E e) {
2     addBefore(e, header.next);
3 }

1 private Entry addBefore(E e, Entry entry) {
2     Entry newEntry = new Entry(e, entry, entry.previous);
3     newEntry.previous.next = newEntry;
4     newEntry.next.previous = newEntry;
5     size++;
6     modCount++;
7     return newEntry;
8 }

removeFirst()

1 public E removeFirst() {
2     return remove(header.next);
3 }

几个remove方法最终都是调用了一个私有方法：remove(Entry e)，只是其他简单逻辑上的区别。下面分析remove(Entry e)方法。

 1 private E remove(Entry e) {
 2     if (e == header)
 3         throw new NoSuchElementException();
 4     // 保留将被移除的节点e的内容
 5 E result = e.element;
 6 // 将前一节点的next引用赋值为e的下一节点
 7     e.previous.next = e.next;
 8     // 将e的下一节点的previous赋值为e的上一节点
 9     e.next.previous = e.previous;
10     // 上面两条语句的执行已经导致了无法在链表中访问到e节点，而下面解除了e节点对前后节点的引用
11 e.next = e.previous = null;
12 // 将被移除的节点的内容设为null
13 e.element = null;
14 // 修改size大小
15     size--;
16     modCount++;
17     // 返回移除节点e的内容
18     return result;
19 }

getFirst()

1 public E getFirst() {
2     if (size==0)
3         throw new NoSuchElementException();
4     return header.next.element;
5 }

offerFirst(E e)

1 public boolean offerFirst(E e) {
2     addFirst(e);
3     return true;
4 }

    在链表开头插入元素。

1 public void addFirst(E e) {
2     addBefore(e, header.next);
3 }

pollFirst()

1 public E pollFirst() {
2     if (size==0)
3         return null;
4     return removeFirst();
5 }

1 public E removeFirst() {
2     return remove(header.next);
3 }

peekFirst()

1 public E peekFirst() {
2     if (size==0)
3         return null;
4     return getFirst();
5 }

addLast(E e)

1 public void addLast(E e) {
2     addBefore(e, header);
3 }

    看上面的示意图，结合addBefore(E e,Entry entry)方法，很容易理解addFrist(E e)只需实现在header元素的下一个元素之前插入，即示意图中的一号之前。addLast(E e)只需在实现在header节点前（因为是循环链表，所以header的前一个节点就是链表的最后一个节点）插入节点（插入后在2号节点之后）。

 removeLast()

1 public E removeLast() {
2     return remove(header.previous);
3 }

getLast()

1 public E getLast()  {
2     if (size==0)
3         throw new NoSuchElementException();
4     return header.previous.element;
5 }

    getLast()方法和getFirst()方法类似，只是获取的是header节点的前一个节点的元素。因为是循环链表，所以header节点的前一节点就是链表的最后一个节点。

    offerLast(E e)

1 public boolean offerLast(E e) {
2     addLast(e);
3     return true;
4 }

    在链表末尾插入元素。

    pollLast()

1 public E pollLast() {
2     if (size==0)
3         return null;
4     return removeLast();
5 }

peekLast()

1 public E peekLast() {
2     if (size==0)
3         return null;
4     return getLast();
5 }

    上面的三个方法也很简单，只是调用了对应的get方法。

1 public E getLast()  {
2     if (size==0)
3         throw new NoSuchElementException();
4     return header.previous.element;
5 }

    getLast()方法和getFirst()方法类似，只是获取的是header节点的前一个节点的元素。因为是循环链表，所以header节点的前一节点就是链表的最后一个节点。