Java Comparator & Comparable

Learning Objectives

After completing this lesson, you will be able to:

• Understand why sorting is important in Java
• Learn the difference between Comparable and Comparator
• Implement natural ordering using Comparable
• Implement custom sorting using Comparator
• Sort objects using Collections and Streams
• Use Lambda Expressions with Comparator
• Learn Comparator utility methods
• Understand sorting internals
• Apply sorting in Spring Boot applications
• Follow enterprise best practices
• Prepare for Java interview questions

Introduction

Sorting is one of the most common operations in enterprise applications.

Examples:

• Sort employees by salary
• Sort products by price
• Sort students by marks
• Sort orders by date
• Sort customers by name
• Sort transactions by amount
• Sort logs by timestamp
• Sort flights by departure time

Java provides two mechanisms for sorting objects:

• Comparable
• Comparator

Both are extensively used in:

• Collections Framework
• Streams API
• Spring Boot
• Hibernate
• JavaFX
• Enterprise Applications

Why Comparable & Comparator?

Suppose we have an Employee class.

public class Employee {

    private int id;
    private String name;
    private double salary;

}

Now suppose we have:

List<Employee> employees = ...

How should Java sort these employees?

• By ID?
• By Name?
• By Salary?
• By Joining Date?

Java needs a way to know the sorting logic.

This is where Comparable and Comparator come into the picture.

Comparable vs Comparator

Sorting Architecture

                 List<Employee>
                        │
          ┌─────────────┴─────────────┐
          │                           │
     Comparable                 Comparator
          │                           │
  Natural Sorting             Custom Sorting

What is Comparable?

Comparable defines the natural ordering of objects.

Interface

public interface Comparable<T>{

    int compareTo(T object);

}

Implementing Comparable

public class Employee
implements Comparable<Employee>{

    private int id;

    private String name;

    @Override
    public int compareTo(Employee other){

        return this.id - other.id;

    }

}

Sorting using Comparable

List<Employee> employees =

new ArrayList<>();

Collections.sort(employees);

Java automatically calls:

compareTo()

Example Output

Before Sorting

102 Rahul

101 Amit

103 John

After Sorting

101 Amit

102 Rahul

103 John

compareTo() Return Values

this.compareTo(other)

Example

return this.salary.compareTo(other.salary);

What is Comparator?

Comparator allows multiple custom sorting strategies.

Interface

public interface Comparator<T>{

    int compare(T o1, T o2);

}

Sorting by Name

public class NameComparator

implements Comparator<Employee>{

    @Override

    public int compare(

            Employee e1,

            Employee e2){

        return e1.getName()

                .compareTo(

                e2.getName());

    }

}

Usage

Collections.sort(

employees,

new NameComparator()

);

Sorting by Salary

public class SalaryComparator

implements Comparator<Employee>{

    @Override

    public int compare(

            Employee e1,

            Employee e2){

        return Double.compare(

                e1.getSalary(),

                e2.getSalary());

    }

}

Comparator using Lambda

Java 8 simplified sorting.

employees.sort(

(a,b) ->

Double.compare(

a.getSalary(),

b.getSalary()

)

);

Comparator using Method Reference

employees.sort(

Comparator.comparing(

Employee::getName

)

);

Reverse Sorting

employees.sort(

Comparator

.comparing(

Employee::getSalary

)

.reversed()

);

Multiple Field Sorting

Sort by Department, then Salary.

employees.sort(

Comparator

.comparing(Employee::getDepartment)

.thenComparing(Employee::getSalary)

);

Comparator Utility Methods

Java provides many helper methods.

comparing()

Comparator.comparing(

Employee::getName

);

reversed()

Comparator

.comparing(

Employee::getSalary

)

.reversed();

thenComparing()

Comparator

.comparing(Employee::getDepartment)

.thenComparing(Employee::getName);

nullsFirst()

Comparator.nullsFirst(

Comparator.naturalOrder()

);

nullsLast()

Comparator.nullsLast(

Comparator.naturalOrder()

);

Sorting using Streams

employees.stream()

.sorted(

Comparator.comparing(

Employee::getSalary

)

)

.forEach(System.out::println);

Comparable vs Comparator Example

Comparable

Employee

↓

Sort by Employee ID

Comparator

Employee

↓

Sort by Salary

↓

Sort by Name

↓

Sort by Department

↓

Sort by Experience

Internal Working

Collections.sort()

↓

TimSort Algorithm

↓

compareTo()/compare()

↓

Sorted Collection

Java uses TimSort, a hybrid sorting algorithm derived from Merge Sort and Insertion Sort.

Complexity

Real-World Example: Employee Management

employees.sort(

Comparator

.comparing(Employee::getDepartment)

.thenComparing(Employee::getSalary)

.reversed()

);

Real-World Example: Product Sorting

products.sort(

Comparator

.comparing(Product::getPrice)

);

Real-World Example: Student Ranking

students.sort(

Comparator

.comparing(Student::getMarks)

.reversed()

);

Spring Boot Example

Repository

List<Employee> employees =
repository.findAll();

Sorting

employees.sort(

Comparator

.comparing(Employee::getJoiningDate)

);

Best Practices

Use Comparable for Natural Ordering

Example

• Employee ID
• Roll Number
• Account Number

Use Comparator for Business Rules

Example

• Salary
• Department
• Name
• Joining Date

Prefer Comparator.comparing()

Cleaner than manually implementing compare().

Use Lambda Expressions

Prefer concise lambda expressions over anonymous classes.

Avoid Subtraction for Integer Comparison

Instead of

return a - b;

Use

return Integer.compare(a,b);

This avoids integer overflow.

Chain Comparisons

Use thenComparing() instead of nested if-else blocks.

Common Mistakes

Returning Incorrect Values

Wrong

return 1;

Always implement consistent comparison logic.

Using == for Strings

Wrong

name1 == name2

Correct

name1.compareTo(name2)

or

Objects.equals(name1, name2)

depending on the requirement.

Ignoring Null Values

Use

Comparator.nullsFirst()

or

Comparator.nullsLast()

Violating compareTo() Contract

Ensure comparisons are:

• Consistent
• Symmetric
• Transitive

Multiple Comparable Implementations

A class can implement only one natural ordering. Use Comparators for additional sorting strategies.

Hands-on Exercise

Create a Java program that:

1. Creates an Employee class implementing Comparable.
2. Sorts employees by ID.
3. Creates a SalaryComparator.
4. Creates a NameComparator.
5. Sorts using Lambda expressions.
6. Uses Comparator.comparing().
7. Uses thenComparing().
8. Uses reversed().
9. Uses nullsFirst().
10. Sorts employees using the Streams API.

Summary

Comparable and Comparator provide the foundation for sorting in Java. Comparable defines a class's natural ordering, while Comparator enables multiple custom sorting strategies. Modern Java encourages using Comparator.comparing(), lambda expressions, and method references to build concise, readable, and maintainable sorting logic. These APIs are heavily used in enterprise applications, especially with Collections, Streams, Spring Boot, and data processing.

Key Takeaways

• Comparable defines natural ordering.
• Comparator defines custom ordering.
• compareTo() belongs to Comparable.
• compare() belongs to Comparator.
• Use Comparator.comparing() for clean code.
• Use thenComparing() for multi-level sorting.
• Use reversed() for descending order.
• Handle null values with nullsFirst() and nullsLast().
• Streams integrate seamlessly with Comparator.
• Java uses TimSort for sorting object collections.

Professional Interview Questions