Comparable and Comparator in Java
Published: 2024-05-12 08:25:35

In java-8  comparable and comparator interface are used for sorting object using custom logic .
However there are some diffrences between them listed as below : 
 

## Comparable Interface : 

- For implementing comparable interface we have to override the **compareTo()** method.

- CompareTo method takes only one arguement, which is the object being compared.

- This CompareTo method has to be implemented in the class to define the natural ordering of the objects.

- It allow us to define single sorting criteria.

- Interface Signature : 

```
public interface Comparable<T> {
    public int compareTo(T o);
}

```


## Comparator Interface : 

- For implementing Comparator interface we have to override the **compare()** method of the interface.

- This method takes two parameters and  compares them (o1 and o2) 
  and returns:

>     a negative integer if o1 is less than o2.
>     zero if o1 is equal to o2.
>     a positive integer if o1 is greater than o2.

- It allow is to define multiple sorting criteria and can be used to sort object in diffrent ways. 

- Interface Signature : 

```
public interface Comparator<T> {
    public int compare(T o1, T o2);
}

```

## Example :

```
import java.util.ArrayList;
import java.util.Collections;
import java.util.Comparator;
import java.util.List;

// Example class representing a Student
class Student implements Comparable<Student> {
    private String name;
    private int id;
    private int age;

    // Constructor
    public Student(String name, int id, int age) {
        this.name = name;
        this.id = id;
        this.age = age;
    }

    // Getters
    public String getName() {
        return name;
    }

    public int getId() {
        return id;
    }

    public int getAge() {
        return age;
    }

    // Implementing Comparable interface based on student id
    @Override
    public int compareTo(Student other) {
        return Integer.compare(this.id, other.id);
    }

    // toString method for displaying student details
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", id=" + id +
                ", age=" + age +
                '}';
    }
}

// Comparator to sort students by age
class AgeComparator implements Comparator<Student> {
    @Override
    public int compare(Student s1, Student s2) {
        return Integer.compare(s1.getAge(), s2.getAge());
    }
}

public class ComparableComparatorExample {
    public static void main(String[] args) {
        // Creating a list of students
        List<Student> students = new ArrayList<>();
        students.add(new Student("Ram", 101, 20));
        students.add(new Student("Shyam", 102, 22));
        students.add(new Student("Raj", 103, 21));
        // Sorting students using Comparable (by student id)
        Collections.sort(students);
        System.out.println("Students sorted by ID (Comparable):");
        for (Student student : students) {
            System.out.println(student);
        }

        // Sorting students using Comparator (by age)
        Collections.sort(students, new AgeComparator());
        System.out.println("\nStudents sorted by Age (Comparator):");
        for (Student student : students) {
            System.out.println(student);
        }
    }
}


```

## In above Example :

- The Student class implements the Comparable interface based on the student ID. This allows sorting a list of students by their IDs.
- The AgeComparator class implements the Comparator interface to provide custom sorting logic based on student ages.
- In the main method, we create a list of Student objects and sort them first using the natural ordering defined by Comparable and then using the custom ordering defined by Comparator.