JAVA Queue源码分析 java1.8

JAVA Queue

第一篇博客，希望以后每天坚持
目录：
1.Queue接口
2.Java中Queue接口方法
3.Queue的子类PriorityQueue分析
4.总结

---

1.Queue接口
数据结构中的队列，先进先出式的数据结构。
主要注意的时，Java中的Queue是比数据结构中理解的Queue更加灵活。这表现在：
a.数据结构中的Queue是按时间顺序的先进先出，即你先插入的元素总是先出的。但是JAVA中的Queue确实运行你实现自己的策略，确定什么元素是“优先”的，如它的value值模拟“它的达到时间”，value越大，则优先级越高，越排在前面。当前你也可以按照自然的常理的时间顺序。（注意：你确定了你的策略之后，就不可变了，不能一会说按照时间顺序，一会按照value倒叙）
b.比通常的queue多了一个方法peek，你可以查看却不删除，根据当前的值，觉得你的操作。

---

2.Java中Queue接口方法
六个：
a:add(E e):添加一个元素
b:remove():删除一个元素
c:offer(E e):添加一个元素
d:poll(E e):删除一个元素
f: element() ：查看最上一个元素
h:peek():查看最上一个元素
上面六个函数总体上分为两类：安全的会进行容量检查的（add,remove,element）,如果队列没有值，则取元素会抛出IlleaglStatementException异常。不安全的不进行容量控制的(offer,poll,peek )。

既然是这样，为什么要有两条语句相同的一个安全、不个不安全的呢？只提供一套安全的不久可以了么？

我的理解：有时候需要通过抛出异常来判断是容器中包涵null还是没有值。Queue通常不允许插入null值元素。但是有的实现却是允许插入null值的，如LinkedList.
另外，这里的分类不是严格的，并不是说所有queue的子类的add方法都会进行容量检查，然后抛出异常。这是要看容器的特性的，如Priorityqueue是无界的，add方法是直接的调用的offer方法。

---

3.Queue的子类PriorityQueue分析
3.1主要的方法成员
private static final int DEFAULT_INITIAL_CAPACITY = 11;
transient Object[] queue; // non-private to simplify nested class access

/** * The number of elements in the priority queue. */private int size = 0;/** * The comparator, or null if priority queue uses elements' * natural ordering. */private final Comparator<? super E> comparator;/** * The number of times this priority queue has been * <i>structurally modified</i>.  See AbstractList for gory details. */transient int modCount = 0; // non-private to simplify nested class access

说明：PriorityQueue使用数组存储数据，基于数组形式的小根堆来做的。

3.2主要方法分析
a.构造方法

    public PriorityQueue(int initialCapacity,                     Comparator<? super E> comparator) {    // Note: This restriction of at least one is not actually needed,    // but continues for 1.5 compatibility    if (initialCapacity < 1)        throw new IllegalArgumentException();    //数组的大小，直接看用户指定的initialCapacity，没有指定就是默认值11          //区别于Map类型的，是2^n次方。    this.queue = new Object[initialCapacity];    this.comparator = comparator;}

注意：PriorityQueue是在构造函数调用阶段就已经申请了底层数组，而有的容器如HashMap是采用的懒加载机制，在实际的使用的时候，才会真正的去申请底层的数据空间（可能原因：hashmap是一个比较费空间的，因为来避免碰撞，获得较好的性能，则一般需要申请较大的底层数组，所以这种开销大的动作能推迟就推迟，而Queue在默认的没有指定初始容量的时候，只申请了长度为11的数组，开销较小。不过ArrayList在没有指定初始化容量的时候，也是采用的类似懒加载机制，指向一个长度为0的空数组，真正使用的时候才创建底层数组的空间，关于ArrayList其他的容器在以后再说）

b.添加元素
add方法：直接调用offer(E)方法
offer方法：
比较简单，因为priorityQueue是无界队列，所以，添加元素不会抛出illegalStateException异常。如果当前数组已满，则会直接扩容。
过程：
a：安全性检查，不运行插入null元素
b：容量检查，如果容量不够，则扩容。扩容原则：如果当前基层数组较小，则扩容时，每次扩展一倍。之后每次扩容时，每次扩展0.5倍
c.如果当前队列为空，则直接插入到queue[0]位置，不需要调整。否则，将元素直接“放到”一个有效位置上，然后调整，不断上浮。

    public boolean offer(E e) {    if (e == null)        throw new NullPointerException();    modCount++;    int i = size;    if (i >= queue.length)        grow(i + 1);    size = i + 1;    if (i == 0)        queue[0] = e;    else        siftUp(i, e);    return true;}

上浮函数：不断的为新节点找位置，最后找到位置后，才赋值一次。

  private void siftUpComparable(int k, E x) {//父亲节点N,孩子节点2*N+1,2(N+1),则孩子节点编号k,父亲节点为(k - 1) >>> 1。0位置//也是存数据的    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;}

c.删除元素
remove函数：主要还是调用的poll函数，只是增加了异常处理（属于装饰器模式么？）

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

poll函数：
主要步骤：
a.容量检查
b.size标志减一，同时保存堆顶元素。
c.将最后一个元暂时提到堆顶位置，然后将堆顶元素调整，下移。

    public E poll() {    if (size == 0)        return null;    int s = --size;    modCount++;    E result = (E) queue[0];    E x = (E) queue[s];    queue[s] = null;    if (s != 0)        siftDown(0, x);    return result;}    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;        //C为左右孩子中最小的        if (right < size &&            ((Comparable<? super E>) c).compareTo((E) queue[right]) > 0)            c = queue[child = right];        //如果key小于孩子，则不用调整的，否则，需要下移，孩子上移        if (key.compareTo((E) c) <= 0)            break;        //孩子上移        queue[k] = c;        k = child;    }    queue[k] = key;}

d.清除元素
特别要注意的地方：要清楚引用，不能只是将size置位0，这样的话会造成内存泄漏

    public void clear() {    modCount++;    //清楚引用，不能只是将size置位0，这样的话会造成内存泄漏    for (int i = 0; i < size; i++)        queue[i] = null;    size = 0;}

3.3其他
a.堆化函数
如果在构造PriorityQueue时，使用一个非priorityqueue集合初始queue，则策略是先将集合中的元素拷贝到底层的数组中，然后调用堆化函数调整元素顺序，使满足堆的性质。
过程：
调整非叶子点[0 , 2/size-1]之间的。

    private void heapify() {    for (int i = (size >>> 1) - 1; i >= 0; i--)        siftDown(i, (E) queue[i]);}

4.总结
a:priorityqueue是无界队列
b:和其他集合容器一样，构造时，尽量大概估计容器大小
c:不允许null元素