java容器类4：Queue深入解读

Collection的其它两大分支：List和Set在前面已近分析过，这篇来分析一下Queue的底层实现。

前三篇关于Java容器类的文章：

java容器类1：Collection,List,ArrayList,LinkedList深入解读

java容器类2：Map及HashMap深入解读

java容器类3：set/HastSet/MapSet深入解读

Queue

---

public interface Queue<E> extends Collection<E> {
    boolean add(E var1);

    boolean offer(E var1);

    E remove();

    E poll();

    E element();

    E peek();
}

这就是Queue接口的代码，相比于List或者Set简洁明了很多。下面介绍一下它里面接口的含义：

在处理元素前用于保存元素的 collection。除了基本的 Collection 操作外，队列还提供其他的

插入、提取和检查

操作。每个方法都存在两种形式：

一种抛出异常（操作失败时），另一种返回一个特殊值（null 或 false，具体取决于操作）。

插入操作的后一种形式是用于专门为有容量限制的 Queue 实现设计的；在大多数实现中，插入操作不会失败。

AbstractQueue

---

AbstractQueue中实现了queue和Collection中部分函数，比较简单，源码如下：

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

    protected AbstractQueue() {
    }

    public boolean add(E e) {
        if (offer(e))
            return true;
        else
            throw new IllegalStateException("Queue full");
    }


    public E remove() {
        E x = poll();
        if (x != null)
            return x;
        else
            throw new NoSuchElementException();
    }

    public E element() {
        E x = peek();
        if (x != null)
            return x;
        else
            throw new NoSuchElementException();
    }

    public void clear() {
        while (poll() != null)
            ;
    }

    public boolean addAll(Collection<? extends E> c) {
        if (c == null)
            throw new NullPointerException();
        if (c == this)
            throw new IllegalArgumentException();
        boolean modified = false;
        for (E e : c)
            if (add(e))
                modified = true;
        return modified;
    }
}

从上面的调用关系可以看出来，Queue的解释中哪些是会抛出异常的调用，哪些是不会抛出异常的调用接口。

Deque

---

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

在Java容器类1中介绍了LinkedList，链表类其实实现了 Deque的接口，所以链表支持从头部和尾部添加和移除元素。

ArrayDeque

---

因为链表的存储结构可能比较简单，这里介绍一下ArrayDeque，它的里面存储元素使用一个数组。 作为一个双端队列的数组，涉及到扩容和元素的拷贝的逻辑可能比较复杂些。

看一下里面的几个构造函数：

public ArrayDeque() {
        elements = 

new Object[16];

    }


public ArrayDeque(int numElements) {
        

allocateElements(numElements);

    }

public ArrayDeque(Collection<? extends E> c) {
        allocateElements(c.size());
        addAll(c);
    }

从构造函数可以看出默认的会分配一个长度为16的数组。同时，也支持指定大小的队列（这里的allocateElements函数之前在

java容器类2：Map及HashMap深入解读  中已经深入分析过，是个非常精妙的函数）。下面看一下到底是如何实现插入？又是如何自动扩充数组的?

ArrayQueue中维护了两个成员变量：head和tail分别代表 队列的头和尾在数组中的下标。

 /**
     * The index of the element at the head of the deque (which is the
     * element that would be removed by remove() or pop()); or an
     * arbitrary number equal to tail if the deque is empty.
     */
    transient int head;

    /**
     * The index at which the next element would be added to the tail
     * of the deque (via addLast(E), add(E), or push(E)).
     */
    transient int 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();
}

由构造函数和数组分配的函数可以知道，数组的长度肯定是一个2的幂次方的一个整数。

当head为大于0的整数时，在头部插入很简单，将head前一个元素赋值为e就可以了。那么当head为0时，怎么计算的？由上面可以看出会插入到数组的尾部。所以ArrayDeque相当于在一个圆环上，规定一个头一个尾作为队列的前后（将数组的首位相连）。

在最后位置添加元素的原理和在首部添加相似。注意判断是否已满的 判断，这里不再分析。

当队列已经满后，会将数组的长度double。由于数组是不能自由扩张的，所以doubleCapacity函数应该是分配一个更大的数组，并将原来的元素拷贝进去，这里不再分析。

总的来说双端队列ArrayDeque是在数组的基础之上实现，原理和实现都不算复杂，但是很多边界调节等细节可以斟酌。

BlockingQueue

---

BlockingQueue是concurrent包下面的，后续打算写一个系列文章专门分析concurrent包下面的类，及一些多线程相关的东西。

PriorityQueue

---

优先级队列是一个可以排序的队列。内部是一个最大堆，大部分人应该了解堆排序，所以对最大堆应该不会陌生。

每次读取元素都是读取最大的元素（默认情况下）。

对外的接口有如下：

方法名	功能描述
add(E e)	添加元素
clear()	清空
contains(Object o)	检查是否包含当前参数元素
offer(E e)	添加元素
peek()	读取元素，（不删除）
poll()	取出元素，（删除）
remove(Object o)	删除指定元素
size()	返回长度

PriorityQueue 默认是一个最大堆结构，如果想构造一个最小堆：

private static final int DEFAULT_INITIAL_CAPACITY = 11;
PriorityQueue<Integer> maxHeap=new PriorityQueue<Integer>(DEFAULT_INITIAL_CAPACITY, new Comparator<Integer>() {
        @Override
        public int compare(Integer o1, Integer o2) {
            return o2-o1;
        }
    });

关于堆的数据结构部分这里不再分析可以参考：https://www.cnblogs.com/tstd/p/5125949.html

c++版的优先级队列分析：优先级队列用法详解（priority_queue）

由于是通过数组保存数据，所以优先级队列也会涉及到容量的扩充等，和HashMap/Setting/Collection的扩容原理相同，甚至更简单，不再分析。PriorityQueue内部的操作都是在最大堆的基础上展开的，阅读堆的数据结构相关资料便可了解。

参考：

http://tool.oschina.net/uploads/apidocs/jdk-zh/java/util/Deque.html

http://www.cnblogs.com/NeilZhang/p/5650226.html