How to Implement the Java Comparable Interface

How to implement the Java comparable interface?

You just have to define that Animal implements Comparable<Animal> i.e. public class Animal implements Comparable<Animal>. And then you have to implement the compareTo(Animal other) method that way you like it.

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

Using this implementation of compareTo, animals with a higher year_discovered will get ordered higher. I hope you get the idea of Comparable and compareTo with this example.

How to implement the Comparable interface?

You want to sort by the title, but you have used year in your compareTo method as follows:

@Override
public int compareTo(Movie m) {
    return Integer.compare(m1.getYear(), m2.getYear());
}

Change it to

@Override
public int compareTo(Movie m) {
    int c;
    if(this.title!=null && m!=null && m.getTitle()!=null){  
        c = this.title.compareTo(m.getTitle());
        if (c == 0)
            c = Integer.compare(this.year, m.getYear());            
    }
    return c;
}

For more flexibility, you can use Comparator instead of Comparable as discussed at Java : Comparable vs Comparator

Update: I just went through your question again and realized that first, you want to compare the title and then in case of a tie, you want to compare on year. I have updated the code given above. Additionally, I have provided another approach (using Comparator) below:

public class MovieCompartor implements Comparator<Movie>{
    public int compare(Movie m1, Movie m2) {
        int c;
        if(m!=null && m2!=null){
            if(m1.getTitle()!=null && m2.getTitle()!=null)
                c = m1.getTitle().compareTo(m2.getTitle());
            if (c == 0)
                c = Integer.compare(m1.getYear(), m2.getYear());            
        }
        return c;
    }
}

Then you use Collections.sort(movies, new MovieCompartor()) instead of Collections.sort(movies).

Implementing the Java comparable interface?

A few points worth noting.

1. As other answers have noted you generally should only implement Comparable if there's a natural ordering for instances of the class. As there's no natural ordering for complex numbers you likely shouldn't implement Comparable.

2. If you are going to provide a natural ordering then you should implement Comparable<Complex> to denote comparing to other instances of Complex (rather than comparing to other objects).

3. A better alternative to implementing Comparable is to provide one or more Comparator objects for your class that can be used to provide as many orderings as you want. For example:

   public class Complex {
       private double real;
       private double imaginary;
   
       public static final Comparator<Complex> COMPARE_BY_REAL =
           Comparator.comparingDouble(Complex::getReal);
   
       public static final Comparator<Complex> COMPARE_BY_IMAGINARY =
           Comparator.comparingDouble(Complex::getImaginary);
   
       public static final Comparator<Complex> COMPARE_BY_MODULUS =
           Comparator.comparingDouble(Complex::getModulus);
   
       private double getModulus() {
           return Math.sqrt(real * real + imaginary * imaginary);
       }
    }
   

Then the user of the class can choose the ordering that makes sense to the use:

Optional<Complex> closestToOrigin = complexList.stream().min(Complex::COMPARE_BY_MODULUS);

Implementing Comparable interface for a generic class with Type parameter

Another option is, instead of implementing Comparable, have a static method that returns a Comparator, and this method can only be called when the constraint on T is met. So then your ClassX can be used with T that do not implement Comparable, but you can only obtain Comparators for ClassXs with T that do implement Comparable.

public class ClassX<T> {
    private T o;

    // ...

    public static <T extends Comparable<? super T>> Comparator<ClassX<T>> getComparator() {
        return (x, y) -> x.o.compareTo(y.o);
    }
}

Java and Comparable

Java is a Object Oriented Based language. Which supports inheritance through classes/ polymorphism through class/abstract class/interface

interface Comparable<T> {
  // methods
}

class Person implements Comparable<Person> {
//methods
}

This essentially means any object of the Type Person is also of the Comparable Type.

interface Runnable {}
class Task implements Runnable {}

this means any object created of Task class is also of the Runnable Type.

This is what the author means.

If you do not implement Comparable interface, yet define the compareTo() method, you are just defining a method inside the class, as any other method. YOU ARE NOT OVERRIDING THE compareTo() method in the Comparable interface defined.

You can still compare each object using your compareTo() method, but you need to define your own sort method which internally would call compareTo() method to get the list in a sorted way.

The Java API Collections.sort() internally converts the list to an Object[] and calls the Arrays.sort(). Now Arrays.sort() will use a modified version of the TimSort Algorithm for sorting and the contract is - it does the sorting of elements of the Array only if they are of the Comparable Type.

• ComparableTimSort
• Collections.sort()

You can check, for all of the internal calls, it states clearly :

@throws IllegalArgumentException (optional) if the comparator is
found to violate the {@link Comparator} contract

So to pass any Object Types to the sort() it has to be also of the type Comparable. Strings/Wrappers are already of the Comparable Type. Hence you need to take care of this contract while defining your user defined objects.

"Without implementing that interface, all we have is a method named compareTo(), but it wouldn't be a Comparable object."

-Simply put, it means without implementing the interface, you have a Duck type object, NOT comparable type

How to Implement the Comparable Interface and Why Should We Implement It

why would we ever need to implement the Comparable Interface when we
can write our own compareTo() method without the implementation

Take for example Collections.sort. The signature is

public static <T extends Comparable<? super T>> void sort(List<T> var0)

The generic type parameter means that we can only sort lists of things which are comparable to themselves (or subtypes). For example, we can sort a list of strings because String implements Comparable<String>. That is, a string knows whether it should naturally fall before or after another string.

Without an interface to define this constraint, this method could not exist.

---

What is the best way to override the compareTo() method of the
Comparable Interface?

That entirely depends on the class you're working with. If it does not have a clear natural ordering then maybe you shouldn't. A seat could be sorted either by number or by price. It doesn't necessarily make sense to choose one arbitrarily.

For that reason, often methods such as the above Collections.sort will provide a second signature which takes a Comparator:

public static <T> void sort(List<T> var0, Comparator<? super T> var1)

This means that we don't have to arbitrarily define whether a seat is naturally ordered by number or price. We can have one piece of code which uses one comparator to sort by price, and another totally separate piece of code which uses another comparator to sort by seat number.

One advantage of implementing Comparable is that you don't need to necessarily expose internal class details to determine an instances ordering as you would with a Comparator.

Java Using The Comparable Interface

You should have Vehicle implement Comparable<Vehicle>, so your compareTo method can take a Vehicle argument rather than having to cast.

But if you're asking how to implement the compareTo method, then if this vehicle is supposed to be less than the other vehicle, return a negative number; if it's supposed to be greater, return a positive number, and if they're supposed to be equal, return 0. You'll probably be using color.compareTo(otherVehicle.color) to compare the colors, since they are Strings.

That should be enough hints!

---

Related Topics