Custom Sorting with Comparable & Comparator

1. The Problem: Sorting Custom Objects

Imagine you have a list of Employee objects. If you try to sort it directly, how would Java know whether to sort by employee ID, name, or salary? It doesn't. This ambiguity leads to a runtime error.

The java.lang.ClassCastException occurs because the sorting algorithm tries to cast your object to a Comparable to figure out how to order it, but your class doesn't implement this interface. Java provides two primary mechanisms to solve this: Comparable and Comparator.

2. Comparable: Defining a "Natural" Order

The Comparable interface is used to impose a single, natural ordering on the objects of a class. If you believe your object has an obvious, default way it should be sorted (e.g., employees by ID, books by ISBN), Comparable is the way to define it.

• Interface: java.lang.Comparable<T>
• Method: public int compareTo(T other)
• Location: The logic is placed inside the class you want to sort.

The compareTo method has a strict contract based on its return value:

• Negative integer: this object is less than the other object.
• Zero: this object is equal to the other object.
• Positive integer: this object is greater than the other object.

The following video provides an excellent, detailed walkthrough of implementing Comparable.

Key Takeaway: By implementing Comparable, your class now has an intrinsic, or "natural," sorting order. Collections.sort(list) will now work correctly without any extra arguments. The main limitation is that you're stuck with this single sorting logic. What if you need to sort employees by name sometimes and by age other times?

3. Comparator: Flexible, External Sorting Logic

This is where the Comparator interface shines. It allows you to define sorting logic externally from the object's class. This is incredibly flexible, as you can create as many different comparators as you need.

• Interface: java.util.Comparator<T>
• Method: public int compare(T o1, T o2)
• Location: The logic is placed in a separate class or, more commonly since Java 8, as a lambda expression.

The return value contract for compare(o1, o2) is the same as for compareTo: negative if o1 < o2, zero if o1 == o2, and positive if o1 > o2.

This flexibility is why Comparator is so powerful. You can define separate comparators for sorting by name, salary, hire date, etc., and apply them as needed.

4. Multi-Level Sorting: A Common Interview Scenario

A very common interview requirement is to implement multi-level sorting. For example: "Sort employees by department, and for employees in the same department, sort them by salary in descending order."

This is a perfect use case for Comparator. You first compare by the primary criterion (department). If they are the same, you then proceed to compare by the secondary criterion (salary).

5. The Modern Way: Java 8+ Comparator Factory Methods

While you can write the if-else logic for multi-level sorting yourself, Java 8 introduced a set of static factory methods on the Comparator interface that make this incredibly clean and expressive. For a senior role, you are expected to know and use this fluent API.

Key methods include:

• Comparator.comparing(keyExtractor): Creates a comparator for a specific key (e.g., Employee::getName).
• thenComparing(keyExtractor): Used for secondary sorting.
• reversed(): Reverses the sort order of a given comparator.

Using this fluent API, the multi-level sorting problem from before ("sort by department, then by salary descending") becomes a simple one-liner:

Comparator<Employee> multiLevelComparator = Comparator
    .comparing(Employee::getDepartment)
    .thenComparing(Employee::getSalary, Comparator.reverseOrder());

This is the kind of concise, readable code that interviewers at top companies love to see.

6. Summary for Your Interview

When an interviewer asks you to compare Comparable and Comparator, you should be ready with a concise summary.

(This table is adapted from the resource at coderstea.in)

Conclusion

Congratulations on completing the "Java Collections & Problem-Solving" module! You've moved from the internal implementations of data structures to the practicalities of iteration and now, custom sorting.

Key Takeaways:

• Comparable defines the natural sorting order for a class by implementing the compareTo method within the class itself. Use it for the single, most obvious way to sort an object.
• Comparator defines external, pluggable sorting logic. Use it when you need multiple sort orders, when you can't modify the source class, or for complex, multi-level sorting.
• Since Java 8, Comparator is a functional interface and is best used with lambda expressions and the fluent API (comparing, thenComparing, etc.) for clean, powerful, and readable sorting logic.

Preview of the Next Module:
The use of lambda expressions and method references with Comparator was a perfect introduction to our next topic. The upcoming module, "Functional Java with Streams & Lambdas," will dive deep into these concepts. In the first lesson, we will formally explore what functional interfaces are and how to implement them using lambda expressions and method references, building directly on what you've seen today.