Java Comparator is a powerful interface that allows you to define custom sorting logic for your objects. At compare.edu.vn, we understand the importance of efficient data management, and the Comparator interface is key to achieving that in Java. This guide will explain How To Use Java Comparator to sort collections in ways that go beyond the natural ordering of objects, offering a tailored approach to data organization.
1. What Is Java Comparator and Why Use It?
The Java Comparator interface is part of the Java Collections Framework and is used to define a comparison function for objects that do not have a natural ordering (i.e., they don’t implement the Comparable interface) or when you need to sort objects in a different order than their natural ordering. Essentially, a Comparator provides a way to impose a total ordering on a collection of objects. This is crucial for tasks like sorting data based on specific criteria or controlling the order of elements in sorted data structures.
1.1 Understanding the Comparator Interface
The Comparator interface primarily consists of one method:
int compare(T o1, T o2): Compares its two arguments for order. Returns a negative integer, zero, or a positive integer as the first argument is less than, equal to, or greater than the second.
1.2 Scenarios Where Comparator Is Useful
- Sorting Objects Without Natural Ordering: When you have a class that doesn’t implement
Comparable, you can use aComparatorto sort instances of that class. - Custom Sorting Logic: You might want to sort objects based on different criteria at different times. For instance, sorting a list of employees by name in one instance and by salary in another.
- Controlling Order in Data Structures:
Comparatorcan be used to specify the ordering of elements in sorted sets (TreeSet) or sorted maps (TreeMap).
2. Implementing a Basic Java Comparator
Let’s start with a simple example. Suppose you have a class Employee with attributes like name and salary. You want to sort a list of Employee objects by their salary.
public class Employee {
private String name;
private double salary;
public Employee(String name, double salary) {
this.name = name;
this.salary = salary;
}
public String getName() {
return name;
}
public double getSalary() {
return salary;
}
@Override
public String toString() {
return "Employee{" +
"name='" + name + ''' +
", salary=" + salary +
'}';
}
}To sort Employee objects by salary, you can create a Comparator:
import java.util.Comparator;
public class SalaryComparator implements Comparator<Employee> {
@Override
public int compare(Employee e1, Employee e2) {
return Double.compare(e1.getSalary(), e2.getSalary());
}
}In this example, SalaryComparator implements the Comparator<Employee> interface and provides an implementation for the compare method. The Double.compare method is used to compare the salaries of the two employees.
2.1 Using the Comparator
You can use the SalaryComparator to sort a list of Employee objects using Collections.sort:
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<Employee> employees = new ArrayList<>();
employees.add(new Employee("Alice", 50000));
employees.add(new Employee("Bob", 60000));
employees.add(new Employee("Charlie", 45000));
System.out.println("Before sorting: " + employees);
Collections.sort(employees, new SalaryComparator());
System.out.println("After sorting by salary: " + employees);
}
}This will output:
Before sorting: [Employee{name='Alice', salary=50000.0}, Employee{name='Bob', salary=60000.0}, Employee{name='Charlie', salary=45000.0}]
After sorting by salary: [Employee{name='Charlie', salary=45000.0}, Employee{name='Alice', salary=50000.0}, Employee{name='Bob', salary=60000.0}]3. Using Lambda Expressions for Comparators
Java 8 introduced lambda expressions, which provide a more concise way to create Comparator instances. You can rewrite the SalaryComparator using a lambda expression:
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<Employee> employees = new ArrayList<>();
employees.add(new Employee("Alice", 50000));
employees.add(new Employee("Bob", 60000));
employees.add(new Employee("Charlie", 45000));
System.out.println("Before sorting: " + employees);
Collections.sort(employees, (e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary()));
System.out.println("After sorting by salary: " + employees);
}
}This achieves the same result as the previous example but with less code.
3.1 Benefits of Using Lambda Expressions
- Conciseness: Lambda expressions reduce the amount of boilerplate code needed to create a
Comparator. - Readability: They make the sorting logic more readable and easier to understand.
- Inline Implementation: Lambda expressions allow you to define the
Comparatorinline, where it’s used.
4. Chaining Comparators
Sometimes, you need to sort objects based on multiple criteria. For example, you might want to sort employees first by salary and then by name if the salaries are the same. You can achieve this by chaining Comparator instances using the thenComparing method.
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Comparator;
public class Main {
public static void main(String[] args) {
List<Employee> employees = new ArrayList<>();
employees.add(new Employee("Alice", 50000));
employees.add(new Employee("Bob", 60000));
employees.add(new Employee("Charlie", 45000));
employees.add(new Employee("Alice", 60000)); // Added an employee with the same salary as Bob
System.out.println("Before sorting: " + employees);
Comparator<Employee> salaryThenNameComparator = Comparator.comparing(Employee::getSalary)
.thenComparing(Employee::getName);
Collections.sort(employees, salaryThenNameComparator);
System.out.println("After sorting by salary then name: " + employees);
}
}This will output:
Before sorting: [Employee{name='Alice', salary=50000.0}, Employee{name='Bob', salary=60000.0}, Employee{name='Charlie', salary=45000.0}, Employee{name='Alice', salary=60000.0}]
After sorting by salary then name: [Employee{name='Charlie', salary=45000.0}, Employee{name='Alice', salary=50000.0}, Employee{name='Alice', salary=60000.0}, Employee{name='Bob', salary=60000.0}]4.1 How thenComparing Works
The thenComparing method allows you to chain multiple Comparator instances. It applies the next Comparator only when the previous Comparator considers the objects equal. This is particularly useful for breaking ties when sorting by multiple criteria.
4.2 Using thenComparing with Lambda Expressions
You can also use lambda expressions with thenComparing to create more complex sorting logic:
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Comparator;
public class Main {
public static void main(String[] args) {
List<Employee> employees = new ArrayList<>();
employees.add(new Employee("Alice", 50000));
employees.add(new Employee("Bob", 60000));
employees.add(new Employee("Charlie", 45000));
employees.add(new Employee("Alice", 60000)); // Added an employee with the same salary as Bob
System.out.println("Before sorting: " + employees);
Comparator<Employee> salaryThenNameComparator = Comparator.comparing(Employee::getSalary)
.thenComparing((e1, e2) -> e1.getName().compareTo(e2.getName()));
Collections.sort(employees, salaryThenNameComparator);
System.out.println("After sorting by salary then name: " + employees);
}
}5. Natural Ordering and Comparable Interface
Before diving deeper into advanced Comparator techniques, it’s essential to understand the concept of natural ordering and the Comparable interface.
5.1 Understanding Natural Ordering
Natural ordering refers to the default ordering of objects of a class. A class has a natural ordering if it implements the Comparable interface.
5.2 Implementing Comparable
The Comparable interface consists of one method:
int compareTo(T o): Compares this object with the specified object for order. Returns a negative integer, zero, or a positive integer as this object is less than, equal to, or greater than the specified object.
Let’s modify the Employee class to implement Comparable:
public class Employee implements Comparable<Employee> {
private String name;
private double salary;
public Employee(String name, double salary) {
this.name = name;
this.salary = salary;
}
public String getName() {
return name;
}
public double getSalary() {
return salary;
}
@Override
public String toString() {
return "Employee{" +
"name='" + name + ''' +
", salary=" + salary +
'}';
}
@Override
public int compareTo(Employee other) {
return this.name.compareTo(other.getName()); // Natural ordering by name
}
}In this example, the Employee class implements Comparable<Employee> and provides an implementation for the compareTo method. The natural ordering is based on the employee’s name.
5.3 Using Natural Ordering
When a class implements Comparable, you can sort a list of objects of that class without providing a Comparator:
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<Employee> employees = new ArrayList<>();
employees.add(new Employee("Alice", 50000));
employees.add(new Employee("Bob", 60000));
employees.add(new Employee("Charlie", 45000));
System.out.println("Before sorting: " + employees);
Collections.sort(employees); // Sorts using natural ordering (by name)
System.out.println("After sorting by name: " + employees);
}
}This will output:
Before sorting: [Employee{name='Alice', salary=50000.0}, Employee{name='Bob', salary=60000.0}, Employee{name='Charlie', salary=45000.0}]
After sorting by name: [Employee{name='Alice', salary=50000.0}, Employee{name='Bob', salary=60000.0}, Employee{name='Charlie', salary=45000.0}]6. Combining Comparable and Comparator
You can use both Comparable and Comparator to provide flexible sorting options. If a class has a natural ordering (implements Comparable), you can still use a Comparator to sort objects in a different order.
6.1 Overriding Natural Ordering with Comparator
Suppose you want to sort Employee objects by salary, even though their natural ordering is by name. You can use a Comparator to override the natural ordering:
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Comparator;
public class Main {
public static void main(String[] args) {
List<Employee> employees = new ArrayList<>();
employees.add(new Employee("Alice", 50000));
employees.add(new Employee("Bob", 60000));
employees.add(new Employee("Charlie", 45000));
System.out.println("Before sorting: " + employees);
Comparator<Employee> salaryComparator = Comparator.comparing(Employee::getSalary);
Collections.sort(employees, salaryComparator); // Sorts by salary using Comparator
System.out.println("After sorting by salary: " + employees);
}
}This will output:
Before sorting: [Employee{name='Alice', salary=50000.0}, Employee{name='Bob', salary=60000.0}, Employee{name='Charlie', salary=45000.0}]
After sorting by salary: [Employee{name='Charlie', salary=45000.0}, Employee{name='Alice', salary=50000.0}, Employee{name='Bob', salary=60000.0}]6.2 When to Use Comparable vs. Comparator
- Use
Comparablewhen you want to define a natural ordering for your class. This is the default way objects of that class will be sorted. - Use
Comparatorwhen you need to sort objects in a different order than their natural ordering or when the class doesn’t implementComparable.
7. Advanced Comparator Techniques
7.1 Using nullsFirst and nullsLast
When dealing with collections that may contain null values, you can use the nullsFirst and nullsLast methods to specify how null values should be handled during sorting.
nullsFirst(Comparator<? super T> comparator): Returns aComparatorthat considersnullto be less than non-null.nullsLast(Comparator<? super T> comparator): Returns aComparatorthat considersnullto be greater than non-null.
Let’s see an example:
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> names = new ArrayList<>();
names.add("Alice");
names.add(null);
names.add("Bob");
names.add(null);
names.add("Charlie");
System.out.println("Before sorting: " + names);
Comparator<String> nullsFirstComparator = Comparator.nullsFirst(Comparator.naturalOrder());
Collections.sort(names, nullsFirstComparator);
System.out.println("After sorting with nullsFirst: " + names);
names.clear();
names.add("Alice");
names.add(null);
names.add("Bob");
names.add(null);
names.add("Charlie");
Comparator<String> nullsLastComparator = Comparator.nullsLast(Comparator.naturalOrder());
Collections.sort(names, nullsLastComparator);
System.out.println("After sorting with nullsLast: " + names);
}
}This will output:
Before sorting: [Alice, null, Bob, null, Charlie]
After sorting with nullsFirst: [null, null, Alice, Bob, Charlie]
Before sorting: [Alice, null, Bob, null, Charlie]
After sorting with nullsLast: [Alice, Bob, Charlie, null, null]7.2 Using reverseOrder
To sort objects in reverse order, you can use the reverseOrder method.
reverseOrder(): Returns aComparatorthat imposes the reverse of the natural ordering on a collection of objects that implement theComparableinterface.reverseOrder(Comparator<T> cmp): Returns aComparatorthat imposes the reverse ordering of the givenComparator.
Here’s an example:
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<Integer> numbers = new ArrayList<>();
numbers.add(10);
numbers.add(5);
numbers.add(20);
numbers.add(15);
System.out.println("Before sorting: " + numbers);
Collections.sort(numbers, Comparator.reverseOrder());
System.out.println("After sorting in reverse order: " + numbers);
}
}This will output:
Before sorting: [10, 5, 20, 15]
After sorting in reverse order: [20, 15, 10, 5]7.3 Using comparing with Key Extractors
The comparing method is a static method in the Comparator interface that accepts a function extracting a sort key and returns a Comparator that compares using that key.
comparing(Function<? super T,? extends U> keyExtractor): Accepts a function that extracts a sort key from typeTand returns aComparator<T>that compares based on that key.
This is particularly useful for sorting objects based on specific attributes.
Example:
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<Employee> employees = new ArrayList<>();
employees.add(new Employee("Alice", 50000));
employees.add(new Employee("Bob", 60000));
employees.add(new Employee("Charlie", 45000));
System.out.println("Before sorting: " + employees);
Comparator<Employee> nameComparator = Comparator.comparing(Employee::getName);
Collections.sort(employees, nameComparator);
System.out.println("After sorting by name: " + employees);
}
}This will output:
Before sorting: [Employee{name='Alice', salary=50000.0}, Employee{name='Bob', salary=60000.0}, Employee{name='Charlie', salary=45000.0}]
After sorting by name: [Employee{name='Alice', salary=50000.0}, Employee{name='Bob', salary=60000.0}, Employee{name='Charlie', salary=45000.0}]8. Comparator and Sorted Data Structures
Comparator is also used to control the order of elements in sorted data structures like TreeSet and TreeMap.
8.1 Using Comparator with TreeSet
TreeSet is a sorted set implementation that uses a Comparator to maintain the order of its elements. If no Comparator is provided, it uses the natural ordering of the elements.
Example:
import java.util.Set;
import java.util.TreeSet;
import java.util.Comparator;
public class Main {
public static void main(String[] args) {
Set<Employee> employees = new TreeSet<>(Comparator.comparing(Employee::getSalary));
employees.add(new Employee("Alice", 50000));
employees.add(new Employee("Bob", 60000));
employees.add(new Employee("Charlie", 45000));
System.out.println("Sorted TreeSet by salary: " + employees);
}
}This will output:
Sorted TreeSet by salary: [Employee{name='Charlie', salary=45000.0}, Employee{name='Alice', salary=50000.0}, Employee{name='Bob', salary=60000.0}]8.2 Using Comparator with TreeMap
TreeMap is a sorted map implementation that uses a Comparator to maintain the order of its keys. If no Comparator is provided, it uses the natural ordering of the keys.
Example:
import java.util.Map;
import java.util.TreeMap;
import java.util.Comparator;
public class Main {
public static void main(String[] args) {
Map<Employee, String> employeeMap = new TreeMap<>(Comparator.comparing(Employee::getName));
employeeMap.put(new Employee("Alice", 50000), "Developer");
employeeMap.put(new Employee("Bob", 60000), "Manager");
employeeMap.put(new Employee("Charlie", 45000), "Analyst");
System.out.println("Sorted TreeMap by employee name: " + employeeMap);
}
}This will output:
Sorted TreeMap by employee name: {Employee{name='Alice', salary=50000.0}=Developer, Employee{name='Bob', salary=60000.0}=Manager, Employee{name='Charlie', salary=45000.0}=Analyst}9. Best Practices for Using Java Comparator
- Keep Comparators Simple: Avoid complex logic in your
Comparatorimplementations to ensure they are efficient and easy to understand. - Handle Null Values: Always consider how your
Comparatorwill handlenullvalues and usenullsFirstornullsLastas needed. - Use Lambda Expressions: Prefer lambda expressions for simple
Comparatorimplementations to reduce boilerplate code. - Chain Comparators: Use
thenComparingto sort objects based on multiple criteria. - Consider Performance: Be mindful of the performance implications of your
Comparatorimplementations, especially when sorting large collections.
10. Common Pitfalls and How to Avoid Them
- Inconsistent Comparisons: Ensure that your
Comparatorprovides a consistent ordering. Ifcompare(a, b)returns a positive value,compare(b, a)should return a negative value, and vice versa. - Not Handling Null Values: Failing to handle
nullvalues can lead toNullPointerException. UsenullsFirstornullsLastto handlenullvalues explicitly. - Complex Logic: Avoid complex logic in your
Comparatorimplementations, as it can make them difficult to understand and maintain.
11. Java Comparator Use Cases
11.1 Sorting a List of Products by Price
Suppose you have a list of products, and you want to sort them by price. Here’s how you can do it using a Comparator:
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
class Product {
private String name;
private double price;
public Product(String name, double price) {
this.name = name;
this.price = price;
}
public String getName() {
return name;
}
public double getPrice() {
return price;
}
@Override
public String toString() {
return "Product{" +
"name='" + name + ''' +
", price=" + price +
'}';
}
}
public class Main {
public static void main(String[] args) {
List<Product> products = new ArrayList<>();
products.add(new Product("Laptop", 1200.0));
products.add(new Product("Mouse", 25.0));
products.add(new Product("Keyboard", 75.0));
System.out.println("Before sorting: " + products);
Comparator<Product> priceComparator = Comparator.comparing(Product::getPrice);
Collections.sort(products, priceComparator);
System.out.println("After sorting by price: " + products);
}
}This will output:
Before sorting: [Product{name='Laptop', price=1200.0}, Product{name='Mouse', price=25.0}, Product{name='Keyboard', price=75.0}]
After sorting by price: [Product{name='Mouse', price=25.0}, Product{name='Keyboard', price=75.0}, Product{name='Laptop', price=1200.0}]11.2 Sorting a List of Strings Ignoring Case
You can use a Comparator to sort a list of strings while ignoring case:
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<String> strings = new ArrayList<>();
strings.add("Alice");
strings.add("bob");
strings.add("Charlie");
System.out.println("Before sorting: " + strings);
Comparator<String> caseInsensitiveComparator = String.CASE_INSENSITIVE_ORDER;
Collections.sort(strings, caseInsensitiveComparator);
System.out.println("After sorting ignoring case: " + strings);
}
}This will output:
Before sorting: [Alice, bob, Charlie]
After sorting ignoring case: [Alice, bob, Charlie]11.3 Sorting a List of Dates
You can sort a list of dates using a Comparator:
import java.time.LocalDate;
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;
public class Main {
public static void main(String[] args) {
List<LocalDate> dates = new ArrayList<>();
dates.add(LocalDate.of(2023, 1, 1));
dates.add(LocalDate.of(2023, 12, 31));
dates.add(LocalDate.of(2023, 6, 15));
System.out.println("Before sorting: " + dates);
Comparator<LocalDate> dateComparator = Comparator.naturalOrder();
Collections.sort(dates, dateComparator);
System.out.println("After sorting: " + dates);
}
}This will output:
Before sorting: [2023-01-01, 2023-12-31, 2023-06-15]
After sorting: [2023-01-01, 2023-06-15, 2023-12-31]12. Real-World Examples of Comparator Usage
12.1 E-commerce Platform
On an e-commerce platform, products can be sorted by price, popularity, rating, or date added. Each of these sorting options can be implemented using a Comparator.
12.2 Social Media Application
In a social media application, posts can be sorted by date, number of likes, or relevance. Again, Comparator can be used to implement these sorting options.
12.3 Task Management Application
In a task management application, tasks can be sorted by due date, priority, or status. A Comparator can be used to implement these sorting options.
13. Relationship Between Comparator and Functional Interfaces
The Comparator interface is a functional interface, which means it has a single abstract method. This makes it compatible with lambda expressions and method references, allowing for more concise and readable code.
13.1 Benefits of Using Functional Interfaces
- Conciseness: Functional interfaces allow you to write less code by using lambda expressions and method references.
- Readability: They make the code more readable by focusing on the behavior rather than the implementation details.
- Flexibility: Functional interfaces can be easily composed and reused.
13.2 Example of Comparator as a Functional Interface
import java.util.ArrayList;
import java.util.Collections;
import java.util.List;
import java.util.Comparator;
public class Main {
public static void main(String[] args) {
List<Employee> employees = new ArrayList<>();
employees.add(new Employee("Alice", 50000));
employees.add(new Employee("Bob", 60000));
employees.add(new Employee("Charlie", 45000));
System.out.println("Before sorting: " + employees);
Comparator<Employee> salaryComparator = (e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary());
Collections.sort(employees, salaryComparator);
System.out.println("After sorting by salary: " + employees);
}
}14. Performance Considerations When Using Comparator
While Comparator is a powerful tool, it’s important to consider its performance implications, especially when sorting large collections.
14.1 Factors Affecting Performance
- Complexity of the
compareMethod: Complex logic in thecomparemethod can slow down the sorting process. - Size of the Collection: Sorting large collections can be time-consuming, especially if the
comparemethod is not efficient. - Sorting Algorithm: The sorting algorithm used by
Collections.sort(typically a variant of merge sort) has a time complexity of O(n log n), but the actual performance can vary depending on the data and theComparator.
14.2 Tips for Improving Performance
- Keep the
compareMethod Simple: Avoid complex logic in thecomparemethod and try to use primitive types for comparisons. - Cache Comparison Results: If the
comparemethod involves expensive calculations, consider caching the results to avoid redundant computations. - Use Parallel Sorting: For very large collections, consider using parallel sorting algorithms to take advantage of multi-core processors.
15. Common Sorting Algorithms and Their Relation to Comparator
Different sorting algorithms can be used with Comparator to sort collections. Here are some common sorting algorithms and their relation to Comparator:
15.1 Merge Sort
- Description: A divide-and-conquer algorithm that divides the collection into smaller sub-collections, sorts them, and then merges them back together.
- Time Complexity: O(n log n)
- Relation to
Comparator:Comparatoris used to compare elements during the merge process.
15.2 Quick Sort
- Description: A divide-and-conquer algorithm that selects a pivot element and partitions the collection around the pivot.
- Time Complexity: O(n log n) on average, O(n^2) in the worst case
- Relation to
Comparator:Comparatoris used to compare elements during the partitioning process.
15.3 Insertion Sort
- Description: A simple algorithm that builds the final sorted array one item at a time.
- Time Complexity: O(n^2)
- Relation to
Comparator:Comparatoris used to compare elements during the insertion process.
15.4 Heap Sort
- Description: An algorithm that uses a heap data structure to sort the collection.
- Time Complexity: O(n log n)
- Relation to
Comparator:Comparatoris used to compare elements during the heap construction and sorting process.
16. How Comparator Works Internally
The Comparator interface provides a way to define a comparison function, but it doesn’t implement the sorting algorithm itself. The sorting algorithm is implemented by the Collections.sort method or the sorted data structures like TreeSet and TreeMap.
16.1 Internal Implementation of Collections.sort
The Collections.sort method typically uses a variant of merge sort, which has a time complexity of O(n log n). The merge sort algorithm divides the collection into smaller sub-collections, sorts them recursively, and then merges them back together.
16.2 Role of Comparator in Sorting
The Comparator is used to compare elements during the merge process. The compare method of the Comparator is called to determine the order of two elements. The sorting algorithm uses this information to arrange the elements in the correct order.
17. Advanced Use Cases
17.1 Dynamic Sorting
Dynamic sorting involves changing the sorting criteria at runtime based on user input or other factors. Comparator can be used to implement dynamic sorting by creating different Comparator instances based on the desired sorting criteria.
17.2 Sorting Based on External Data
Sometimes, you need to sort objects based on data that is not directly available in the objects themselves. For example, you might want to sort a list of products based on their sales data, which is stored in a separate database. You can use a Comparator to implement this by fetching the sales data for each product and using it to compare the products.
18. Migrating from Older Versions of Java to Java 8+ for Comparator
If you are migrating from older versions of Java to Java 8 or later, you can take advantage of the new features in the Comparator interface, such as lambda expressions and method references, to simplify your code and make it more readable.
18.1 Benefits of Migrating
- Conciseness: Lambda expressions and method references allow you to write less code.
- Readability: The new features make the code more readable and easier to understand.
- Performance: In some cases, the new features can improve the performance of your code.
18.2 Example of Migrating to Lambda Expressions
// Older version of Java
Comparator<Employee> salaryComparator = new Comparator<Employee>() {
@Override
public int compare(Employee e1, Employee e2) {
return Double.compare(e1.getSalary(), e2.getSalary());
}
};
// Java 8+ using lambda expression
Comparator<Employee> salaryComparator = (e1, e2) -> Double.compare(e1.getSalary(), e2.getSalary());19. Tips for Debugging Comparator Implementations
- Test with Different Data: Test
