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

  • 0
    点赞
  • 0
    收藏
    觉得还不错? 一键收藏
  • 0
    评论
评论
添加红包

请填写红包祝福语或标题

红包个数最小为10个

红包金额最低5元

当前余额3.43前往充值 >
需支付:10.00
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明:

1.余额是钱包充值的虚拟货币,按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载,可以购买VIP、付费专栏及课程。

余额充值