Comparable vs Comparator in Java

Sorting objects in Java can be done using Comparable and Comparator interfaces. Both are part of the java.util package and widely used in collections like ArrayList, TreeSet, TreeMap, etc.

Comparable in Java

Comparable is used to define a natural ordering of objects by modifying the class itself.

Package: java.lang
Interface Method: int compareTo(T obj)

public class Student implements Comparable<Student> {
    private String name;
    private int marks;

    public Student(String name, int marks) {
        this.name = name;
        this.marks = marks;
    }

    @Override
    public int compareTo(Student other) {
        return this.marks - other.marks; // Ascending order
    }

    @Override
    public String toString() {
        return name + " : " + marks;
    }
}

Usage:

ArrayList<Student> list = new ArrayList<>();
list.add(new Student("Alice", 90));
list.add(new Student("Bob", 75));

Collections.sort(list);
System.out.println(list);

Key Points about Comparable

Defines natural ordering.
Only one sorting sequence per class.
Modifies the class itself.
Uses compareTo() method.
Return values:
- Negative → this < obj
- Zero → this == obj
- Positive → this > obj

Comparator in Java

Comparator is used to define custom ordering without modifying the class.

Package: java.util
Interface Methods: int compare(T o1, T o2) and boolean equals(Object obj)

(Anonymous Class):

Comparator<Student> cmp = new Comparator<Student>() {
    @Override
    public int compare(Student s1, Student s2) {
        return s2.getMarks() - s1.getMarks(); // Descending order
    }
};
Collections.sort(list, cmp);

Syntax (Lambda in Java 8+):

list.sort((s1, s2) -> s2.getMarks() - s1.getMarks());

Key Points about Comparator

Defines custom ordering.
Can have multiple sorting sequences.
Does not modify class.
Uses compare() method.
Can be used with TreeSet, TreeMap, Collections.sort(), etc.

Comparable vs Comparator

Feature	Comparable	Comparator
Purpose	Defines natural ordering of objects	Defines custom ordering of objects
Interface	`java.lang.Comparable`	`java.util.Comparator`
Method	`compareTo(Object o)`	`compare(Object o1, Object o2)`
Implemented by	Class whose objects need to be sorted	Separate class or lambda (external logic)
Number of Sorts	Single sort sequence	Multiple sort sequences possible
Location	Inside the class	Outside the class
Usage	`Collections.sort(list)`	`Collections.sort(list, comparator)`
Example	`class Student implements Comparable<Student>`	`class AgeComparator implements Comparator<Student>`

Example Program Using Both

import java.util.*;

class Student implements Comparable<Student> {
    String name;
    int marks;

    public Student(String name, int marks) {
        this.name = name;
        this.marks = marks;
    }

    @Override
    public int compareTo(Student other) {
        return this.marks - other.marks; // Ascending
    }

    @Override
    public String toString() {
        return name + ":" + marks;
    }
}

public class Main {
    public static void main(String[] args) {
        ArrayList<Student> list = new ArrayList<>();
        list.add(new Student("Alice", 90));
        list.add(new Student("Bob", 75));
        list.add(new Student("Charlie", 85));

        // Natural Order (Comparable)
        Collections.sort(list);
        System.out.println("Ascending by marks: " + list);

        // Custom Order (Comparator)
        list.sort((s1, s2) -> s2.marks - s1.marks);
        System.out.println("Descending by marks: " + list);
    }
}

Output:

Ascending by marks: [Bob:75, Charlie:85, Alice:90]
Descending by marks: [Alice:90, Charlie:85, Bob:75]

Points to Remember

Comparable → Built-in class modification, one natural sorting.
Comparator → External class or lambda, multiple sorting sequences.
Use Comparable when a class has a default order.
Use Comparator for custom or multiple sorting logic.
Works with Collections.sort(), TreeSet, TreeMap.

Core Java tutorial for beginners

Comparable vs Comparator in Java – Differences, Examples & Usage