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。非經特殊聲明，原始代碼版權歸原作者所有，本譯文未經允許或授權，請勿轉載或複製。