How to use Java PriorityQueue with Examples

https://grokonez.com/java/how-to-use-java-priorityqueue-with-examples

[no_toc]In the tutorial, Grokonez introduces how to work with Java PriorityQueue by examples:

• How does Java PriorityQueue work?
• Explore Java PriorityQueue Hierarchy
• Create Java PriorityQueue with Integer, String, and Custom Object Class

Related posts:

• Java TreeMap with Examples

Java PriorityQueue

• Java PriorityQueue is an unbounded priority queue.
• The elements of the priority queue are ordered according to their natural ordering, or by a Comparator.
  • The front of the priority queue contains the least element.
  • And the rear of the priority queue contains the greatest element.

• PriorityQueue does not permit null elements.
• PriorityQueue does not permit insertion of non-comparable objects. ClassCastException will be throwed.
• The head of this queue is the least element. The queue operations poll, remove, peek, and element access the element at the head of the queue.
• Java PriorityQueue is not synchronized. Multiple threads should not access the same PriorityQueue concurrently if having any of the threads modifies the queue.

  Java PriorityQueue Hierarchy

Java PriorityQueue with Integer Example

In the follwing example, We create an Integer Java PriorityQueue, then do a list operations on the queue:

• Insert an element to PriorityQueue with offer and add method.
• Retrieve a head value of the Queue, but NOT remove it by peek() method.
• Removes a single instance of the specified element from this queue by remove(Object o) method.
• Retrieves and removes the head of this queue by poll() method.

Example:

import java.util.PriorityQueue;
import java.util.Queue;

public class JavaPriorityQueueExamples {

    public static void main(String[] args) {
        Queue intQueue = new PriorityQueue();
        // Inserts the specified element into this priority queue.
        intQueue.offer(10);
        intQueue.offer(1);
        intQueue.offer(5);
        intQueue.offer(9);
        
        // E poll(): Retrieves and removes the head of this queue
        System.out.println(intQueue.remove());
        /*
         * 1
         */
        
        // Retrieves, but does not remove, the head of this queue
        int head = intQueue.peek();
        System.out.println("headValue = " + head); // headValue = 5
        
        // Inserts the specified element into this priority queue.
        intQueue.add(7);
        intQueue.add(2);
        
        head = intQueue.element();
        System.out.println("headValue = " + head); // headValue = 2
        
        // Removes a single instance of the specified element from this queue, if it is present.
        boolean containOrNot = intQueue.remove(9);
        System.out.println(containOrNot); // true
        
        System.out.println("---");
        
        while(!intQueue.isEmpty()) {
            System.out.println(intQueue.poll());
        }
        
        /*
         * 2
         * 5
         * 7
         * 10
         */
    }
}

• In above example, we use PriorityQueue() Constructor to create a PriorityQueue with the default initial capacity (11) that orders its elements according to their natural ordering.

• add() and offer() method, both can insert an element to a PriorityQueue, But what is the difference?

• The offer method inserts an element if possible, otherwise returning false.

• This differs from the Collection.add method, which can fail to add an element only by throwing an unchecked exception.

• The remove() and poll() methods remove and return the head of the queue.
  -> BUT when the queue is empty, the remove() method throws an exception, while the poll() method returns null.

• The element() and peek() retrive the head's value of the queue and NOT remove. When the queue is empty:

• element() throws NoSuchElementException.

• peek() returns null.

Now we do an example to iterate all elements of a Java PriorityQueue:

• using iterator(): to return an iterator over the elements in the queue.
• using toArray(): to return an array containing all the elements in the queue.

import java.util.Iterator;
import java.util.PriorityQueue;
import java.util.Queue;

public class JavaPriorityQueueExamples{

    public static void main(String[] args) {
        Queue<Integer> intQueue = new PriorityQueue<Integer>();
        // Inserts the specified element into this priority queue.
        intQueue.offer(10);
        intQueue.offer(1);
        intQueue.offer(5);
        intQueue.offer(9);
        
        // Returns an iterator over the elements in this queue.
        Iterator<Integer> intIterator = intQueue.iterator();
        
        while (intIterator.hasNext()) 
            System.out.print(intIterator.next() + " ");
        /*
         * 1 9 5 10 
         */
        
        System.out.println();
        
        // Returns an array containing all of the elements in this queue.
        Object[] intArr =  intQueue.toArray();
        for(int i=0; i<intArr.length; i++) {
            System.out.print(intArr[i] + " ");
        }
        /*
         * 1 9 5 10 
         */
    }
}

Java PriorityQueue with String Example

• Example: Create Java String PriorityQueue using Natural Ordering of String

import java.util.PriorityQueue;
import java.util.Queue;

public class JavaPriorityQueueExamples {

    public static void main(String[] args) {
        Queue strQueue = new PriorityQueue();
        
        // Inserts the specified element into this priority queue.
        strQueue.offer("Jack");
        strQueue.offer("Charlie");
        strQueue.offer("Joe");
        strQueue.offer("George");
        
        while(!strQueue.isEmpty()) {
            System.out.print(strQueue.poll() + " ");
        }
        
        /*
         * -> Charlie George Jack Joe   
         */
    }
}

Create Java PriorityQueue with a custom Comparator

• Create a Java PriorityQueue using a Custom Comparator that compares two Strings by their length:

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

public class JavaPriorityQueueExamples {

    public static void main(String[] args) {
        Queue strQueue = new PriorityQueue((Comparator super String>) new Comparator() {
            public int compare(String s1, String s2) {
                return s1.length() - s2.length();
            }
        });
        
        // Inserts the specified element into this priority queue.
        strQueue.offer("Jack");
        strQueue.offer("Charlie");
        strQueue.offer("Joe");
        strQueue.offer("George");
        
        while(!strQueue.isEmpty()) {
            System.out.print(strQueue.poll() + " ");
        }
    }
}

-> Output:

Joe Jack George Charlie

Java PriorityQueue with Custom Object Example

• Create an Java Developer class:

class Developer{
    Integer id;
    String name;
    Double salary;
    
    public Developer(Integer id, String name, Double salary){
        this.id = id;
        this.name = name;
        this.salary = salary;
    }
    
    public int getId() {
        return this.id;
    }
    
    public String getName() {
        return this.name;
    }
    
    public Double getSalary() {
        return this.salary;
    }
    
    public String toString() {
        return String.format("[id = %d, name = %s, salary = %.2f]", id, name, salary);
    }
}

• Implement Comparable interface to compare its elements and order them accordingly as below:

class Developer implements Comparable{
    ...
    
    @Override
    public int compareTo(Developer d) {
        if(this.getSalary() > d.getSalary()) {
            return 1;
        } else if (this.getSalary() < d.getSalary()) {
            return -1;
        } else {
            return 0;
        }
    }
}

• Create a Java PriorityQueue Example with Developer class:

import java.util.PriorityQueue;
import java.util.Queue;

public class JavaPriorityQueueExamples {

    public static void main(String[] args) {
        Queue devQueue = new PriorityQueue();
        
        // Inserts the specified element into this priority queue.
        devQueue.offer(new Developer(1, "Jack", 6000.0));
        devQueue.offer(new Developer(4, "Joe", 7000.0));
        devQueue.offer(new Developer(10, "Davis", 6500.0));
        devQueue.offer(new Developer(6, "Mary", 5700.0));
        
        while(!devQueue.isEmpty()) {
            System.out.println(devQueue.poll());
        }       
    }
}

-> Output:

/*
 * [id = 6, name = Mary, salary = 5700,00]
 * [id = 1, name = Jack, salary = 6000,00]
 * [id = 10, name = Davis, salary = 6500,00]
 * [id = 4, name = Joe, salary = 7000,00]
 */

-> The Developer with smallest salary is removed first

Conclusion

We had learned how to work with Java PriorityQueue by examples:

• Create Java PriorityQueue with Natural Ordering of Elements.
• Create Java PriorityQueue with Custom Comparator.
• Create Java PriorityQueue with Custom Object that implements Comparable interface.
• Do a list operations of Java PriorityQueue: offer, peek, poll, remove...

Happy Learning! See you later!