Java Comparable vs Comparator

Last Updated : 02 May, 2025

In Java, both Comparable and Comparator interfaces are used for sorting objects. The main difference between Comparable and Comparator is:

Comparable: It is used to define the natural ordering of the objects within the class.
Comparator: It is used to define custom sorting logic externally.

Difference Between Comparable and Comparator

The table below demonstrates the difference between comparable and comparator in Java.

Features	Comparable	Comparator
Definition	It defines natural ordering within the class.	It defines external or custom sorting logic.
Method	compareTo()	compare()
Implementation	It is implemented in the class.	It is implemented in a separate class.
Sorting Criteria	Natural order sorting	Custom order sorting
Usage	It is used for a single sorting order.	It is used for multiple sorting orders.

Example of Comparable

In this example, we use the Comparable interface to sort Movies by their release year using compareTo() method.

Java

// Java program to demonstrate Comparable interface import java.util.ArrayList; import java.util.Collections;  // Movie class implements Comparable  // interface to define default sorting class Movie implements Comparable<Movie> {     private String name;      private double rating;     private int year;       // Constructor      public Movie(String name, double rating, int year) {         this.name = name;         this.rating = rating;         this.year = year;     }      // Implementation of the compareTo method      // for default sorting by year     public int compareTo(Movie m) {                  // Sort movies in ascending          // order of year         return this.year - m.year;      }      // Getter methods     public String getName() {         return name;     }      public double getRating() {         return rating;     }      public int getYear() {         return year;     } }  public class Geeks {     public static void main(String[] args) {                  // Create a list of movies         ArrayList<Movie> l = new ArrayList<>();         l.add(new Movie("Star Wars", 8.7, 1977));         l.add(new Movie("Empire Strikes Back", 8.8, 1980));         l.add(new Movie("Return of the Jedi", 8.4, 1983));          // Sort movies using Comparable's          // compareTo method by year         Collections.sort(l);          // Display the sorted list of movies         System.out.println("Movies after sorting by year:");         for (Movie m : l) {             System.out.println(m.getName() + " " + m.getRating() + " " + m.getYear());         }     } }

Output

Movies after sorting by year: Star Wars 8.7 1977 Empire Strikes Back 8.8 1980 Return of the Jedi 8.4 1983

Explanation: In the above example, the compareTo() method sorts the Movie objects by their release year, where it return negative if the current movie year is earlier, return positive if the current movie year is later and return zero if the year are same. The Collections.sort() method uses the compareTo() method to compare and sort the movies in ascending order.

Now, suppose we want to sort movies by their rating and names as well. When we make a collection element comparable (by having it implement Comparable), we get only one chance to implement the compareTo() method. The solution is using Comparator.

Example of Comparator

In this example, we use Comparator interface to define custom sorting logic to sort movies first by rating and then by name.

Java

// Java program to demonstrate Comparator interface import java.util.ArrayList; import java.util.Collections; import java.util.Comparator;  class Movie {     private String name;      private double rating;      private int year;          // Constructor to initialize movie details     public Movie(String name, double rating, int year) {         this.name = name;         this.rating = rating;         this.year = year;     }      // Getter methods      public String getN() {        return name;      }      public double getR() {        return rating;      }      public int getY() {        return year;      }     }  // Comparator to sort movies by rating class Rating implements Comparator<Movie> {     public int compare(Movie m1, Movie m2) {                // Sort by rating in descending order         return Double.compare(m2.getR(), m1.getR());     } }  // Comparator to sort movies by name class NameCompare implements Comparator<Movie> {     public int compare(Movie m1, Movie m2) {                // Sort by name in alphabetical order         return m1.getN().compareTo(m2.getN());      } }  // Main class  public class Geeks {     public static void main(String[] args) {                // Create a list of movies          ArrayList<Movie> m = new ArrayList<>();         m.add(new Movie("Force Awakens", 8.3, 2015));         m.add(new Movie("Star Wars", 8.7, 1977));         m.add(new Movie("Empire Strikes Back", 8.8, 1980));          // Sort movies by rating and display all         Collections.sort(m, new Rating());         System.out.println("Movies sorted by rating:");         for (Movie m1 : m) {             System.out.println(m1.getR() + " " + m1.getN() + " " + m1.getY());         }          // Sort movies by name and display all         Collections.sort(m, new NameCompare());         System.out.println("\nMovies sorted by name:");         for (Movie m1 : m) {             System.out.println(m1.getN() + " " + m1.getR() + " " + m1.getY());         }     } }

Output

Movies sorted by rating: 8.8 Empire Strikes Back 1980 8.7 Star Wars 1977 8.3 Force Awakens 2015  Movies sorted by name: Empire Strikes Back 8.8 1980 Force Awakens 8.3 2015 Star Wars 8.7 1977

Explanation: In the above example, the Comparator interface is used to sort the movies first by rating and then by name. The Rating and NameCompare classes implement custom sorting logic. The Collections.sort() method uses these comparators to sort the list by multiple criteria.

Important Point:

Comparator is a functional interface. So, now the question is why comparator is a functional interface?

Answer: Java 8 introduced functional interface. These interfaces has only one abstract method. But comparator has two methods that are compare(T o1, T o2) and equals(Object obj). Here, only compare() is an abstract method. The equals() method is inherited from the Object class and is not considered abstract in the interface.

Java Comparator Interface

kartik

Improve

Article Tags :

Practice Tags :

Java

Java Comparable vs Comparator

Difference Between Comparable and Comparator

Example of Comparable

Example of Comparator

Similar Reads

Lambda Expressions

Functional Interfaces

Method Reference

Streams

Java Stream Programs

Java Stream Methods

Comparable and Comparator

Optional Class

Date/Time API