How to Sort in Descending Order in Java Using Comparator

Sorting data is a fundamental operation in computer science, and Java offers robust tools for achieving this efficiently. This article explores how to sort elements in descending order using the Comparator interface in Java. The Comparator interface provides a flexible way to define custom sorting logic without modifying the original class of the objects being sorted.

Understanding the Comparator Interface

The Comparator interface, found in the java.util package, defines a method called compare(). This method takes two objects as input and returns an integer value indicating their relative order.

• A negative return value signifies that the first object is less than the second.
• A positive return value indicates that the first object is greater than the second.
• Zero implies that the two objects are equal.

To sort in descending order, we need to implement the compare() method such that it reverses the natural ordering.

Implementing Descending Order Sorting

Let’s illustrate with an example of sorting Laptop objects based on their RAM size in descending order:

import java.util.*;

class Laptop {
    int ModalNo;
    String name;
    int ram;

    Laptop(int ModalNo, String name, int ram) {
        this.ModalNo = ModalNo;
        this.name = name;
        this.ram = ram;
    }
}

class RamComparator implements Comparator<Laptop> {
    @Override
    public int compare(Laptop l1, Laptop l2) {
        if (l1.ram == l2.ram) {
            return 0;
        } else if (l1.ram < l2.ram) {
            return 1; // Reversed for descending order
        } else {
            return -1; // Reversed for descending order
        }
    }
}

public class Main {
    public static void main(String[] args) {
        ArrayList<Laptop> laptops = new ArrayList<>();
        laptops.add(new Laptop(322, "Dell", 2));
        laptops.add(new Laptop(342, "Asus", 8));
        laptops.add(new Laptop(821, "HP", 16));
        laptops.add(new Laptop(251, "Lenovo", 6));
        laptops.add(new Laptop(572, "Acer", 4));

        System.out.println("Before sorting:");
        printLaptops(laptops);

        Collections.sort(laptops, new RamComparator());

        System.out.println("nAfter sorting by RAM in descending order:");
        printLaptops(laptops);
    }

    static void printLaptops(ArrayList<Laptop> laptops) {
        System.out.println("Ram Name ModalNo");
        for (Laptop laptop : laptops) {
            System.out.println(laptop.ram + " " + laptop.name + " " + laptop.ModalNo);
        }
    }
}

In the RamComparator, the compare() method returns 1 if l1.ram is less than l2.ram, effectively placing laptops with higher RAM first.

Sorting Strings in Descending Order

For String variables, use the compareTo() method in reverse order within the compare() method:

class NameComparator implements Comparator<Laptop> {
    @Override
    public int compare(Laptop l1, Laptop l2) {
        return l2.name.compareTo(l1.name); // Reversed for descending order
    }
}

This implementation will sort laptops in descending order based on their names.

Conclusion

The Comparator interface in Java provides a powerful mechanism for sorting objects in descending order. By implementing the compare() method with reversed logic, we can achieve the desired sorting behavior. This approach allows for custom sorting strategies without altering the underlying classes, promoting code reusability and maintainability. This flexibility makes Comparator an essential tool for developers working with collections of objects in Java.