Queue

Queue是一个提供队列服务的集合。除实现了Collection的操作以外，队列还提供插入、提取和检查操作。一般情况下队列是FIFO的，但是也有一些特殊队列，如：优先队列就是依据提供的比较器或是按照自然顺序排列的。不过无论何种队列，其中的数据顺序都是有序的，我们都只可对它的头进行操作。

看到上述对队列的描述，我们发现其实我们也可以使用List或是Set来完成这些功能。其实在java6之前的版本中，我们可以看到LinkedList是实现了Queue接口的，但是从java6开始，增加了Deque（double-end queue），LinkedList的实现更改为了Deque。

Deque（双端队列）可以同时堆头、尾进行操作，在实现了Queue功能的基础上增加了对队列头和尾的操作，并增加了栈的操作。

Queue

数据进出顺序为FIFO，声明了对队列头的插入和检索功能。

AbstractQueue

public abstract class AbstractQueue<E> extends AbstractCollection<E> implements Queue<E> {
	……
}

是Queue的骨干实现。其中add、remove 和 element 方法分别基于 offer、poll 和 peek 方法，但是它们通过抛出异常而不是返回 false 或 null 来指示失败。

PriorityQueue

public class PriorityQueue<E> extends AbstractQueue<E> implements java.io.Serializable{
	……
}

一个基于优先级堆的极大优先级队列。此队列按照在构造时所指定的顺序对元素排序，既可以根据元素的自然顺序 来指定排序，也可以根据 Comparator 来指定，这取决于使用哪种构造方法。优先级队列不允许 null 元素。依靠自然排序的优先级队列还不允许插入不可比较的对象（这样做可能导致 ClassCastException）。

队列的头 是按指定排序方式的最小 元素。如果多个元素都是最小值，则头是其中一个元素——选择方法是任意的。队列检索操作 poll、remove、peek 和 element 访问处于队列头的元素。

数据结构为一个Object数组。并带有自动扩容功能，可以在构造器中设置数组的初始容量，默认为11。

    private void siftUp(int k, E x) {
        if (comparator != null)
            siftUpUsingComparator(k, x);
        else
            siftUpComparable(k, x);
    }

    private void siftUpComparable(int k, E x) {
        Comparable<? super E> key = (Comparable<? super E>) x;
        while (k > 0) {
            int parent = (k - 1) >>> 1;
            Object e = queue[parent];
            if (key.compareTo((E) e) >= 0)
                break;
            queue[k] = e;
            k = parent;
        }
        queue[k] = key;
    }

    private void siftUpUsingComparator(int k, E x) {
        while (k > 0) {
            int parent = (k - 1) >>> 1;
            Object e = queue[parent];
            if (comparator.compare(x, (E) e) >= 0)
                break;
            queue[k] = e;
            k = parent;
        }
        queue[k] = x;
    }

在队列中数据发生变化时，都会对数据进行排序操作，如果有提供了比较器就按照比较器来进行，没有提供就会按照自然排序法进行，但是前提是这些元素是可比较的，即实现了Comparable接口。

Deque

public interface Deque<E> extends Queue<E> {
	……
}

双端队列（double ended queue，发音为‘deck’），是java6以后新增的接口。可以同时堆头、尾进行操作，在实现了Queue功能的基础上增加了对队列头和尾的操作，并增加了栈的操作。

ArrayDeque

public class ArrayDeque<E> extends AbstractCollection<E> implements Deque<E>, Cloneable, Serializable{
	……
}

是由数组实现的双端队列。数组默认的长度为16，每次扩张是都是原大小的二倍。可以通过构造器自行设置大小，但是会通过一次适配，把长度适配为2的次幂。适配方法：

    private void allocateElements(int numElements) {
        int initialCapacity = MIN_INITIAL_CAPACITY;
        // Find the best power of two to hold elements.
        // Tests "<=" because arrays aren't kept full.
        if (numElements >= initialCapacity) {
            initialCapacity = numElements;
            initialCapacity |= (initialCapacity >>>  1);
            initialCapacity |= (initialCapacity >>>  2);
            initialCapacity |= (initialCapacity >>>  4);
            initialCapacity |= (initialCapacity >>>  8);
            initialCapacity |= (initialCapacity >>> 16);
            initialCapacity++;

            if (initialCapacity < 0)   // Too many elements, must back off
                initialCapacity >>>= 1;// Good luck allocating 2 ^ 30 elements
        }
        elements = (E[]) new Object[initialCapacity];
    }

由于是双端队列，所以需要维护2个index，分别为head和tail。

    public void addFirst(E e) {
        if (e == null)
            throw new NullPointerException();
        elements[head = (head - 1) & (elements.length - 1)] = e;
        if (head == tail)
            doubleCapacity();
    }
    public void addLast(E e) {
        if (e == null)
            throw new NullPointerException();
        elements[tail] = e;
        if ( (tail = (tail + 1) & (elements.length - 1)) == head)
            doubleCapacity();
    }

由上代码可以看到，首先是不支持null对象的。head在维护时顺时针处理，tail逆时针处理。如果它们指向同一个位置时就要扩张数组。从这里我们就可以看到为什么我们要求数组的长度必须为2的次幂了，为了位运算，呵呵，觉得这里Josh Bloch and Doug Lea有些取巧了。head指向当前的头数据的位置，tail指向下一个尾数据的位置，这个要切记，否则上面的代码必定要出错。

从api中可以看到，当这个类当做一个stack使用时，运行速度要快于Stack类；当做queue使用时要快于LinkedList的。这个也是同它的数据结构关联的，毕竟对于数组来说检索永远是线性时间。

    public E pollFirst() {
        int h = head;
        E result = elements[h]; // Element is null if deque empty
        if (result == null)
            return null;
        elements[h] = null;     // Must null out slot
        head = (h + 1) & (elements.length - 1);
        return result;
    }

如果我们要移除一个头元素的话，移除仅是将当前指向的元素设为null，并将head指向下一个位置。这样省事，但是会造成空间的浪费。

    public E pollLast() {
        int t = (tail - 1) & (elements.length - 1);
        E result = elements[t];
        if (result == null)
            return null;
        elements[t] = null;
        tail = t;
        return result;
    }

移除一个尾元素，更有意思，找到真正的元素设置为null，并将它作为下一个元素位置。

迭代器也提供了2个，分别从头至尾和从尾至头，呵呵。