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.

• Supports standard queue operations like add(), poll(), and peek().
• Automatically grows as elements are added and null insertion is not possible .
• Uses a heap data structure internally to ensure efficient insertion and removal of the highest-priority element.

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

Declaration of PriorityQueue

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

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

Hierarchy of PriorityQueue

PriorityQueue extends AbstractQueue and implements the Queue interface, which is part of the Collection hierarchy. It also supports iteration through Iterable

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>(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.

Comparator<Integer> c = (a, b) -> b - a; // max-heap
PriorityQueue<Integer> pq = new PriorityQueue<>(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<String> 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