Java PriorityBlockingQueue用法及代码示例

PriorityBlockingQueue是一个无界阻塞队列，使用与类相同的排序规则PriorityQueue并提供阻塞检索操作。由于是无界的，添加元素有时可能会因为资源耗尽而失败，导致OutOfMemoryError。该类不允许空元素。
PriorityBlockingQueue 类及其迭代器实现了 Collection 和 Iterator 接口的所有可选方法。

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

对该类的操作不保证具有相同优先级的元素的顺序。如果需要强制执行排序，请定义使用辅助键来打破主要优先级值中的联系的自定义类或比较器。
此类是 Java 集合框架的成员。

PriorityBlockingQueue的层次结构

Hierarchy of PriorityBlockingQueue Class in Java

它实现了可串行化,可迭代<E>,集合<E>,BlockingQueue,Queue接口和扩展AbstractQueue类。

声明：

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

这里，E 是该集合中保存的元素的类型。

Constructors of PriorityBlockingQueue

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

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

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

例子：

Java


// 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<? extends E> c) - 创建一个包含指定集合中的元素的PriorityBlockingQueue。

PriorityBlockingQueue<E> pbq = new PriorityBlockingQueue(Collection<? extends E> 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); 
    } 
}

输出：

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

3. PriorityBlockingQueue(intinitialCapacity)- 创建一个具有指定初始容量的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); 
    } 
}

输出：

PriorityBlockingQueue:[1, 2, 3]

4. PriorityBlockingQueue(int initialCapacity, Comparator<? super E> 比较器)- 创建具有指定初始容量的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); 
    } 
}

输出：

PriorityBlockingQueue:[3, 1, 2]

Basic Operations

1. 添加元素

PriorityBlockingQueue add()PriorityBlockingQueue 的方法将作为参数传递给此 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); 
    } 
}

输出：

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

输出：

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

输出

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

输出

The Names are:
A
Computer
Geeks
forGeeks
Portal

5. 比较器示例

PriorityBlockingQueue 的 comparator() 方法返回可用于对 PriorityBlockingQueue 中的元素进行排序的比较器。如果队列遵循元素的自然排序模式，则该方法返回 null 值。

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

输出

Comparator value: ComparatorExample$1@27bc2616
PriorityBlockingQueue follows : ComparatorExample$1@27bc2616

PriorityBlockingQueue的方法

METHOD	DESCRIPTION
add(E e)	将指定元素插入此优先级队列。
clear()	以原子方式删除此队列中的所有元素。
comparator()	返回用于排序此队列中的元素的比较器，如果此队列使用其元素的自然排序，则返回 null。
contains(Object o)	如果此队列包含指定元素，则返回 true。
dropTo(Collection<? super E> c)	从此队列中删除所有可用元素并将它们添加到给定集合中。
dropTo(Collection<? super E> c, int maxElements)	从此队列中删除最多给定数量的可用元素并将它们添加到给定的集合中。
forEach(消费者<? super E> 操作)	对 Iterable 的每个元素执行给定的操作，直到处理完所有元素或该操作引发异常。
PriorityBlockingQueue iterator()	返回对此队列中元素的迭代器。
offer(E e)	将指定元素插入此优先级队列。
offer(E e, long timeout, TimeUnit unit)	将指定元素插入此优先级队列。
put(E e)	将指定元素插入此优先级队列。
remainingCapacity()	始终返回 Integer.MAX_VALUE，因为 PriorityBlockingQueue 不受容量限制。
remove(Object o)	从此队列中删除指定元素的单个实例(如果存在)。
移除全部(集合<?> c)	删除指定集合中也包含的所有该集合的元素(可选操作)。
removeIf(Predicate<? super E> 过滤器)	删除此集合中满足给定谓词的所有元素。
keepAll(集合<?> c)	仅保留此集合中包含在指定集合中的元素(可选操作)。
spliterator()	返回对此队列中元素的 Spliterator。
toArray()	返回一个包含此队列中所有元素的数组。
toArray(T[] a)	返回一个包含此队列中所有元素的数组；返回数组的运行时类型是指定数组的运行时类型。

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

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

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

METHOD	DESCRIPTION
AbstractCollection containsAll()	如果此集合包含指定集合中的所有元素，则返回 true。
AbstractCollection isEmpty()	如果此集合不包含任何元素，则返回 true。
AbstractCollection toString()	返回此集合的字符串表示形式。

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

METHOD	DESCRIPTION
BlockingQueue poll()	检索并删除此队列的头部，如果需要元素变得可用，则等待指定的等待时间。
BlockingQueue take()	检索并删除此队列的头部，如有必要，则等待直到有元素可用。

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

METHOD	DESCRIPTION
Collection addAll()	将指定集合中的所有元素添加到此集合中(可选操作)。
containsAll(集合<?> c)	如果此集合包含指定集合中的所有元素，则返回 true。
equals(Object o)	比较指定对象与此集合是否相等。
hashCode()	返回此集合的哈希码值。
isEmpty()	如果此集合不包含任何元素，则返回 true。
parallelStream()	返回一个可能并行的 Stream 并以此集合作为其源。
size()	返回此集合中的元素数量。
stream()	返回以此集合作为源的顺序 Stream。
toArray(IntFunction<T[]> 生成器)	返回一个包含此集合中所有元素的数组，使用提供的生成器函数分配返回的数组。

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

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

参考：https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/concurrent/PriorityBlockingQueue.html

相关用法

注：本文由纯净天空筛选整理自Code_r大神的英文原创作品 PriorityBlockingQueue Class in Java。非经特殊声明，原始代码版权归原作者所有，本译文未经允许或授权，请勿转载或复制。