Queue源码浅析(java)

目录

1. ArrayDeque

简述

成员变量

构造方法

扩容机制

2. PriorityQueue

 简述

成员变量

构造方法

扩容机制

---

简述

       ArrayDeque是Deque接口的一个实现，使用了可变数组，所以没有容量上的限制。同时，ArrayDeque是线程不安全的，在没有外部同步的情况下，不能再多线程环境下使用。ArrayDeque是Deque的实现类，可以作为栈来使用，效率高于Stack；也可以作为队列来使用，效率高于LinkedList。需要注意的是，ArrayDeque不支持null值

成员变量

    transient Object[] elements; 
 
    transient int head;
 
    transient int tail;
 
    private static final int MIN_INITIAL_CAPACITY = 8;

构造方法

public ArrayDeque() {
    elements = new Object[16];
}        //构造一个初始容量足够容纳16个元素的空数组队列。

public ArrayDeque(int numElements) {
    allocateElements(numElements);
}        //构造一个初始容量足够容纳指定数目的元素空数组队列。

public ArrayDeque(Collection<? extends E> c) {
    allocateElements(c.size());
    addAll(c);
}        //构建一个deque容器包含指定集合的元素，它们是由集合的迭代器返回的顺序。

扩容机制

        通过移位或的操作进行放大倍数，使得数组的容量值不必严格满足2的幂.看对应的源码吧

    // 初始化时分配数组大小
    private static int calculateSize(int numElements) {
        int initialCapacity = MIN_INITIAL_CAPACITY;
        // 最佳匹配元素与2的乘积
        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
        }
        return initialCapacity;
    }
    
    // 新增元素时扩容
    public void addFirst(E e) {
        if (e == null)
            throw new NullPointerException();
        elements[head = (head - 1) & (elements.length - 1)] = e;
        if (head == tail)
            doubleCapacity();
    }
 
    private void doubleCapacity() {
        assert head == tail;
        int p = head;
        int n = elements.length;
        int r = n - p; // number of elements to the right of p
        int newCapacity = n << 1;
        if (newCapacity < 0)
            throw new IllegalStateException("Sorry, deque too big");
        Object[] a = new Object[newCapacity];
        System.arraycopy(elements, p, a, 0, r);
        System.arraycopy(elements, 0, a, r, p);
        elements = a;
        head = 0;
        tail = n;
    }

2. PriorityQueue

 简述

            一个基于优先级堆 queue无界优先级。优先级队列的元素进行排序，根据他们的 natural ordering，或通过设置在队列 Comparator施工时间，这取决于使用哪个构造函数。一个优先队列不允许 null元素。依靠自然排序的优先级队列也不允许插入不可比较的对象

成员变量

private static final long serialVersionUID = -7720805057305804111L;

private static final int DEFAULT_INITIAL_CAPACITY = 11;

transient Object[] queue;

private int size = 0;

private final Comparator<? super E> comparator;

transient int modCount = 0;

构造方法

public PriorityQueue() {
    this(DEFAULT_INITIAL_CAPACITY, null);
}     //创建一个默认的初始容量 PriorityQueue（11），命令其元素按其 natural ordering  

public PriorityQueue(int initialCapacity) {
    this(initialCapacity, null);
}        //创建一个具有指定的初始容量，命令其元素按其 natural ordering PriorityQueue

public PriorityQueue(Comparator<? super E> comparator) {
    this(DEFAULT_INITIAL_CAPACITY, comparator);
}        //创建一个 PriorityQueue包含在指定集合的元素

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();
    this.queue = new Object[initialCapacity];
    this.comparator = comparator;
}        //创建一个具有指定的初始容量，命令其元素根据指定的比较器 PriorityQueue。

public PriorityQueue(Collection<? extends E> c) {
    if (c instanceof SortedSet<?>) {
        SortedSet<? extends E> ss = (SortedSet<? extends E>) c;
        this.comparator = (Comparator<? super E>) ss.comparator();
        initElementsFromCollection(ss);
    }
    else if (c instanceof PriorityQueue<?>) {
        PriorityQueue<? extends E> pq = (PriorityQueue<? extends E>) c;
        this.comparator = (Comparator<? super E>) pq.comparator();
        initFromPriorityQueue(pq);
    }
    else {
        this.comparator = null;
        initFromCollection(c);
    }
}        //创建一个 PriorityQueue包含指定的优先级队列中的元素。

public PriorityQueue(PriorityQueue<? extends E> c) {
    this.comparator = (Comparator<? super E>) c.comparator();
    initFromPriorityQueue(c);
}                //创建一个 PriorityQueue包含指定的优先级队列中的元素。

public PriorityQueue(SortedSet<? extends E> c) {
    this.comparator = (Comparator<? super E>) c.comparator();
    initElementsFromCollection(c);
}        创建一个 PriorityQueue含有指定排序的集合中的元素。

扩容机制

    private void grow(int minCapacity) {
        int oldCapacity = queue.length;
        // Double size if small; else grow by 50%
        int newCapacity = oldCapacity + ((oldCapacity < 64) ?
                                         (oldCapacity + 2) :
                                         (oldCapacity >> 1));
        // overflow-conscious code
        if (newCapacity - MAX_ARRAY_SIZE > 0)
            newCapacity = hugeCapacity(minCapacity);
        queue = Arrays.copyOf(queue, newCapacity);
    }