---
title: "Explain the difference between Comparator and Comparable in Java."  
description: "Explain the difference between Comparator and Comparable in Java."  
author: "Anubhav Sharma"  
published: 2024-07-18  
updated: 2024-07-19  
canonical: https://www.mindstick.com/forum/160953/explain-the-difference-between-comparator-and-comparable-in-java  
category: "java"  
tags: ["java", "javac"]  
reading_time: 4 minutes  

---

# Explain the difference between Comparator and Comparable in Java.

[Explain the difference](https://www.mindstick.com/forum/156125/can-you-explain-the-difference-between-organic-and-paid-results) between Comparator and [Comparable](https://www.mindstick.com/interview/2521/what-is-the-difference-between-comparable-and-comparator) in Java.

## Replies

### Reply by Ravi Vishwakarma

`Comparator` and `Comparable` are both interfaces used to define the natural ordering of objects and provide ways to compare objects. However, they have different purposes and are used in different contexts.

#### Comparable

`Comparable` is an interface in Java used to define the natural ordering of objects of a class. A class that implements the `Comparable` interface needs to override the `compareTo` method to specify how objects of that class should be compared.

## Key Characteristics:

- **Single Sorting Sequence**: A class can have only one implementation of the `compareTo` method, defining a single sorting sequence.
- **Method**: The method to be implemented is `compareTo(Object o)`.
- **Package**: Part of the `java.lang` package.
- **In-Class Implementation**: The comparison logic is defined within the class itself.

**Usage Example:** Here's how you can use `Comparable` to sort a list of `Person` objects by their `age`:

```java
public class Person implements Comparable<Person> {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public int compareTo(Person other) {
        return Integer.compare(this.age, other.age);
    }

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

    public static void main(String[] args) {
        List<Person> people = new ArrayList<>();
        people.add(new Person("Alice", 30));
        people.add(new Person("Bob", 25));
        people.add(new Person("Charlie", 35));

        Collections.sort(people);
        people.forEach(System.out::println);
    }
}
```

## Output:

```plaintext
Bob: 25
Alice: 30
Charlie: 35
```

#### Comparator

`Comparator` is an interface in Java used to define multiple ways of comparing objects of a class. It is used to create custom comparison logic separate from the class itself.

## Key Characteristics:

- **Multiple Sorting Sequences**: A class can have multiple implementations of the `Comparator` interface, each defining a different sorting sequence.
- **Method**: The main method to be implemented is `compare(Object o1, Object o2)`.
- **Package**: Part of the `java.util` package.
- **External Implementation**: The comparison logic is defined outside the class, allowing for more flexibility.

**Usage Example:** Here's how you can use `Comparator` to sort a list of `Person` objects by their `name` and `age`:

```java
import java.util.*;

public class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

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

    public static void main(String[] args) {
        List<Person> people = new ArrayList<>();
        people.add(new Person("Alice", 30));
        people.add(new Person("Bob", 25));
        people.add(new Person("Charlie", 35));

        // Sort by name
        Collections.sort(people, new Comparator<Person>() {
            @Override
            public int compare(Person p1, Person p2) {
                return p1.getName().compareTo(p2.getName());
            }
        });
        people.forEach(System.out::println);

        System.out.println();

        // Sort by age
        Collections.sort(people, new Comparator<Person>() {
            @Override
            public int compare(Person p1, Person p2) {
                return Integer.compare(p1.getAge(), p2.getAge());
            }
        });
        people.forEach(System.out::println);
    }
}
```

## Output:

```plaintext
Alice: 30
Bob: 25
Charlie: 35

Bob: 25
Alice: 30
Charlie: 35
```

## Summary of Differences

| Feature | Comparable | Comparator |
| --- | --- | --- |
| Package | `java.lang` | `java.util` |
| Method | `compareTo(Object o)` | `compare(Object o1, Object o2)` |
| Sorting Sequence | Single natural ordering defined within the class | Multiple custom orderings defined outside the class |
| Implementation | Class implements `Comparable` | Class uses a `Comparator` implementation |
| Flexibility | Less flexible (single sort sequence) | More flexible (multiple sort sequences possible) |

## When to Use

- **Comparable**: Use when you need a single, default sorting sequence for objects of a class. Implementing `Comparable` makes sense if the class has a natural order.
- **Comparator**: Use when you need multiple sorting sequences or when you want to separate the comparison logic from the class itself. This is useful for complex sorting scenarios or when the sorting criteria might change.


---

Original Source: https://www.mindstick.com/forum/160953/explain-the-difference-between-comparator-and-comparable-in-java

Copyright © MindStick Software Pvt. Ltd. This Markdown version is provided for developers, AI systems, and offline reading.