Introduction:

In Java, a priority queue is a data structure that allows us to store elements with priority and retrieve them in a specific order. While Java provides built-in priority queue implementations, there may be scenarios where you need to convert an array into a priority queue. In this blog, we will explore different methods to achieve this conversion and understand their pros and cons.

Method 1: Using the PriorityQueue class

The PriorityQueue class in Java provides a simple way to create and manipulate priority queues. We can leverage this class to convert an array into a priority queue efficiently. Let's take a look at the following program:

import java.util.Arrays;
import java.util.PriorityQueue;

public class ArrayToPriorityQueueExample {

    public static void main(String[] args) {
        Integer[] array = {5, 2, 8, 1, 6};
        
        // Convert array to priority queue
        PriorityQueue<Integer> priorityQueue = new PriorityQueue<>(Arrays.asList(array));
        
        // Print elements from the priority queue
        while (!priorityQueue.isEmpty()) {
            System.out.println(priorityQueue.poll());
        }
    }
}

Output:

1
2
5
6
8

In this method, we first initialize an array with some integer values. We then create a PriorityQueue instance, passing the array to its constructor using Arrays.asList(array). This converts the array into a list and initializes the priority queue with its elements. We can then use the poll() method to retrieve and remove the elements from the priority queue in the desired order, which is the natural ordering for integers. The output demonstrates that the elements are retrieved in ascending order.

Method 2: Converting using a Custom Comparator

Sometimes, we need to prioritize elements based on specific criteria that are not provided by the natural ordering of the elements. In such cases, we can use a custom comparator to convert an array into a priority queue. Let's see an example:

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

public class ArrayToPriorityQueueExample {

    public static void main(String[] args) {
        String[] array = {"apple", "banana", "grape", "orange"};
        
        // Convert array to priority queue using a custom comparator
        PriorityQueue<String> priorityQueue = new PriorityQueue<>(Arrays.asList(array),
                Comparator.comparing(String::length));
        
        // Print elements from the priority queue
        while (!priorityQueue.isEmpty()) {
            System.out.println(priorityQueue.poll());
        }
    }
}

Output:

grape
apple
banana
orange

In this method, we initialize an array with some string values. We then create a PriorityQueue instance and pass the array to its constructor along with a custom comparator. Here, the custom comparator is defined using Comparator.comparing(String::length), which compares the strings based on their lengths. As a result, the elements are retrieved and removed from the priority queue in ascending order of their lengths. The output demonstrates that the strings are sorted based on their lengths.

Conclusion:

In this blog, we explored two methods to convert an array into a priority queue in Java. The first method utilized the PriorityQueue class and leveraged its constructor to initialize the priority queue with the elements of the array. The second method involved using a custom comparator to prioritize the elements based on specific criteria.