Queue源码浅析(java)

曾经终败给现在 2024-04-01 09:43 63阅读 0赞

**目录**

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);
        }