Java PriorityBlockingQueue类

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

PriorityBlockingQueue类和它的迭代器实现了Collection和Iterator接口的所有可选方法。

方法iterator()中提供的Iterator和方法splitator()中提供的Spliterator不保证以任何特定顺序遍历PriorityBlockingQueue的元素。对于有序的遍历，请使用 Arrays.sort(pq.toArray()) 。 另外，方法drainTo()可以用来移除部分或全部优先级顺序的元素，并将其放入另一个集合中。

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

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

PriorityBlockingQueue的层次结构

Java中的PriorityBlockingQueue类

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

声明

public class PriorityBlockingQueue<E> extends AbstractQueue<E> implements BlockingQueue<E>, Serializable

这里， E 是这个集合中持有的元素的类型。

PriorityBlockingQueue的构造函数

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

1.PriorityBlockingQueue() - 创建一个具有默认初始容量（11）的PriorityBlockingQueue，根据其元素的自然排序进行排序。由于PriorityBlockingQueue不受容量限制，添加超过初始容量的元素会动态地改变PriorityBlockingQueue的容量。

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

示例：

// Java program to demonstrate
// PriorityBlockingQueue() constructor
  
import java.util.concurrent.PriorityBlockingQueue;
  
public class GFG {
  
    public static void main(String[] args)
    {
  
        // create object of PriorityBlockingQueue
        // using PriorityBlockingQueue() constructor
        PriorityBlockingQueue<Integer> pbq
            = new PriorityBlockingQueue<Integer>();
  
        // add  numbers
        pbq.add(1);
        pbq.add(2);
        pbq.add(3);
        pbq.add(4);
        pbq.add(5);
  
        // print queue
        System.out.println("PriorityBlockingQueue:" + pbq);
    }
}

输出

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

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

`PriorityBlockingQueue pbq = new PriorityBlockingQueue(Collection c)`

**示例：**

“`java
// Java program to demonstrate
// PriorityBlockingQueue(Collection c) constructor

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

public class GFG {

    public static void main(String[] args)
    {

        // Creating a Collection
        Vector<Integer> v = new Vector<Integer>();
        v.addElement(1);
        v.addElement(2);
        v.addElement(3);
        v.addElement(4);
        v.addElement(5);

        // create object of PriorityBlockingQueue
        // using PriorityBlockingQueue(Collection c)
        // constructor
        PriorityBlockingQueue<Integer> pbq
            = new PriorityBlockingQueue<Integer>(v);

        // print queue
        System.out.println("PriorityBlockingQueue:" + pbq);
    }
}
“`

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

**3.PriorityBlockingQueue(int initialCapacity)** \- 以指定的初始容量创建一个PriorityBlockingQueue，按照元素的自然顺序排列。

**例子**
“`java
// Java program to demonstrate
// PriorityBlockingQueue(int initialCapacity)
// constructor

import java.util.concurrent.PriorityBlockingQueue;

public class GFG {

    public static void main(String[] args)
    {
        // define capacity of PriorityBlockingQueue
        int capacity = 15;

        // create object of PriorityBlockingQueue
        // using PriorityBlockingQueue(int initialCapacity)
        // constructor
        PriorityBlockingQueue<Integer> pbq
            = new PriorityBlockingQueue<Integer>(capacity);

        // add numbers
        pbq.add(1);
        pbq.add(2);
        pbq.add(3);

        // print queue
        System.out.println("PriorityBlockingQueue:" + pbq);
    }
}
“`

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

**4.PriorityBlockingQueue(int initialCapacity, Comparator comparator) **\- 用指定的初始容量创建一个PriorityBlockingQueue，根据指定的比较器排列其元素。

**示例：**

“`java
// Java program to demonstrate
// PriorityBlockingQueue(int initialCapacity, Comparator
// comparator) constructor

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

public class GFG {

    public static void main(String[] args)
    {
        // define capacity of PriorityBlockingQueue
        int capacity = 15;

        // create object of PriorityBlockingQueue
        PriorityBlockingQueue<Integer> pbq
            = new PriorityBlockingQueue<Integer>(
                capacity, Comparator.reverseOrder());

        // add numbers
        pbq.add(1);
        pbq.add(2);
        pbq.add(3);

        // print queue
        System.out.println("PriorityBlockingQueue:" + pbq);
    }
}
“`

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

### 基本操作

**1.添加元素**

PriorityBlockingQueue的add(E e)方法在这个PriorityBlockingQueue的尾部插入作为参数传递给该方法的元素。如果添加元素成功，该方法返回true。否则，它返回false。

“`java
// Java program to demonstrate adding elements
// to the PriorityBlockingQueue

import java.util.concurrent.PriorityBlockingQueue;

public class AddingElementsExample {

    public static void main(String[] args)
    {
        // define capacity of PriorityBlockingQueue
        int capacity = 15;

        // create object of PriorityBlockingQueue
        PriorityBlockingQueue<Integer> pbq
            = new PriorityBlockingQueue<Integer>(capacity);

        // add numbers
        pbq.add(1);
        pbq.add(2);
        pbq.add(3);

        // print queue
        System.out.println("PriorityBlockingQueue:" + pbq);
    }
}
“`

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

**2.删除元素**

PriorityBlockingQueue的remove(Object o)方法是用来从这个队列中删除一个元素。这个方法删除了作为参数传递的元素的一个实例，如果它存在的话。如果且仅当元素被移除时，它返回true，否则返回false。 clear()用于一次性移除所有元素。
“`java
// Java program to demonstrate removing
// elements from the PriorityBlockingQueue

import java.util.concurrent.PriorityBlockingQueue;

public class RemovingElementsExample {

    public static void main(String[] args)
    {
        // define capacity of PriorityBlockingQueue
        int capacity = 15;

        // create object of PriorityBlockingQueue
        PriorityBlockingQueue<Integer> pbq
            = new PriorityBlockingQueue<Integer>(capacity);

        // add numbers
        pbq.add(1);
        pbq.add(2);
        pbq.add(3);

        // print queue
        System.out.println("PriorityBlockingQueue:" + pbq);

        // remove all the elements
        pbq.clear();

        // print queue
        System.out.println("PriorityBlockingQueue:" + pbq);
    }
}
“`

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

**3.访问元素**

PriorityBlockingQueue的peek()方法返回PriorityBlockingQueue头部的元素。它检索LinkedBlockingQueue的头部的值，但不删除它。如果PriorityBlockingQueue不包含任何元素，那么这个方法返回null。PriorityBlockingQueue队使用与PriorityQueue类相同的排序规则。
“`java
// Java Program Demonstrate accessing
// elements of PriorityBlockingQueue

import java.util.concurrent.PriorityBlockingQueue;

public class AccessingElementsExample {
    public static void main(String[] args)
    {
        // define capacity of PriorityBlockingQueue
        int capacityOfQueue = 5;

        // create object of PriorityBlockingQueue
        PriorityBlockingQueue<Integer> PrioQueue
            = new PriorityBlockingQueue<Integer>(
                capacityOfQueue);

        // Add elements to PriorityBlockingQueue
        PrioQueue.add(464161);
        PrioQueue.add(416165);

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

        // get head of PriorityBlockingQueue
        int head = PrioQueue.peek();

        // print head of PriorityBlockingQueue
        System.out.println("Head of Queue: " + head);
    }
}
“`

**输出**
“`java
PrioQueue: [416165, 464161]
Head of Queue: 416165
“`

**4.迭代**

PriorityBlockingQueue类的iterator()方法返回这个队列中的元素的一个迭代器。从这个方法返回的元素不遵循任何顺序。返回的迭代器是弱一致性的。
“`java
// Java Program Demonstrate iterating
// over PriorityBlockingQueue

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

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

        // define capacity of PriorityBlockingQueue
        int capacityOfQueue = 5;

        // create object of PriorityBlockingQueue
        PriorityBlockingQueue<String> names
            = new PriorityBlockingQueue<String>(
                capacityOfQueue);

        // Add names of students of girls college
        names.add("Geeks");
        names.add("forGeeks");
        names.add("A");
        names.add("Computer");
        names.add("Portal");

        // Call iterator() method of PriorityBlockingQueue
        Iterator iteratorVals = names.iterator();

        // Print elements of iterator
        // created from 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 Program Demonstrate comparator()
// method and passing Comparator to PriorityBlockingQueue

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

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

        // create object of PriorityBlockingQueue
        PriorityBlockingQueue<Integer> PrioQueue
            = new PriorityBlockingQueue<Integer>(
                10, new Comparator<Integer>() {
                    public int compare(Integer a, Integer b)
                    {
                        return a – b;
                    }
                });

        // Add numbers to PriorityBlockingQueue
        PrioQueue.put(45815616);
        PrioQueue.put(4981561);
        PrioQueue.put(4594591);
        PrioQueue.put(9459156);

        // get String representation of
        // PriorityBlockingQueue
        String str = PrioQueue.toString();

        // Creating a comparator using comparator()
        Comparator comp = PrioQueue.comparator();

        // Displaying the comparator values
        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 follows : 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()	返回一个以该集合为源的可能的并行流。
size()	返回这个集合中元素的数量。
stream()	返回一个以这个集合为源的顺序流。
toArray(IntFunction<T[]> generator)	返回一个包含此集合中所有元素的数组，使用提供的生成器函数来分配返回的数组。

java.util.Queue中声明的方法

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