Java PriorityQueue Class

---

---

Introduction

The Java PriorityQueue class is an unbounded priority queue based on a priority heap. The elements are not based on their insertion order, but rather they are based on the priority of the elements.

The PriorityQueue depends on an array of objects, and this array is auto-resized if the capacity is not enough to store the elements. The PriorityQueue class takes O(log_n) time for the operations of enqueuing and dequeuing methods in the PriorityQueue.

Characteristics

The following are the important points about PriorityQueue in Java −

• The elements of the priority queue are ordered according to their natural ordering, or by a Comparator provided at queue construction time, depending on which constructor is used.
• A priority queue does not permit null elements.
• A priority queue relying on natural ordering also does not permit insertion of non-comparable objects.

Class Declaration

The following is the declaration for java.util.PriorityQueue class −

public class PriorityQueue<E>
   extends AbstractQueue<E>
   implements Serializable

Parameter −

E − This is the type of elements held in this collection.

How to Implement the PriorityQueue Class?

The following are the steps to implement a PriorityQueue class in Java −

Step 1

In Java, to implement or use a PriorityQueue class, we first need to import the java.util.PriorityQueue or java.util.* package to use the PriorityQueue class.

import java.util.PriorityQueue
//OR
import java.util.*

Step 2

After importing the PriorityQueue class, we will instantiate the PriorityQueue and create its object named "pqueue".

PriorityQueue<Datatype> pqueue = new PriorityQueue<Datatype>();

Step 3

Now we operate on the PriorityQueue, above "Datatype" is the type of the object to be stored in the Queue. To add elements to the PriorityQueue class, we use either the add() or offer() methods.

PriorityQueue<Integer> pqueue = new PriorityQueue<Integer> ();
pqueue.add(20);
pqueue.offer(35);

Here, we have created a PriorityQueue of integers and, using the add() and offer() methods, we add "20" and "35" respectively to the PriorityQueue.

Example of PriorityQueue Class

Below is an example of the PriorityQueue class to show its basic operations in Java −

package com.tutorialspoint;

import java.util.PriorityQueue;

public class PriorityQueueDemo {
   public static void main(String[] args) {
      
      // create an empty priority queue with no initial capacity
      PriorityQueue<Integer> pqueue = new PriorityQueue<>();

      // use offer() method to add elements to the queue
      pqueue.offer(10);
      pqueue.offer(35);
      pqueue.offer(20);
      
      System.out.println("The head of the queue is: " + pqueue.peek());
      System.out.println("The removed element is: " + pqueue.poll());
      System.out.println("The queue is: " + pqueue);
      
    }
}

Output

Let us compile and run the above program. This will produce the following result −

The head of the queue is: 10
The removed element is: 10
The queue is: [20, 35]

Class Constructors

The following are the class constructors present in the PriorityQueue class −

Class Methods

The following are the supported methods in the PriorityQueue class −

Methods inherited

This class inherits methods from the following classes in Java −

• java.util.AbstractQueue
• java.util.AbstractCollection
• java.util.Object
• java.util.Collection

Adding an Item to a PriorityQueue Example

The following example shows the usage of the Java PriorityQueue add(E) method to add Integers. We're adding a couple of Integers to the PriorityQueue object using the add() method calls per element, and then printing each element to show the elements added.

package com.tutorialspoint;

import java.util.PriorityQueue;

public class PriorityQueueDemo {
   public static void main(String[] args) {
      
      // create an empty priority queue with an initial capacity
      PriorityQueue<Integer> queue = new PriorityQueue<>(5);

      // use add() method to add elements in the queue
      queue.add(20);
      queue.add(30);
      queue.add(20);
      queue.add(30);
      queue.add(15);
      queue.add(22);
      queue.add(11);

      // let us print all the elements available in queue
      for (Integer number : queue) {
         System.out.println("Number = " + number);
      }
   }
}

Output

Let us compile and run the above program. This will produce the following result −

Number = 11
Number = 20
Number = 15
Number = 30
Number = 30
Number = 22
Number = 20

PriorityQueue using Custom Comparator

The PriorityQueue with a custom comparator allows us to define the ordering rule for the elements instead of depending upon the default natural ordering. Using the Comparator.reverseOrder(), we can make it work like a Max-Heap, where top priority is given to the highest value.

Example

Below is an example of the PriorityQueue class using the custom comparator in Java −

package com.tutorialspoint;

import java.util.PriorityQueue;
import java.util.Comparator;

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

      // create an empty priority queue with a custom comparator
      PriorityQueue<Integer> queue = new PriorityQueue<>(5, Comparator.reverseOrder());

      // use add() method to add elements in the queue
      queue.add(20);
      queue.add(30);
      queue.add(20);
      queue.add(30);
      queue.add(15);
      queue.add(22);
      queue.add(11);

      // let us print all the elements available in queue
      for (Integer number : queue) {
         System.out.println("Number = " + number);
      }
   }
}

Output

Let us compile and run the above program. This will produce the following result −

Number = 30
Number = 30
Number = 22
Number = 20
Number = 15
Number = 20
Number = 11