Java Comparable Interface

Comparable interface is a very important interface which can be used by Java Collections to compare custom objects and sort them. Using comparable interface, we can sort our custom objects in the same way how wrapper classes, string objects get sorted using Collections sorting methods.

Using comparable, we can make the elements as sortable.

Comparable Interface Methods

The Comparable interface defines a methods: compareTo(). The compareTo() method, shown here, compares the passed object for order −

The compare() Method

int compareTo(Object obj)

obj is the object to be compared. This method returns zero if the objects are equal. It returns a positive value if current object is greater than obj. Otherwise, a negative value is returned.

By overriding compareTo(), you can alter the way that objects are ordered. For example, to sort in a reverse order, you can implement a comparison method that reverses the outcome of a comparison.

The equals() Method

The equals() method, shown here, tests whether an object equals the invoking comparator −

boolean equals(Object obj)

obj is the object to be tested for equality. The method returns true if obj and the invoking object are both Comparator objects and use the same ordering. Otherwise, it returns false.

Overriding equals() is unnecessary, and most simple comparators will not do so.

Comparable Interface to Sort Custom Object

In this example, we”re using Comparable interface to sort a custom object Dog based on comparison criterias.

Example

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

class Dog implements Comparable<Dog> {
   private String name;
   private int age;
   Dog() {
   }

   Dog(String n, int a) {
      name = n;
      age = a;
   }

   public String getDogName() {
      return name;
   }

   public int getDogAge() {
      return age;
   }

   // Overriding the compareTo method
   public int compareTo(Dog d) {
      // compare the name using alphabetical order   
      return (this.name).compareTo(d.name);
   }

   @Override
   public String toString() {
      return this.name + "," + this.age;
   }
}

public class ComparableDemo {

   public static void main(String args[]) {
      // Takes a list o Dog objects
      List<Dog> list = new ArrayList<>();

      list.add(new Dog("Shaggy", 3));
      list.add(new Dog("Lacy", 2));
      list.add(new Dog("Roger", 10));
      list.add(new Dog("Tommy", 4));
      list.add(new Dog("Tammy", 1));

      Collections.sort(list);   // Sorts the array list
      System.out.println("Sorted by name:");
      // printing the sorted list of names
      System.out.print(list);
   }
}

Output

This will produce the following result −

Sorted by name:
[Lacy,2, Roger,10, Shaggy,3, Tammy,1, Tommy,4]

Note − Sorting of the Arrays class is as the same as the Collections.

Comparable Interface to Sort Custom Object in Reverse Order

Example

In this example, we”re using Collections.reverseOrder() method to reverse sort the Dog objects.

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

class Dog implements Comparable<Dog> {
   private String name;
   private int age;
   Dog() {
   }

   Dog(String n, int a) {
      name = n;
      age = a;
   }

   public String getDogName() {
      return name;
   }

   public int getDogAge() {
      return age;
   }

   // Overriding the compareTo method
   public int compareTo(Dog d) {
      return (this.name).compareTo(d.name);
   }

   @Override
   public String toString() {
      return this.name + "," + this.age;
   }
}

public class ComparableDemo {

   public static void main(String args[]) {
      // Takes a list o Dog objects
      List<Dog> list = new ArrayList<>();

      list.add(new Dog("Shaggy", 3));
      list.add(new Dog("Lacy", 2));
      list.add(new Dog("Roger", 10));
      list.add(new Dog("Tommy", 4));
      list.add(new Dog("Tammy", 1));

      Collections.sort(list, Collections.reverseOrder());   // Sorts the array list
      System.out.println("Sorted by name in reverse order:");
      // printing the sorted list of names
      System.out.print(list);
   }
}

Output

This will produce the following result −

Sorted by name in reverse order:
[Tommy,4, Tammy,1, Shaggy,3, Roger,10, Lacy,2]

Example

In this example, we”re using Comparable interface to sort Dog objects based on their ages.

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

class Dog implements Comparable<Dog> {
   private String name;
   private int age;
   Dog() {
   }

   Dog(String n, int a) {
      name = n;
      age = a;
   }

   public String getDogName() {
      return name;
   }

   public int getDogAge() {
      return age;
   }

   // Overriding the compareTo method
   public int compareTo(Dog d) {
      return this.age - d.age;
   }

   @Override
   public String toString() {
      return this.name + "," + this.age;
   }
}

public class ComparableDemo {

   public static void main(String args[]) {
      // Takes a list o Dog objects
      List<Dog> list = new ArrayList<>();

      list.add(new Dog("Shaggy", 3));
      list.add(new Dog("Lacy", 2));
      list.add(new Dog("Roger", 10));
      list.add(new Dog("Tommy", 4));
      list.add(new Dog("Tammy", 1));

      Collections.sort(list);   // Sorts the array list
      System.out.println("Sorted by age:");
      // printing the sorted list by age
      System.out.print(list);
   }
}

Output

This will produce the following result −

Sorted by age:
[Tammy,1, Lacy,2, Shaggy,3, Tommy,4, Roger,10]