Comparator Interface

Implement different sort orders with the Comparator interface’s compare() method, and pass the Comparator as a parameter to List.sort(). Your implementation must explicitly handle null inputs in the compare() method to avoid a null pointer exception.

Namespace

System

Comparator Methods

The following are methods for Comparator.

compare(var1, var2)

Compares the two arguments and returns a negative integer, zero, or a positive integer depending on whether the first argument is less than, equal to, or greater than the second argument.

Signature

public Integer compare(T var1, T var2)

Parameters

var1: Type: T; T - The type determined by the parameterized type of the Comparator. For example, if the class implements Comparator<Account> then var1 and var2 are of type Account .
var2: Type: T; T - The type determined by the parameterized type of the Comparator. For example, if the class implements Comparator<Account> then var1 and var2 are of type Account .

Return Value

Type: Integer

Comparator Example Implementation

Use the Comparator interface to impose different kinds of sorting.

This example implements two different ways of sorting employees.

1public class Employee {
2
3    private Long id;
4    private String name;
5    private Integer yearJoined;
6    
7    // Constructor
8    public Employee(Long i, String n, Integer y) {
9        id = i;
10        name = n;
11        yearJoined = y;
12    }
13    
14    public String getName() { return name; }
15    public Integer getYear() { return yearJoined; }
16}

1// Class to compare Employees by name
2    public class NameCompare implements Comparator<Employee> {
3        public Integer compare(Employee e1, Employee e2) {
4            if(e1?.getName() == null && e2?.getName() == null) {
5                return 0;
6            } else if(e1?.getName() == null) { 
7                return -1; 
8            } else if(e2?.getName() == null) {
9                return 1;
10            }        
11            return e1.getName().compareTo(e2.getName());
12            }
13        }
14
15    // Class to compare Employees by year joined
16    public class YearCompare implements Comparator<Employee> {
17        public Integer compare(Employee e1, Employee e2) {
18            // Guard against null operands for ‘<’ or ‘>’ operators because
19            // they will always return false and produce inconsistent sorting
20            Integer result;
21            if(e1?.getYear() == null && e2?.getYear() == null) {
22                result = 0;
23            } else if(e1?.getYear() == null) { 
24                  result = -1; 
25            } else if(e2?.getYear() == null) {
26                  result = 1;
27            } else if (e1.getYear() < e2.getYear()) {
28                  result = -1;
29            } else if (e1.getYear() > e2.getYear()) {
30                  result = 1;
31            } else {
32                  result = 0;  
33            } 
34        return result;
35        }
36    }
37

The following example tests the implementation:

1@isTest
2private class EmployeeSortingTest {
3    @isTest
4    static void sortWithComparators() {        
5        List<Employee> empList = new List<Employee>();
6        empList.add(new Employee(101,'Joe Smith', 2020));
7        empList.add(new Employee(102,'J. Smith', 2020));
8        empList.add(new Employee(25,'Caragh Smith', 2021));
9        empList.add(new Employee(105,'Mario Ruiz', 2019));
10        // Sort by name
11        NameCompare nameCompare = new NameCompare();
12        empList.sort(nameCompare);
13        // Expected order: Caragh Smith, J. Smith, Joe Smith, Mario Ruiz
14        Assert.areEqual('Caragh Smith', empList.get(0).getName());
15        
16        // Sort by year joined
17        YearCompare yearCompare = new YearCompare();
18        empList.sort(yearCompare);
19        // Expected order: Mario Ruiz, J. Smith, Joe Smith, Caragh Smith
20        Assert.areEqual('Mario Ruiz', empList.get(0).getName());
21    }
22}

Apex Reference Guide