Java集合(三)：Queue队列

前面介绍了列表，其中包括List接口和LinkedList链表和ArrayList数组列表。这节介绍一个也很常见的数据结构：队列。

我们知道，队列是一个可以从尾部添加新元素、从头部删除元素的数据结构。对于有两个头的队列，即双端队列，可以让人们有效的在头部和尾部同时添加或删除元素。不过，队列不支持在中间添加元素。这节将介绍两个队列接口：Queue接口和双端队列接口Deque，还有实现类：ArrayDeque和优先级队列PriorityQueue。

1 队列：Queue接口

Queue接口设计了一些可以在队列头部删除元素、在尾部添加元素的方法。这个接口比较简单，一共只有6个方法，分别如下：

（1）添加元素

[java] view plain copy

print?

1. boolean add(E e);  
2. boolean offer(E e);  

boolean add(E e);boolean offer(E e);

这两个方法都在尾部添加一个值为e的元素。如果队列没有满，将给定的元素添加到这个队列的尾部并返回true。不同的是如果队列满了，add方法会抛出一个IllegalStateException异常，而offer方法返回false。

（2）删除并返回元素

[java] view plain copy

print?

1. E remove();  
2. E poll();  

E remove();E poll();

这两个方法删除队列头部的元素。如果队列非空，这两个方法删除头部元素后并返回这个元素。不同的是如果队列是空的，remove方法抛出一个NoSuchElementException异常，而poll方法返回false。

（3） 获得头部元素

[java] view plain copy

print?

1. E element();  
2. E peek();  

E element();E peek();

这两个方法都会返回头部的元素，而都不删除头部元素。不同的是如果队列是空的，element方法抛出一个NoSuchElementException异常，而peek方法返回null。

2 双端队列：Deque接口及ArrayDeque类

一般的队列只能在头部删除元素、在尾部添加元素，即只有一个端。而双端队列有两个端，支持在两端同时添加或删除元素。Deque接口是Java SE 6引入的，并由ArrayDeque类和LinkedList类实现，这两个类都提供了双端队列，并在必要的时候可以增加队列的长度。其实，还有一种队列，叫做有限队列，当然也包括有限双端队列，这两个队列不在本文的讨论之内。

2.1 Deque接口

Deque接口在Queue接口的基础之上增加了一些针对双端添加和删除元素的方法，这些方法根据出错时的行为也可以分为几组。这些方法就是在Queue接口中的方法名后面加上“First”和“Last”表明在哪端操作。这些方法整理如下：

（1）添加元素

[java] view plain copy

print?

1. void addFirst(E e);  
2. void addLast(E e);  
3. boolean offerFirst(E e);  
4. boolean offerLast(E e);  

void addFirst(E e);void addLast(E e);boolean offerFirst(E e);boolean offerLast(E e);

这四个方法在头部或尾部添加给定的元素。如果队列满了，前两个方法将抛出一个IllegalStateException异常，后两个方法返回false。

（2）删除并返回元素

[java] view plain copy

print?

1. E removeFirst();  
2. E removeLast();  
3. E pollFirst();  
4. E pollLast();  

E removeFirst();E removeLast();E pollFirst();E pollLast();

这四个方法删除头部或尾部的元素并返回。如果队列为空，前两个方法将抛出一个NoSuchElementException异常，后两个方法返回null。

（3）返回但不删除元素

[java] view plain copy

print?

1. E getFirst();  
2. E getLast();  
3. E peekFirst();  
4. E peekLast();  

E getFirst();E getLast();E peekFirst();E peekLast();

这四个方法返回头部或尾部的元素，但不删除。如果队列为空，前两个方法将抛出一个NoSuchElementException异常，后两个方法返回null。

2.2 ArrayDeque类

ArrayDeque类实现了Deque接口，是一个双端队列。不像LinkedList是一个双向链表，ArrayDeque是一个双向数组。这么说有点不准确，应该是，ArrayDeque的底层实现是一个循环数组：

[java] view plain copy

print?

1. transient Object[] elements;  
2. transient int head;  
3. transient int tail;  

transient Object[] elements;transient int head;transient int tail;

什么是循环数组？对于普通的数组，下标为0的元素代表数组的第一个元素，下标最大的元素代表数组的最后一个元素，这是固定的，对于在尾部添加和删除元素的队列操作来说还可以，但是对于同时也要在头部添加和删除元素就不适合了，因为这时必须移动头部元素后面的所有元素。而循环数组就解决了这个问题。

循环数组的基本思路是头下标和尾下标不是固定的。即这样：

其中中间的部分是队列中的元素。从这里我们可以看出，队列中的元素还是在数组中的连续部分存储的。两边空的地方可以扩展队列。如果要在头部添加或删除一个元素，只需要使头下标head左移或右移一位即可，对于尾部的操作也是如此。这样就避免了真个数组的移动，提高了性能。

可以如果头部一直添加，或尾部一直添加，导致左面或右面不够了怎么办？这时就体现出循环数组的循环特点来了。具体的做法是，如果添加头部时左面没空间了，那么就在右面添加，就像这样：

数组的总长度固定，保证能够容纳所有元素的情况下，两个下标（head和tail）就像这样来回循环着。

那么在这两种情况下，队列中的元素个数怎么计算呢？

对于上面那种情况很容易，元素个数就是tail-head+1。下面这种情况就不是那么清晰了。可以先算中间空余的部分，然后用总长度减去空余的。中间空余的部分的长度是head-tail-1，那么元素个数就是length-(head-tail-1)。

事实上，ArrayDeque类的实现者有个更好的方法，使用位运算：

[java] view plain copy

print?

1. public int size() {  
2.     return (tail - head) & (elements.length - 1);  
3. }  

public int size() {    return (tail - head) & (elements.length - 1);}

这样就计算了元素的个数，很神奇。

可是，head和tail总有相等的时候。一种情况是队列中没有元素，这时head==tail，就像这样：

另一种情况是，head循环后一直增加，一直增加到tail：

这两种情况tail都等于head，看ArrayDeque类的isEmpty方法：

[java] view plain copy

print?

1. public boolean isEmpty() {  
2.     return head == tail;  
3. }  

public boolean isEmpty() {    return head == tail;}

这又是怎么判断到底是空呢还是满呢？

事实上，ArrayDeque类的实现者不会让第二种情况发生。因为ArrayDeque是一个可变长度队列，即如果空间不够，程序会自动扩大数组的容量为原来的2倍，然后将原来的元素复制到新的数组中。

还有一点，初始化时这个数组的长度是8，如果满了就扩大为原来的2倍，因此数组的长度一直是2的幂。

这个双端队列的基本操作方法都很简单，这里就不过多叙述。

虽然双端队列只可以在两端做添加和删除操作，但ArrayDeque类还增加了两个方法可以在中间删除给定的元素：

[java] view plain copy

print?

1. public boolean removeFirstOccurrence(Object o)  
2. public boolean removeLastOccurrence(Object o)  

public boolean removeFirstOccurrence(Object o)public boolean removeLastOccurrence(Object o)

第一个方法删除第一次出现给定对象的元素（第一次出现即从head开始到tail结束）；第二个方法删除最后一次出现给定对象的元素。

由于双端队列的特殊性（head可能比tail大），如果要从head到tail遍历队列，需要这样：

[java] view plain copy

print?

1. int mask=elements.length-1;  
2. int i=head;  
3. while(i!=tail)  
4. {  
5.     dosomething with elements[i];  
6.     i=(i+1)&mask;  
7. }  

int mask=elements.length-1;int i=head;while(i!=tail){    dosomething with elements[i];    i=(i+1)&mask;}

不过这样的话tail的那个元素没有遍历到。

ArrayDeque类中还定义了两个迭代器，一个是正向的Iterator迭代器，通过方法iterator返回；另一个是反向迭代器DescendingIterator，通过方法descendingIterator返回。关于迭代器的部分在上一节LinkedList部分讲到了，这里不过多重复。ArrayDeque类内部实现Iterator接口的内部类分别是：

[java] view plain copy

print?

1. private class DeqIterator implements Iterator<E>  
2. private class DescendingIterator implements Iterator<E>  

private class DeqIterator implements Iterator<E>private class DescendingIterator implements Iterator<E>

这两个类实现了next和hasNext方法。

3 优先级队列：PriorityQueue

优先级队列中的元素可以按照任意的顺序插入，却总是按照排序的顺序进行检索。也就是说，无论何时调用remove方法，总会获得当前优先级队列中最小的元素。然而，优先级队列并没有对所有的元素进行排序。如果用迭代的方式处理这些元素，并不需要对它们进行排序。优先级队列使用了一个优雅且高效的数据结构，称为堆（heap）。堆是一个可以自我调节的二叉树，对树执行添加（add）和删除（remove）操作，可以让最小的元素移动到根，而不必花时间对元素进行排序。

PriorityQueue类的底层是使用数组保存数据的：

[java] view plain copy

print?

1. transient Object[] queue;  
2. private int size = 0;  

transient Object[] queue;private int size = 0;

其中size保存元素的个数。使用数组保存一个二叉树，对于一个节点下标为n，则左儿子的下标为2*n+1，右儿子下标为2*(n+1)。而队列中的最小元素保存在queue[0]中。

PriorityQueue即可以保存实现了Comparable接口的类对象，也可以保存在构造器中提供比较器的对象。比如，下面的代码使用自定义比较器构造一个优先级队列：

[java] view plain copy

print?

1. PriorityQueue<Student> pq=new PriorityQueueM<>(new Comparator<Student>(){  
2.       public int compare(Student s1,Student s2){  
3.         return s1.getScore()-s2.getScore();  
4.         }  
5. }  
6. );  

PriorityQueue<Student> pq=new PriorityQueueM<>(new Comparator<Student>(){      public int compare(Student s1,Student s2){        return s1.getScore()-s2.getScore();        }});

这个比较器比较两个学生的成绩。这是一个匿名内部类。

在最小堆中，最重要的操作就是添加元素或删除元素后如何调整这个堆。基本上，如果添加一个元素，可以先将这个元素放在最下面，然后将这个元素向上移动，知道大于等于它的父节点或称为根节点；还可以将这个元素放在根节点位置，然后将这个元素向下移动，直到小于等于子节点或称为一个叶节点。

下面是PriorityQueue类中实现的上移和下移代码，对我们的编程很有帮助：

[java] view plain copy

print?

1. private void siftUp(int k, E x) {  
2.     if (comparator != null)  
3.         siftUpUsingComparator(k, x);  
4.     else  
5.         siftUpComparable(k, x);  
6. }  
7.   
8. @SuppressWarnings("unchecked")  
9. private void siftUpComparable(int k, E x) {  
10.     Comparable<? super E> key = (Comparable<? super E>) x;  
11.     while (k > 0) {  
12.         int parent = (k - 1) >>> 1;  
13.         Object e = queue[parent];  
14.         if (key.compareTo((E) e) >= 0)  
15.             break;  
16.         queue[k] = e;  
17.         k = parent;  
18.     }  
19.     queue[k] = key;  
20. }  
21.   
22. @SuppressWarnings("unchecked")  
23. private void siftUpUsingComparator(int k, E x) {  
24.     while (k > 0) {  
25.         int parent = (k - 1) >>> 1;  
26.         Object e = queue[parent];  
27.         if (comparator.compare(x, (E) e) >= 0)  
28.             break;  
29.         queue[k] = e;  
30.         k = parent;  
31.     }  
32.     queue[k] = x;  
33. }  
34.   
35. private void siftDown(int k, E x) {  
36.     if (comparator != null)  
37.         siftDownUsingComparator(k, x);  
38.     else  
39.         siftDownComparable(k, x);  
40. }  
41.   
42. @SuppressWarnings("unchecked")  
43. private void siftDownComparable(int k, E x) {  
44.     Comparable<? super E> key = (Comparable<? super E>)x;  
45.     int half = size >>> 1;        // loop while a non-leaf  
46.     while (k < half) {  
47.         int child = (k << 1) + 1; // assume left child is least  
48.         Object c = queue[child];  
49.         int right = child + 1;  
50.         if (right < size &&  
51.             ((Comparable<? super E>) c).compareTo((E) queue[right]) > 0)  
52.             c = queue[child = right];  
53.         if (key.compareTo((E) c) <= 0)  
54.             break;  
55.         queue[k] = c;  
56.         k = child;  
57.     }  
58.     queue[k] = key;  
59. }  
60.   
61. @SuppressWarnings("unchecked")  
62. private void siftDownUsingComparator(int k, E x) {  
63.     int half = size >>> 1;  
64.     while (k < half) {  
65.         int child = (k << 1) + 1;  
66.         Object c = queue[child];  
67.         int right = child + 1;  
68.         if (right < size &&  
69.             comparator.compare((E) c, (E) queue[right]) > 0)  
70.             c = queue[child = right];  
71.         if (comparator.compare(x, (E) c) <= 0)  
72.             break;  
73.         queue[k] = c;  
74.         k = child;  
75.     }  
76.     queue[k] = x;  
77. }  

private void siftUp(int k, E x) {    if (comparator != null)        siftUpUsingComparator(k, x);    else        siftUpComparable(k, x);}@SuppressWarnings("unchecked")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;}@SuppressWarnings("unchecked")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;}private void siftDown(int k, E x) {    if (comparator != null)        siftDownUsingComparator(k, x);    else        siftDownComparable(k, x);}@SuppressWarnings("unchecked")private void siftDownComparable(int k, E x) {    Comparable<? super E> key = (Comparable<? super E>)x;    int half = size >>> 1;        // loop while a non-leaf    while (k < half) {        int child = (k << 1) + 1; // assume left child is least        Object c = queue[child];        int right = child + 1;        if (right < size &&            ((Comparable<? super E>) c).compareTo((E) queue[right]) > 0)            c = queue[child = right];        if (key.compareTo((E) c) <= 0)            break;        queue[k] = c;        k = child;    }    queue[k] = key;}@SuppressWarnings("unchecked")private void siftDownUsingComparator(int k, E x) {    int half = size >>> 1;    while (k < half) {        int child = (k << 1) + 1;        Object c = queue[child];        int right = child + 1;        if (right < size &&            comparator.compare((E) c, (E) queue[right]) > 0)            c = queue[child = right];        if (comparator.compare(x, (E) c) <= 0)            break;        queue[k] = c;        k = child;    }    queue[k] = x;}

使用优先级队列的典型示例是任务调度。每一个任务都有一个优先级，任务以随机顺序添加到队列中。每当启动一个新的任务时，都将优先级最高的任务从队列中删除（习惯上将1设为最高优先级）。

下面的代码展示了PriorityQueue类的使用：

[java] view plain copy

print?

1. import java.util.*;  
2. public class PriorityQueueTest {  
3.     public static void main(String[] args) {  
4.         PriorityQueue<GregorianCalendar> pq=new PriorityQueue<>();  
5.         pq.add(new GregorianCalendar(1906,Calendar.DECEMBER,9));  
6.         pq.add(new GregorianCalendar(1815,Calendar.DECEMBER,10));  
7.         pq.add(new GregorianCalendar(1903,Calendar.DECEMBER,3));  
8.         pq.add(new GregorianCalendar(1910,Calendar.JUNE,22));  
9.   
10.         System.out.println("Iterating over elements...");  
11.         for(GregorianCalendar date:pq){  
12.             System.out.println(date.get(Calendar.YEAR));  
13.         }  
14.         System.out.println("Removing elements...");  
15.         while(!pq.isEmpty()){  
16.             System.out.println(pq.remove().get(Calendar.YEAR));  
17.         }  
18.     }  
19. }  

import java.util.*;public class PriorityQueueTest {    public static void main(String[] args) {        PriorityQueue<GregorianCalendar> pq=new PriorityQueue<>();        pq.add(new GregorianCalendar(1906,Calendar.DECEMBER,9));        pq.add(new GregorianCalendar(1815,Calendar.DECEMBER,10));        pq.add(new GregorianCalendar(1903,Calendar.DECEMBER,3));        pq.add(new GregorianCalendar(1910,Calendar.JUNE,22));        System.out.println("Iterating over elements...");        for(GregorianCalendar date:pq){            System.out.println(date.get(Calendar.YEAR));        }        System.out.println("Removing elements...");        while(!pq.isEmpty()){            System.out.println(pq.remove().get(Calendar.YEAR));        }    }}

结果如下：