Java Comparable Interface Example

Java Comparable interface is used to order the objects of the user-defined class. This interface is found in java.lang package and contains only one method named compareTo(Object). It provides a single sorting sequence only, i.e., you can sort the elements on the basis of single data member only.

By default, a user-defined class is not comparable. That is, its objects can’t be compared. To make an object comparable, the class must implement the Comparable interface.

Java Comparable Interface Example - Sort User-Defined Objects in Ascending Order

This is example demonstrate that we create a list of person objects and we compare each person's age by using compateTo() method of Comparable Interface.
In short, we are sorting persons by age in ascending order.
public class Person implements Comparable<Person> {

    private int id;

    private String name;

    private int age;

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

    public int getId() {
        return id;
    }

    public void setId(int id) {
        this.id = id;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }
 
    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    @Override
    public String toString() {
        return this.name;
    }

    @Override
    public int compareTo(Person otherPerson) {
        return (this.getAge() - otherPerson.getAge());
    }
}
import java.util.ArrayList;

import java.util.Collections;
import java.util.List;

public class PersonSorterInASC {
    public static void main(String[] args) {
         sortUserDefinedObjectsInAsc();
    }

    private static void sortUserDefinedObjectsInAsc() {
        List<Person> persons = new ArrayList<Person>();
        Person person1 = new Person(59, "John", 40);
        Person person12 = new Person(67, "Roger", 25);
        Person person13 = new Person(45, "Steven", 30);
        persons.add(person1);
        persons.add(person12);
        persons.add(person13);

        System.out.println("Before Sorting : " + persons);
        Collections.sort(persons);
        System.out.println("After Sorting : " + persons);
    }
}
Output:
Before Sorting : [John, Roger, Steven]
After Sorting : [Roger, Steven, John]

Java Comparable Interface Example - Sort User-Defined Objects in Descending Order

Java provides in build utility method sort() and Collections.reverseOrder() to sort the objects in descending order.

Collections.reverseOrder()

Returns a comparator that imposes the reverse of the natural ordering on a collection of objects that implement the Comparable interface.
Collections.sort(persons, Collections.reverseOrder());
This example demonstrates that we are sorting person objects by age in descending order.
public class PersonSorterInDESC {

    public static void main(String[] args) {
        sortUserDefinedObjectsinDesc();
    }
 
    private static void sortUserDefinedObjectsinDesc(){
        List<Person> persons = new ArrayList<Person>();
        Person person1 = new Person(59, "John", 40);
        Person person12 = new Person(67, "Roger", 25);
        Person person13 = new Person(45, "Steven", 30);
        persons.add(person1);
        persons.add(person12);
        persons.add(person13);

        System.out.println("Before Sorting : " + persons);
        Collections.sort(persons, Collections.reverseOrder());
  
        System.out.println(" Sort in decending order : " + persons);
    }
}
Output:
Before Sorting : [John, Roger, Steven]
Sort in decending order : [John, Steven, Roger]

Comments