Custom Comparator for a Specific Element type in a PriorityQueue in Java
PriorityQueue in Java is a data structure that stores elements according to their specified natural order or comparison. By default, it uses a natural order, but we can also define customized comparisons to sort things out based on specific criteria.
Custom Comparator in PriorityQueue
A Custom Comparator in Java is an interface that defines a method for comparing two objects. It allows us to specify a custom sort for elements that do not have a natural order or when we want to override the default sort. Using a Comparator, we can provide our logic to compare items in a PriorityQueue and determine their priority.
Steps to Implement a Custom Comparator
Follow these steps to create a customized comparison for a specific element type in a PriorityQueue in Java.
- Create a class that implements the Comparator interface and specifies the element type we want to compare. Let’s call this class GFG.
- Use the comparison method from the Comparator interface of the GFG class.
- This method takes two parameters representing the elements to be compared and returns an integer value based on the comparison result. The returned value must follow this rule.
- Returns a negative integer if the first element should be greater than the first.
- If the first element should be redundant, a positive integer is returned.
- Returns zero if the elements have the same priority.
- Create an instance of PriorityQueue and pass an instance of the GFG class to its constructor. This will cause PriorityQueue to use our custom comparison according to object order.
- Add elements to the PriorityQueue using the add or offer method. A custom comparator is used to determine the order of the items in the queue.
Program to Implement a Custom Comparator for a Specific Element type in a PriorityQueue in Java
Below is an example of how to implement a custom comparator for a specific element type in a PriorityQueue in Java:
// Java program to Implement a Custom Comparator
import java.util.*;
// Define a class representing a Person
class Person
{
private String name;
private int age;
// Constructor to initialize name and age
public Person(String name, int age)
{
this.name = name;
this.age = age;
}
// Getter method for name
public String getName()
{
return name;
}
// Getter method for age
public int getAge()
{
return age;
}
}
// Define a custom comparator to compare Person objects
// based on age
class AgeComparator implements Comparator<Person>
{
@Override
// Override the compare method to define custom
// comparison logic
public int compare(Person p1, Person p2)
{
// Compare persons based on their ages
return p1.getAge() - p2.getAge();
}
}
// Driver Class
public class GFG
{
// Main Function
public static void main(String[] args)
{
// Create a PriorityQueue with a custom comparator
// for Person objects
PriorityQueue<Person> queue
= new PriorityQueue<>(new AgeComparator());
// Create some Person objects
Person person1 = new Person("Sushmita", 25);
Person person2 = new Person("Alekya", 30);
Person person3 = new Person("Geetha", 20);
// Add Person objects to the PriorityQueue
queue.offer(person1);
queue.offer(person2);
queue.offer(person3);
// Poll elements from the PriorityQueue and print
// their details
while (!queue.isEmpty())
{
Person person = queue.poll();
System.out.println("Name: " + person.getName()
+ ", Age: "
+ person.getAge());
}
}
}
Output
Name: Geetha, Age: 20 Name: Sushmita, Age: 25 Name: Alekya, Age: 30
Explanation of the Program:
- We created a PriorityQueue of Person objects.
- Then we have used the AgeComparator as a custom comparator.
- The Person objects were ordered based on their age, resulting in the output being sorted in ascending order of age.