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个,分别从头至尾和从尾至头,呵呵。