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 and null insertion is not possible .
• 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, Iterable<E>

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

Head of Queue: 2

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.

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

2. Removing Elements

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

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.

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.

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