PriorityQueue Comparator in Java allows you to customize element prioritization. COMPARE.EDU.VN offers comprehensive guides that illuminate the application of comparators in Java PriorityQueues, enhancing your ability to manage data structures efficiently. Explore data sorting and custom ordering strategies with ease.
1. Introduction: PriorityQueue and Comparators
A PriorityQueue in Java is a class that implements a priority queue based on the priority heap data structure. The elements are ordered according to their natural ordering, or by a Comparator provided at queue construction time, depending on which constructor is used. This means that the elements are retrieved in order of priority, where the highest priority element is retrieved first. Understanding how to effectively use a Comparator with a PriorityQueue is crucial for tailoring data structures to specific needs. Using a Comparator allows for custom sorting logic, enabling more flexible data management within your Java applications. For developers aiming to optimize data handling, knowing how to implement a comparator is essential. Let’s explore this further, and see how COMPARE.EDU.VN can guide you.
2. Understanding PriorityQueue in Java
PriorityQueue is a class in Java that implements the Queue interface. It’s part of the Java Collections Framework and provides a way to store and retrieve elements based on their priority. Unlike standard queues where elements are processed in a FIFO (First-In-First-Out) manner, a PriorityQueue orders elements based on either their natural ordering or a custom ordering defined by a Comparator.
2.1. Definition and Purpose
A PriorityQueue is essentially a heap-based data structure. This means that it maintains a partial ordering of its elements such that the element with the highest priority (or lowest, depending on the implementation) is always at the front of the queue. This makes it very efficient for retrieving elements in order of priority.
2.2. How PriorityQueue Works
The internal structure of a PriorityQueue is typically a binary heap. This heap ensures that the element at the root (the front of the queue) has the highest priority. When you add an element to the queue, it’s placed in the heap, and the heap structure is adjusted to maintain the priority order. When you retrieve an element (using poll() or peek()), the highest priority element is returned, and the heap is re-organized.
2.3. Default Ordering: Natural Ordering
By default, a PriorityQueue uses the natural ordering of its elements. This means that the elements must implement the Comparable interface. The compareTo() method of the Comparable interface is used to determine the order of the elements. For example, if you add integers to a PriorityQueue, they will be ordered from smallest to largest by default, as integers implement the Comparable interface and their natural ordering is numeric.
3. What is a Comparator in Java?
A Comparator is an interface in Java that is used to define a custom ordering for objects. It’s part of the java.util package and provides a way to sort objects based on specific criteria. When the natural ordering of objects is not sufficient, or when you want to sort objects in a different way, you can use a Comparator.
3.1. Definition and Purpose
The Comparator interface defines a single method, compare(Object o1, Object o2), which compares two objects and returns an integer value. The return value indicates the relative order of the two objects:
- A negative value means
o1comes beforeo2. - A positive value means
o1comes aftero2. - Zero means
o1ando2are equal in terms of ordering.
3.2. Implementing the Comparator Interface
To use a Comparator, you need to create a class that implements the Comparator interface and provides an implementation for the compare() method. This implementation defines the custom ordering logic.
3.3. Using Comparators for Custom Sorting
Comparators are often used with methods like Collections.sort() or Arrays.sort() to sort lists or arrays of objects. They can also be used with data structures like TreeSet and TreeMap to maintain elements in a sorted order based on the custom ordering.
4. The Role of Comparator in PriorityQueue
The Comparator interface plays a crucial role in how PriorityQueue orders its elements. When you create a PriorityQueue, you can provide a Comparator to define a custom ordering. This is especially useful when the elements do not have a natural ordering or when you want to sort them in a way that is different from their natural ordering.
4.1. Overriding Natural Ordering
By providing a Comparator to the PriorityQueue constructor, you can override the natural ordering of the elements. This allows you to sort elements based on any criteria you choose.
4.2. Custom Sorting Logic
The Comparator’s compare() method defines the custom sorting logic. This method takes two elements as input and returns an integer value indicating their relative order. The PriorityQueue uses this value to maintain the correct order of elements in the queue.
4.3. Flexibility in Element Prioritization
Using a Comparator with PriorityQueue gives you a great deal of flexibility in how you prioritize elements. You can sort elements based on multiple criteria, or based on criteria that are not directly related to the elements’ natural properties.
5. How to Use Comparator with PriorityQueue in Java
To use a Comparator with a PriorityQueue, you need to follow a few steps: first, create a class that implements the Comparator interface; second, provide an implementation for the compare() method; and third, pass an instance of your Comparator class to the PriorityQueue constructor.
5.1. Steps to Implement Comparator with PriorityQueue
- Create a Comparator Class: Define a class that implements the
java.util.Comparatorinterface. - Implement the
compare()Method: Implement thecompare(Object o1, Object o2)method to define your custom sorting logic. - Pass the Comparator to PriorityQueue: Create an instance of your Comparator class and pass it to the PriorityQueue constructor.
5.2. Example: Sorting Strings by Length
Let’s say you want to create a PriorityQueue of Strings and sort them by their length instead of their natural alphabetical order. Here’s how you can do it:
import java.util.Comparator;
import java.util.PriorityQueue;
public class StringLengthComparator implements Comparator<String> {
@Override
public int compare(String s1, String s2) {
return s1.length() - s2.length();
}
public static void main(String[] args) {
PriorityQueue<String> pq = new PriorityQueue<>(new StringLengthComparator());
pq.add("apple");
pq.add("banana");
pq.add("kiwi");
pq.add("orange");
while (!pq.isEmpty()) {
System.out.println(pq.poll());
}
}
}In this example, the StringLengthComparator class implements the Comparator interface and compares two Strings based on their lengths. The PriorityQueue is created with an instance of this Comparator, so the Strings are ordered by length when they are retrieved from the queue.
5.3. Example: Sorting Objects by Multiple Fields
You can also sort objects based on multiple fields using a Comparator. For example, let’s say you have a class called Person with fields for name and age. You can create a Comparator to sort people first by age and then by name:
import java.util.Comparator;
import java.util.PriorityQueue;
class Person {
String name;
int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + ''' +
", age=" + age +
'}';
}
}
class PersonComparator implements Comparator<Person> {
@Override
public int compare(Person p1, Person p2) {
if (p1.age != p2.age) {
return p1.age - p2.age; // Sort by age
} else {
return p1.name.compareTo(p2.name); // Then sort by name
}
}
}
public class Main {
public static void main(String[] args) {
PriorityQueue<Person> pq = new PriorityQueue<>(new PersonComparator());
pq.add(new Person("Alice", 30));
pq.add(new Person("Bob", 25));
pq.add(new Person("Charlie", 30));
pq.add(new Person("David", 25));
while (!pq.isEmpty()) {
System.out.println(pq.poll());
}
}
}In this example, the PersonComparator class implements the Comparator interface and compares two Person objects first by age and then by name. The PriorityQueue is created with an instance of this Comparator, so the Person objects are ordered accordingly.
6. Benefits of Using Comparator with PriorityQueue
Using a Comparator with a PriorityQueue offers several benefits, including custom sorting, flexibility, and the ability to handle complex data structures.
6.1. Custom Sorting Based on Specific Needs
One of the main benefits of using a Comparator is that it allows you to sort elements based on your specific needs. You are not limited to the natural ordering of the elements.
6.2. Flexibility in Handling Complex Data Structures
Comparators provide flexibility in handling complex data structures. You can define custom sorting logic for objects with multiple fields or for objects that don’t have a natural ordering.
6.3. Improved Code Readability and Maintainability
Using a Comparator can improve code readability and maintainability. By encapsulating the sorting logic in a separate class, you can make your code more modular and easier to understand.
7. Common Use Cases for Comparator with PriorityQueue
There are many common use cases for using a Comparator with a PriorityQueue, including task scheduling, event management, and graph algorithms.
7.1. Task Scheduling
In task scheduling, you can use a PriorityQueue to store tasks and prioritize them based on their priority. A Comparator can be used to define the priority of the tasks based on factors such as deadline, importance, or resource requirements.
7.2. Event Management
In event management, you can use a PriorityQueue to store events and prioritize them based on their start time. A Comparator can be used to define the order of the events based on their start time, duration, or other relevant criteria.
7.3. Graph Algorithms (e.g., Dijkstra’s Algorithm)
In graph algorithms like Dijkstra’s algorithm, you can use a PriorityQueue to store nodes and prioritize them based on their distance from the starting node. A Comparator can be used to define the order of the nodes based on their distance.
8. Potential Pitfalls and How to Avoid Them
While using a Comparator with a PriorityQueue is powerful, there are some potential pitfalls to be aware of. These include NullPointerException, inconsistent comparisons, and performance considerations.
8.1. Handling Null Values
When using a Comparator, you need to be careful about handling null values. If your Comparator doesn’t handle null values properly, it may throw a NullPointerException.
Solution: Ensure that your Comparator handles null values gracefully. You can add null checks to your compare() method to avoid NullPointerException.
import java.util.Comparator;
import java.util.PriorityQueue;
class NullSafeStringComparator implements Comparator<String> {
@Override
public int compare(String s1, String s2) {
if (s1 == null && s2 == null) {
return 0;
} else if (s1 == null) {
return -1; // Null comes before non-null
} else if (s2 == null) {
return 1; // Non-null comes before null
} else {
return s1.compareTo(s2);
}
}
}
public class Main {
public static void main(String[] args) {
PriorityQueue<String> pq = new PriorityQueue<>(new NullSafeStringComparator());
pq.add("apple");
pq.add(null);
pq.add("banana");
while (!pq.isEmpty()) {
System.out.println(pq.poll());
}
}
}In this example, the NullSafeStringComparator handles null values by placing them at the beginning or end of the queue.
8.2. Inconsistent Comparisons
Inconsistent comparisons can lead to unexpected behavior in your PriorityQueue. If your Comparator doesn’t provide a consistent ordering, the PriorityQueue may not function correctly.
Solution: Ensure that your Comparator provides a consistent ordering. The compare() method should satisfy the following properties:
- Symmetry: If
compare(a, b)returns a negative value, thencompare(b, a)should return a positive value, and vice versa. - Transitivity: If
compare(a, b)returns a negative value andcompare(b, c)returns a negative value, thencompare(a, c)should return a negative value. - Reflexivity:
compare(a, a)should return zero.
8.3. Performance Considerations
Using a complex Comparator can impact the performance of your PriorityQueue. The compare() method is called frequently, so it should be as efficient as possible.
Solution: Keep your Comparator’s compare() method simple and efficient. Avoid complex calculations or I/O operations. If necessary, consider caching the results of expensive calculations.
9. Advanced Comparator Techniques
To further enhance your use of Comparators with PriorityQueue, consider using chained comparators and lambda expressions.
9.1. Chained Comparators
Chained comparators allow you to combine multiple comparators to sort elements based on multiple criteria. You can chain comparators together to create a more complex sorting logic.
import java.util.Comparator;
import java.util.PriorityQueue;
class Person {
String name;
int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + ''' +
", age=" + age +
'}';
}
}
class AgeComparator implements Comparator<Person> {
@Override
public int compare(Person p1, Person p2) {
return p1.age - p2.age;
}
}
class NameComparator implements Comparator<Person> {
@Override
public int compare(Person p1, Person p2) {
return p1.name.compareTo(p2.name);
}
}
class ChainedComparator implements Comparator<Person> {
private Comparator<Person>[] comparators;
public ChainedComparator(Comparator<Person>... comparators) {
this.comparators = comparators;
}
@Override
public int compare(Person p1, Person p2) {
for (Comparator<Person> comparator : comparators) {
int result = comparator.compare(p1, p2);
if (result != 0) {
return result; // Use this comparator's result
}
}
return 0; // All comparators returned equal
}
}
public class Main {
public static void main(String[] args) {
PriorityQueue<Person> pq = new PriorityQueue<>(new ChainedComparator(new AgeComparator(), new NameComparator()));
pq.add(new Person("Alice", 30));
pq.add(new Person("Bob", 25));
pq.add(new Person("Charlie", 30));
pq.add(new Person("David", 25));
while (!pq.isEmpty()) {
System.out.println(pq.poll());
}
}
}In this example, the ChainedComparator class combines the AgeComparator and NameComparator to sort Person objects first by age and then by name.
9.2. Lambda Expressions for Concise Comparators
Lambda expressions provide a concise way to define comparators. You can use lambda expressions to create simple comparators inline, without the need for a separate class.
import java.util.PriorityQueue;
class Person {
String name;
int age;
public Person(String name, int age) {
this.name = name;
this.age = age;
}
@Override
public String toString() {
return "Person{" +
"name='" + name + ''' +
", age=" + age +
'}';
}
}
public class Main {
public static void main(String[] args) {
PriorityQueue<Person> pq = new PriorityQueue<>(
(p1, p2) -> {
if (p1.age != p2.age) {
return p1.age - p2.age; // Sort by age
} else {
return p1.name.compareTo(p2.name); // Then sort by name
}
}
);
pq.add(new Person("Alice", 30));
pq.add(new Person("Bob", 25));
pq.add(new Person("Charlie", 30));
pq.add(new Person("David", 25));
while (!pq.isEmpty()) {
System.out.println(pq.poll());
}
}
}In this example, a lambda expression is used to define a comparator inline, which sorts Person objects first by age and then by name.
10. Performance Considerations When Using Comparators
While Comparators offer great flexibility, it’s important to consider their impact on performance, especially when dealing with large datasets.
10.1. Impact of Complex Comparison Logic
Complex comparison logic within a Comparator can significantly impact the performance of PriorityQueue operations. The compare() method is frequently invoked, and inefficient logic can slow down enqueueing and dequeueing operations.
Optimization Strategies:
- Simplify Comparison Logic: Keep the comparison logic as straightforward as possible. Avoid complex calculations or unnecessary operations.
- Cache Intermediate Results: If certain parts of the comparison involve computationally expensive operations, consider caching the results. However, be mindful of the memory overhead and cache invalidation.
10.2. Memory Overhead
Each Comparator instance consumes memory. When using many Comparators or creating them frequently, the memory overhead can become significant.
Optimization Strategies:
- Reuse Comparator Instances: Instead of creating new Comparator instances each time, reuse existing instances whenever possible. This can be achieved by creating a static instance of the Comparator class and using it across multiple PriorityQueue instances.
- Use Lambda Expressions Efficiently: When using lambda expressions for Comparators, ensure they don’t capture unnecessary context that could increase memory usage.
10.3. Benchmarking and Profiling
To understand the true performance impact of a Comparator, it’s essential to benchmark and profile your code. This involves measuring the execution time and memory usage of PriorityQueue operations with and without the Comparator.
Tools and Techniques:
- Java Microbenchmark Harness (JMH): JMH is a powerful tool for writing reliable microbenchmarks in Java. It allows you to measure the performance of small code snippets in a controlled environment.
- Profiling Tools: Tools like VisualVM or JProfiler can provide detailed insights into the performance of your application, including CPU usage, memory allocation, and garbage collection.
11. Best Practices for Using Comparator with PriorityQueue
To ensure that you are using Comparators with PriorityQueue effectively, follow these best practices:
11.1. Ensure Comparator Consistency
A Comparator should provide a consistent ordering of elements. This means that the compare() method should satisfy the properties of symmetry, transitivity, and reflexivity.
11.2. Handle Null Values Gracefully
Your Comparator should handle null values gracefully to avoid NullPointerException. Add null checks to your compare() method to ensure that it can handle null values.
11.3. Keep Comparators Simple and Efficient
Keep your Comparators simple and efficient. Avoid complex calculations or I/O operations in the compare() method.
12. Common Mistakes to Avoid
When working with Comparators and PriorityQueues, there are several common mistakes to avoid:
12.1. Ignoring Comparator Consistency
One of the most common mistakes is ignoring the consistency requirements of Comparators. If your Comparator doesn’t provide a consistent ordering, the PriorityQueue may not function correctly.
12.2. Neglecting Null Value Handling
Neglecting to handle null values can lead to NullPointerException when the Comparator encounters a null element. Always add null checks to your compare() method.
12.3. Overcomplicating Comparison Logic
Overcomplicating the comparison logic can lead to performance issues. Keep your Comparators simple and efficient to ensure optimal performance.
13. Comparing PriorityQueue with Other Data Structures
It’s important to understand how PriorityQueue compares to other data structures in Java, such as TreeSet and regular Queue implementations.
13.1. PriorityQueue vs. TreeSet
Both PriorityQueue and TreeSet maintain elements in a sorted order, but they have different characteristics:
- PriorityQueue: Implements a heap-based priority queue. It allows duplicate elements and provides O(log n) time complexity for enqueueing and dequeueing operations.
- TreeSet: Implements a sorted set using a tree structure. It does not allow duplicate elements and provides O(log n) time complexity for adding, removing, and checking the presence of elements.
Choose PriorityQueue when you need to allow duplicate elements and prioritize access to the highest or lowest priority element. Choose TreeSet when you need to maintain a sorted set of unique elements.
13.2. PriorityQueue vs. Regular Queue Implementations (LinkedList, ArrayDeque)
Regular Queue implementations like LinkedList and ArrayDeque follow a FIFO (First-In-First-Out) order. PriorityQueue, on the other hand, orders elements based on their priority.
- LinkedList and ArrayDeque: Provide O(1) time complexity for adding and removing elements from the front or back of the queue.
- PriorityQueue: Provides O(log n) time complexity for enqueueing and dequeueing operations.
Choose LinkedList or ArrayDeque when you need a simple FIFO queue. Choose PriorityQueue when you need to prioritize elements based on their priority.
14. Real-World Examples
To illustrate the practical applications of using Comparator with PriorityQueue, let’s explore a few real-world examples:
14.1. Hospital Emergency Room Triage System
In a hospital emergency room, patients need to be treated based on the severity of their condition. A PriorityQueue can be used to manage the patients, with a Comparator defining the priority of each patient based on factors such as vital signs, symptoms, and medical history.
import java.util.Comparator;
import java.util.PriorityQueue;
class Patient {
String name;
int priority; // Lower value means higher priority
public Patient(String name, int priority) {
this.name = name;
this.priority = priority;
}
@Override
public String toString() {
return "Patient{" +
"name='" + name + ''' +
", priority=" + priority +
'}';
}
}
class PatientPriorityComparator implements Comparator<Patient> {
@Override
public int compare(Patient p1, Patient p2) {
return p1.priority - p2.priority; // Lower priority value comes first
}
}
public class Main {
public static void main(String[] args) {
PriorityQueue<Patient> triageQueue = new PriorityQueue<>(new PatientPriorityComparator());
triageQueue.add(new Patient("Alice", 3));
triageQueue.add(new Patient("Bob", 1));
triageQueue.add(new Patient("Charlie", 2));
while (!triageQueue.isEmpty()) {
System.out.println("Treating: " + triageQueue.poll());
}
}
}In this example, the PatientPriorityComparator orders patients based on their priority, ensuring that the most critical patients are treated first.
14.2. CPU Task Scheduling
In a CPU task scheduling system, tasks need to be executed based on their priority. A PriorityQueue can be used to manage the tasks, with a Comparator defining the priority of each task based on factors such as execution time, resource requirements, and importance.
import java.util.Comparator;
import java.util.PriorityQueue;
class Task {
String name;
int priority; // Lower value means higher priority
public Task(String name, int priority) {
this.name = name;
this.priority = priority;
}
@Override
public String toString() {
return "Task{" +
"name='" + name + ''' +
", priority=" + priority +
'}';
}
}
class TaskPriorityComparator implements Comparator<Task> {
@Override
public int compare(Task t1, Task t2) {
return t1.priority - t2.priority; // Lower priority value comes first
}
}
public class Main {
public static void main(String[] args) {
PriorityQueue<Task> taskQueue = new PriorityQueue<>(new TaskPriorityComparator());
taskQueue.add(new Task("Task A", 3));
taskQueue.add(new Task("Task B", 1));
taskQueue.add(new Task("Task C", 2));
while (!taskQueue.isEmpty()) {
System.out.println("Executing: " + taskQueue.poll());
}
}
}In this example, the TaskPriorityComparator orders tasks based on their priority, ensuring that the most important tasks are executed first.
15. Conclusion: Comparator and PriorityQueue – A Powerful Combination
In conclusion, using a Comparator with a PriorityQueue in Java provides a powerful and flexible way to manage and prioritize elements in a collection. Whether you’re sorting strings by length, handling complex data structures with multiple fields, or implementing real-world applications like task scheduling or emergency room triage, understanding how to use Comparators with PriorityQueue is essential for writing efficient and maintainable code.
15.1. Recap of Key Points
- PriorityQueue orders elements based on their natural ordering or a custom ordering defined by a Comparator.
- A Comparator is an interface that defines a custom ordering for objects.
- Using a Comparator with PriorityQueue allows you to override the natural ordering of elements and sort them based on your specific needs.
- Common use cases include task scheduling, event management, and graph algorithms.
- Potential pitfalls include
NullPointerException, inconsistent comparisons, and performance considerations. - Advanced techniques include chained comparators and lambda expressions.
15.2. Encouragement to Explore and Experiment
We encourage you to explore and experiment with Comparators and PriorityQueue to gain a deeper understanding of their capabilities. Try implementing different Comparators for various data types and use cases. Explore the advanced techniques like chained comparators and lambda expressions.
15.3. Invitation to Visit COMPARE.EDU.VN for More Information
For more information and resources on Java data structures and algorithms, visit COMPARE.EDU.VN. Our website provides comprehensive guides, tutorials, and examples to help you master Java programming.
Need to compare different sorting algorithms or data structures? Visit COMPARE.EDU.VN for detailed comparisons and expert insights. Our platform offers a wealth of information to help you make informed decisions and optimize your code.
16. Call to Action
Ready to take your Java skills to the next level? Visit COMPARE.EDU.VN to explore more articles, tutorials, and comparisons. Make informed decisions with our detailed analyses. Enhance your projects with the best solutions.
Address: 333 Comparison Plaza, Choice City, CA 90210, United States
WhatsApp: +1 (626) 555-9090
Website: compare.edu.vn
17. FAQ
17.1. Can I use a Comparator with a PriorityQueue of primitive types?
Yes, you can use a Comparator with a PriorityQueue of primitive types by using their corresponding wrapper classes (e.g., Integer, Double).
import java.util.Comparator;
import java.util.PriorityQueue;
public class Main {
public static void main(String[] args) {
PriorityQueue<Integer> pq = new PriorityQueue<>(Comparator.reverseOrder());
pq.add(5);
pq.add(1);
pq.add(3);
while (!pq.isEmpty()) {
System.out.println(pq.poll());
}
}
}17.2. What happens if I don’t provide a Comparator when creating a PriorityQueue?
If you don’t provide a Comparator, the PriorityQueue will use the natural ordering of the elements. This means that the elements must implement the Comparable interface.
17.3. Can I change the Comparator of a PriorityQueue after it has been created?
No, you cannot change the Comparator of a PriorityQueue after it has been created. If you need to change the Comparator, you will need to create a new PriorityQueue with the desired Comparator.
17.4. How do I sort in descending order using a Comparator?
To sort in descending order, you can use the Comparator.reverseOrder() method or implement a Comparator that returns the opposite of the natural ordering.
import java.util.Comparator;
import java.util.PriorityQueue;
public class Main {
public static void main(String[] args) {
PriorityQueue<Integer> pq = new PriorityQueue<>(Comparator.reverseOrder());
pq.add(5);
pq.add(1);
pq.add(3);
while (!pq.isEmpty()) {
System.out.println(pq.poll());
}
}
}17.5. Can I use a lambda expression as a Comparator?
Yes, you can use a lambda expression as a Comparator to create concise comparators inline.
import java.util.PriorityQueue;
public class Main {
public static void main(String[] args) {
PriorityQueue<String> pq = new PriorityQueue<>(
(s1, s2) -> s1.length() - s2.length()
);
pq.add("apple");
pq.add("banana");
pq.add("kiwi");
while (!pq.isEmpty()) {
System.out.println(pq.poll());
}
}
}17.6. How do I handle ties in a Comparator?
When handling ties, ensure that your Comparator provides a consistent ordering. If two elements are equal, the compare() method should return zero.
17.7. What is the time complexity of adding an element to a PriorityQueue with a Comparator?
The time complexity of adding an element to a PriorityQueue with a Comparator is O(log n), where n is the number of elements in the queue.
17.8. What is the time complexity of removing the highest priority element from a PriorityQueue with a Comparator?
The time complexity of removing the highest priority element from a PriorityQueue with a Comparator is O(log n), where n is the number of elements in the queue.
17.9. Can I use a Comparator to sort objects based on multiple criteria?
Yes, you can use chained comparators or lambda expressions to sort objects based on multiple criteria.
17.10. How do I ensure that my Comparator is consistent?
To ensure that your Comparator is consistent, the compare() method should satisfy the properties of symmetry, transitivity, and reflexivity.
