在本教程中，我们将看到Java 8 PriorityQueue。

当对象应该在其基础上处理 priority，在那种情况下，我们使用PriveityQueue。

这是一种特殊类型的 queue(也，未结合的队列)，其中元素可以根据其自然排序或者基于在声明时实现的自定义比较器来订购。

让我们了解日常生活例子的优先级队列的概念，

假设两个人去了两个不同的银行存钱， Person A根据现金计数器上形成的队列提供服务， Person B根据银行提供的令牌编号(底层队列)提供服务，现在在这里都遵循 FIFO(首先在先出来)模型，但他们的优先事项由不同的因素决定 Person A这是他们的抵达时间(站在队列中)，但对于 Person B它只是令牌号码(首先维修的较小数字)。
现在，即使在这里我们可以修改我们的系统，那个老年人首先维修，所以这是我们在少数优先事项的一个系统(可能是在年龄的基础上)。

优先级队列数据结构

让我们说你想读几本书并基于页数优先考虑它。
你想先阅读较薄的书籍，逐渐移动到更厚的书籍。

在给定示例中，优先级队列的前部包含最小元素，根据指定的排序，后部包含最伟大的元素。
由于从前面移除了元件，因此首先被移除最小值。

一些重要观点

• 无法使用优先级队列实现不可比较的对象。
• 不允许使用null，因为我们无法将其与任何值进行比较。
• 像，poll()，remove()，peek()等基本检索操作访问前面或者队列头部的元素。

构造函数

• priarityqueue()：创建具有默认初始容量的优先级队列，并遵循其元素的自然排序。
• priveityqueue(集合<e> c)：它在参数中指定的集合中创建包含元素的优先级队列。
• PriveityQueue(int intentcapacity)：它与具有指定初始容量的PriorityQueue()类似。
• PriorityQueue(IntinitCapacity，比较器<e>比较器)：它类似于PartityQueue(Int IntentCapacity)，但另外的参数指定其元素的顺序，应根据指定的比较器。

方法

• Boolean Add(元素)：此方法将元素插入此优先级队列。

pQueue.add(“Java”) ; //adding “Java” to string type priority queue pQueue

• 布尔删除(元素)：此方法将从队列中删除一个Element的一次性。

pQueue.remove(“Java”) ; //remove “Java” from string type priority queue pQueue

• poll()：此方法返回队列头部的元素，从而从队列中删除它，否则返回null(如果给定队列为空)。

pQueue.poll(); //if pQueue is the Priority queue given in the diagram above then it will return 50 and remove from the Priority Queue

• peek()：此方法与轮询()相同，唯一的区别是，返回它后不会删除头部。

pQueue.peek() ; //if pQueue is the Priority queue given in the diagram above then it will return 50.

• 布尔包含(元素)：如果给定队列包含其中的指定元素，则返回true。

pQueue.contains(250) ; //if pQueue is the Priority queue given in the diagram above then it will return true.
 
pQueue.contains(365) ; //if pQueue is the Priority queue given in the diagram above then it will return false.

• CLEAR()：此方法将从优先级队列中删除所有元素，即它将清空现有的优先级队列，并不会删除它。

pQueue.clear() ; //if we try to print the queue after invoking this function, it will return []

• 布尔优惠(元素)：此方法充当add()方法，因为它也用于将特定元素插入优先级队列。

pQueue.offer(25) ; //will add 25 to the pQueue according to its natural ordering,

• int size()：此方法将返回优先级队列中的元素数。

pQueue.size() ; //if pQueue is the Priority queue given in the diagram above then it will return 5.

• ToArray()：此方法返回类型是数组，它返回数组中优先级队列的所有元素。

Object[] arr1 = pQueue.toArray() ; //this will store all the elements of the priority queue pQueue in an array arr1, therefore we can traverse the elements using simple array traversal

• 比较器比较器()：此方法将返回用于订购优先级队列元素的比较器，如果队列遵循自然排序，则返回NULL值。

pQueue.comparator() ; //if pQueue is the Priority queue given in the diagram above then it will return NULL, because it follows natural ordering.

创建优先级

现在，自从我们讨论了优先级队列类的所有基本操作，方法和构造函数，让我们看看如何以不同的方式实现它们，

由于，对于整数类型，它易于区分，让我们为字符串类型实现。

我们将看到优先级如何改变一些最畅销书籍的顺序

使用No-Arg构造函数(自然排序)

在这个程序中，我们创建了一个没有比较器的字符串类型的优先级，因此它将使用自然排序，这将根据字典(按字母顺序)，添加了几个字符串值以了解工作。
我们还可以在此处查看添加()的应用程序和删除()。

代码 ：

package org.igi.theitroad.theitroadPrograms;
import java.util.PriorityQueue;
 
import java.util.PriorityQueue;
 
public class PriorityQueueMain {
    public static void main (String[] args) {
        //Creating a Priority Queue of String Type
        PriorityQueue<String> pQueue = new PriorityQueue<>() ;
 
        //Adding the items to a Priority Queue (ENQUEUE) using add()
        pQueue.add("Don Quixote") ;
        pQueue.add("The Master and Margarita") ;
        pQueue.add("The Hobbit") ;
        pQueue.add("Dream of the Red Chamber") ;
        pQueue.add("A Tale of Two Cities") ;
        pQueue.add("And Then There Were None") ;
 
        //Removing and printing items from the Priority Queue (DEQUEUE) using remove()
        while (!pQueue.isEmpty()) {
            System.out.println(pQueue.remove()) ;
        }
 
    }
}

输出：

A Tale of Two Cities
And Then There Were None
Don Quixote
Dream of the Red Chamber
The Hobbit
The Master and Margarita

使用自定义比较器

在此程序中，我们已经通过使用正确的语法单独指定的自定义比较器来实现优先级，其中我们可以看到我们如何根据书籍的数量优先考虑。

代码 ：

package org.igi.theitroad.theitroadPrograms;
 
import java.util.Comparator;
import java.util.PriorityQueue;
 
class Book {
    String bookName;
    int pages;
 
    public Book(String name, int pages) {
        this.bookName = name;
        this.pages = pages;
    }
 
    @Override
    public String toString() {
        return "Book name is : " + bookName + " and number of pages are :" + pages;
    }
}
 
class byPages implements Comparator<Book> {
    @Override
    public int compare(Book st1, Book st2) {
        return st2.pages - st1.pages;
    }
}
 
public class PriorityQueueMainComparator {
    public static void main(String[] args) {
        byPages comp = new byPages();
        //Adding elements in pQueue using offer, we can also use add()
        PriorityQueue<Book> pQueue = new PriorityQueue<Book>(10, comp);
        pQueue.offer(new Book("A Tale of Two Cities", 322));
        pQueue.offer(new Book("The Master and Margarita", 444));
        pQueue.offer(new Book("Don Quixote", 246));
        pQueue.offer(new Book("And Then There Were None", 342));
        pQueue.offer(new Book("Think and Grow Rich", 401));
        pQueue.offer(new Book("The Hobbit", 276));
        pQueue.offer(new Book("Dream of the Red Chamber", 378));
 
        //Removing the head elements using poll to print in order according to the
        //implemented comparator
        System.out.println(pQueue.poll());
        System.out.println(pQueue.poll());
        System.out.println(pQueue.poll());
        System.out.println(pQueue.poll());
        System.out.println(pQueue.poll());
        System.out.println(pQueue.poll());
        System.out.println(pQueue.poll());
    }
}