Java中的PriorityBlockingQueue类

PriorityBlockingQueue 是一个无界阻塞队列，它使用与类 PriorityQueue 相同的排序规则，并提供阻塞检索操作。由于它是无界的，添加元素时有时可能由于资源耗尽而失败，导致 OutOfMemoryError 。此类不允许空元素。

PriorityBlockingQueue类及其迭代器实现了集合和迭代器接口的所有可选方法。

在方法iterator()中提供的迭代器和方法spliterator()中提供的Spliterator不能保证以任何特定顺序遍历PriorityBlockingQueue的元素。如果要进行有序遍历，请使用 Arrays.sort(pq.toArray()) 。此外，方法drainTo()可用于按优先级顺序删除一些或所有元素并将它们放置在另一个集合中。

此类上的操作不保证具有相等优先级的元素的顺序。如果需要强制执行排序，请定义使用第二个关键字来打破主要优先级值中的平局的自定义类或比较器。

此类是Java集合框架的成员。

PriorityBlockingQueue的层次结构

Java中的PriorityBlockingQueue类

它实现了 Serializable ， **Iterable ** ， **Collection ** ， BlockingQueue ，Queue接口并扩展AbstractQueue类。

PriorityBlockingQueue的构造函数

为了创建PriorityBlockingQueue的实例，我们需要从 java.util.concurrent.PriorityBlockingQueue 导入它。

1. PriorityBlockingQueue() - 创建一个带有默认初始容量（11）的PriorityBlockingQueue，其根据其自然顺序对其元素进行排序。添加超过初始容量的元素会动态地更改PriorityBlockingQueue的容量，因为PriorityBlockingQueue没有容量限制。

PriorityBlockingQueue<E> pbq = new PriorityBlockingQueue<E>();

例子：

// Java程序演示
// PriorityBlockingQueue()构造函数

import java.util.concurrent.PriorityBlockingQueue;

public class GFG {
     public static void main(String[] args)
     {

        // 创建PriorityBlockingQueue的对象
        //使用PriorityBlockingQueue()构造函数
        PriorityBlockingQueue<Integer> pbq
              = new PriorityBlockingQueue<Integer>();

        //添加数字
        pbq.add(1);
        pbq.add(2);
        pbq.add(3);
        pbq.add(4);
        pbq.add(5);

        // 打印队列
        System.out.println("PriorityBlockingQueue:" + pbq);
     }
}

输出：

PriorityBlockingQueue:[1, 2, 3, 4, 5]

**2. PriorityBlockingQueue(Collection c)** \- 创建一个包含指定集合中的元素的PriorityBlockingQueue。

`PriorityBlockingQueue pbq = new PriorityBlockingQueue(Collection c);`

**3\. PriorityBlockingQueue(int initialCapacity)** \- 创建一个具有指定初始容量的PriorityBlockingQueue，并根据其自然顺序对其元素进行排序。

**4\. PriorityBlockingQueue(int initialCapacity, Comparator comparator)** \- 创建具有指定初始容量的PriorityBlockingQueue，并根据指定比较器对其元素进行排序。

### 基本操作

**1\. 添加元素**

PriorityBlockingQueue的add(E e)方法将传递给该方法的元素插入到此PriorityBlockingQueue的末尾。如果元素添加成功，则该方法返回true。否则，返回false。

“`java
// Java程序演示向PriorityBlockingQueue添加元素

import java.util.concurrent.PriorityBlockingQueue;

public class AddingElementsExample {

    public static void main(String[] args)
    {
        // 定义PriorityBlockingQueue的容量
        int capacity = 15;

        // 创建PriorityBlockingQueue对象
        PriorityBlockingQueue pbq
            = new PriorityBlockingQueue(capacity);

        // 添加数字
        pbq.add(1);
        pbq.add(2);
        pbq.add(3);

        // 打印队列
        System.out.println("PriorityBlockingQueue:" + pbq);
    }
}
“`

**输出：**
“`java
PriorityBlockingQueue:[1, 2, 3]
“`

**2\. 删除元素**

PriorityBlockingQueue的remove(Object o)方法用于从此队列中删除元素。如果该元素出现，则此方法仅删除传递的元素的单个实例。如果成功删除元素，它返回true。否则返回false。 clear()方法可一次性删除所有元素。
“`java
// Java程序演示从PriorityBlockingQueue中删除元素

import java.util.concurrent.PriorityBlockingQueue;

public class RemovingElementsExample {

    public static void main(String[] args)
    {
        // 定义PriorityBlockingQueue的容量
        int capacity = 15;

        // 创建PriorityBlockingQueue对象
        PriorityBlockingQueue pbq
            = new PriorityBlockingQueue(capacity);

        // 添加数字
        pbq.add(1);
        pbq.add(2);
        pbq.add(3);

        // 打印队列
        System.out.println("PriorityBlockingQueue:" + pbq);

        // 删除所有元素
        pbq.clear();

        // 打印队列
        System.out.println("PriorityBlockingQueue:" + pbq);
    }
}
“`

**输出：**
“`java
PriorityBlockingQueue:[1, 2, 3]
PriorityBlockingQueue:[]
“`

**3\. 访问元素**

PriorityBlockingQueue的peek()方法返回PriorityBlockingQueue头部的元素。它检索LinkedBlockingQueue的头部值，但不会将其删除。如果PriorityBlockingQueue不包含任何元素，则此方法返回null。PriorityBlockingQueue队列使用与PriorityQueue类相同的排序规则。
“`java
// Java程序演示访问PriorityBlockingQueue的元素

import java.util.concurrent.PriorityBlockingQueue;

public class AccessingElementsExample {
    public static void main(String[] args)
    {
        // 定义PriorityBlockingQueue的容量
        int capacityOfQueue = 5;

        // 创建PriorityBlockingQueue对象
        PriorityBlockingQueue PrioQueue
            = new PriorityBlockingQueue(
                capacityOfQueue);

        // 向PriorityBlockingQueue添加元素
        PrioQueue.add(464161);
        PrioQueue.add(416165);

        // 打印PrioQueue
        System.out.println("PrioQueue: " + PrioQueue);

        // 获取PriorityBlockingQueue的头部
        int head = PrioQueue.peek();

        // 打印PriorityBlockingQueue的头部
        System.out.println("Head of Queue: " + head);
    }
}
“`

**输出：**
“`java
PrioQueue: [416165, 464161]
排队的头部：416165
“`

**4\. 迭代**

PriorityBlockingQueue类的iterator（）方法返回此队列中元素的迭代器。从此方法返回的元素不遵循任何顺序。返回的迭代器是弱一致的。
“`java
// Java程序演示迭代
//在PriorityBlockingQueue上

import java.util.concurrent.PriorityBlockingQueue;
import java.util.*;

public class IteratingExample {
    public static void main(String[] args)
    {

        //定义PriorityBlockingQueue的容量
        int capacityOfQueue = 5;

        //创建PriorityBlockingQueue对象
        PriorityBlockingQueue<String> names
            = new PriorityBlockingQueue<String>(
                capacityOfQueue);

        //添加女子学院学生的姓名
        names.add("Geeks");
        names.add("forGeeks");
        names.add("A");
        names.add("Computer");
        names.add("Portal");

        //调用PriorityBlockingQueue的iterator（）方法
        Iterator iteratorVals = names.iterator();

        //打印从PriorityBlockingQueue创建的
        //迭代器的元素
        System.out.println("The Names are:");

        while (iteratorVals.hasNext()) {
            System.out.println(iteratorVals.next());
        }
    }
}
“`

**输出**
“`java
The Names are:
A
Computer
Geeks
forGeeks
Portal
“`

**5\. 比较器示例**

PriorityBlockingQueue的comparator（）方法返回可用于对PriorityBlockingQueue中的元素排序的比较器。如果队列遵循元素的自然排序模式，则该方法返回空值。
“`java
// Java程序演示comparator（）
//方法和传递比较器到PriorityBlockingQueue

import java.util.concurrent.PriorityBlockingQueue;
import java.util.*;

public class ComparatorExample {
    public static void main(String[] args)
        throws InterruptedException
    {

        //创建PriorityBlockingQueue对象
        PriorityBlockingQueue<Integer> PrioQueue
            = new PriorityBlockingQueue<Integer>(
                10, new Comparator<Integer>() {
                    public int compare(Integer a, Integer b)
                    {
                        return a – b;
                    }
                });

        //向PriorityBlockingQueue添加数字
        PrioQueue.put(45815616);
        PrioQueue.put(4981561);
        PrioQueue.put(4594591);
        PrioQueue.put(9459156);

        //获取PriorityBlockingQueue的字符串表示形式
        String str = PrioQueue.toString();

        //使用comparator（）创建比较器
        Comparator comp = PrioQueue.comparator();

        //显示比较器值
        System.out.println("Comparator value: " + comp);

        if (comp == null)
            System.out.println(
                "PriorityBlockingQueue follows natural ordering");
        else
            System.out.println(
                "PriorityBlockingQueue follows : " + comp);
    }
}
“`

**输出**
“`java
Comparator value: ComparatorExample $1 @ 27bc2616 PriorityBlockingQueue遵循的是：ComparatorExample$ 1 @ 27bc2616
“`

### 方法PriorityBlockingQueue

java.util.AbstractQueue类中声明的方法

方法	描述
addAll(Collection c) \| 将指定集合中的所有元素添加到此队列中。 element() \| 检索但不删除此队列的头。 remove() \| 检索并删除此队列的头。 ### java.util.AbstractCollection类中声明的方法方法 \| 描述 —\|— containsAll(Collection c)	如果此集合包含指定集合中的所有元素，则返回true。
isEmpty()	如果此集合不包含任何元素，则返回true。
toString()	返回此集合的字符串表示形式。

方法

描述

addAll(Collection c) | 将指定集合中的所有元素添加到此队列中。
element() | 检索但不删除此队列的头。
remove() | 检索并删除此队列的头。

### java.util.AbstractCollection类中声明的方法

方法 | 描述
—|—
containsAll(Collection c)

如果此集合包含指定集合中的所有元素，则返回true。

isEmpty()

如果此集合不包含任何元素，则返回true。

toString()

返回此集合的字符串表示形式。

java.util.concurrent.BlockingQueue接口中声明的方法

方法	描述
poll(long timeout, TimeUnit unit)	检索并删除此队列的头部，如果需要等待元素变为可用，则最多等待指定的等待时间。
take()	检索并删除此队列的头部，如果需要则等待，直到元素变为可用。

java.util.Collection接口中声明的方法

方法	描述
addAll(Collection c) \| 将指定集合中的所有元素添加到此集合中（可选操作）。 containsAll(Collection c)	如果此集合包含指定集合中的所有元素，则返回true。
equals(Object o)	将指定的对象与此集合进行比较，以检测相等性。
hashCode()	返回此集合的哈希码值。
isEmpty()	如果此集合不包含任何元素，则返回true。
parallelStream()	返回以此集合为其源的可能并行的Stream。
size()	返回此集合中的元素数。
stream()	返回以此集合为其源的顺序Stream。
toArray(IntFunction<T[]> generator)	使用提供的生成器函数来分配返回的数组，返回包含此集合中所有元素的数组。

java.util.Queue接口中声明的方法

方法	描述
element()	检索但不删除此队列的头部。
peek()	检索但不删除此队列的头部，如果此队列为空，则返回null。
poll()	检索并删除此队列的头部，如果此队列为空，则返回null。
remove()	检索并删除此队列的头部。