PriorityQueue in Java

A PriorityQueue in Java is a queue where elements are ordered based on their priority, rather than the order of insertion. By default, it uses natural ordering (min-heap), but a custom comparator can be used to define different priorities.

• Elements are processed based on priority rather than insertion order.
• Supports standard queue operations like add(), poll(), and peek().
• Automatically grows as elements are added.
• Uses a heap data structure internally to ensure efficient insertion and removal of the highest-priority element.

Declaration of PriorityQueue

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

where, E is the type of elements held in this queue.

import java.util.PriorityQueue;

public class Geeks 
{
    public static void main(String[] args) 
    {
      	// Priority Queue Min Type
        PriorityQueue<Integer> p = new PriorityQueue<>();

        // Add elements to the queue
        p.add(3);
        p.add(10);
        p.add(7);
        p.add(2);

        // Print the head of the queue
        System.out.println("Head of Queue: " + p.peek());
    }
}

Head of Queue: 2

Hierarchy of PriorityQueue

It implements the Queue interface which extends the Collection Interface.

Constructors of PriorityQueue

1. PriorityQueue()

This method creates a PriorityQueue with the default initial capacity (11) that orders its elements according to their natural ordering.

PriorityQueue<E> pq = new PriorityQueue<E>();

2. PriorityQueue(int initialCapacity)

This creates a PriorityQueue with the specified initial capacity that orders its elements according to their natural ordering.

PriorityQueue<E> pq = new PriorityQueue<E>(int initialCapacity);

3. PriorityQueue(Comparator<E> comparator)

This creates a PriorityQueue with the default initial capacity and whose elements are ordered according to the specified comparator.

PriorityQueue<E> pq = new PriorityQueue<E>(Comparator<E> c);

4. PriorityQueue(int initialCapacity, Comparator<E> comparator)

This creates a PriorityQueue with the specified initial capacity that orders its elements according to the specified comparator.

PriorityQueue<E> pq = new PriorityQueue<E>(int initialCapacity, Comparator<E> comparator);

Different Operations on PriorityQueue

Let’s see how to perform a few frequently used operations on the Priority Queue class.

1. Adding Elements

To add an element in a priority queue, we can use the add() method.

import java.util.*;
  
public class Geeks
{  
    public static void main(String args[])
    {
        PriorityQueue<Integer> pq = new PriorityQueue<>();
        
      	for(int i=0;i<3;i++){
            pq.add(i);
            pq.add(1);
        }
      
        System.out.println(pq);
    }
}

[0, 1, 1, 1, 2, 1]

2. Removing Elements

To remove an element from a priority queue, we can use the remove() method.

import java.util.*;
import java.io.*;

public class Geeks {

    public static void main(String args[])
    {
        PriorityQueue<String> pq = new PriorityQueue<>();

        pq.add("Geeks");
        pq.add("For");
        pq.add("Geeks");

        System.out.println("Initial PriorityQueue " + pq);

        // using the method
        pq.remove("Geeks");

        System.out.println("After Remove: " + pq);

        System.out.println("Poll Method: " + pq.poll());

        System.out.println("Final PriorityQueue: " + pq);
    }
}

Initial PriorityQueue [For, Geeks, Geeks]
After Remove: [For, Geeks]
Poll Method: For
Final PriorityQueue: [Geeks]

3. Accessing the Elements

To access elements from a priority queue, we can use the peek() method.

import java.util.*;

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

        PriorityQueue<String> pq = new PriorityQueue<>();
        pq.add("Geeks");
        pq.add("For");
        pq.add("Geeks");
        System.out.println("PriorityQueue: " + pq);

        // Using the peek() method
        String element = pq.peek();
        System.out.println("Accessed Element: " + element);
    }
}

PriorityQueue: [For, Geeks, Geeks]
Accessed Element: For

4. Iterating the PriorityQueue

There are multiple ways to iterate through the PriorityQueue. The most famous way is converting the queue to the array and traversing using an iterator. Iterator does not traverse in priority order.

import java.util.*;

public class Geeks {
    public static void main(String args[])
    {
        PriorityQueue<String> pq = new PriorityQueue<>();

        pq.add("Geeks");
        pq.add("For");
        pq.add("Geeks");

        Iterator iterator = pq.iterator();

        while (iterator.hasNext()) {
            System.out.print(iterator.next() + " ");
        }
    }
}

For Geeks Geeks 

Methods of PriorityQueue

Methods Declared in Interface java.util.Queue

Methods Declared in Class java.util.AbstractQueue

Methods Declared in Class java.util.AbstractCollection

Methods Declared in Interface java.util.Collection

Applications of PriorityQueue

• Implementing Dijkstra's and Prim's algorithms.
• Maximize array sum after K negation

PriorityQueue in Java

Visit Course