307 Contributors: 13 Thursday, May 18, 2017
Licensed under: CC-BY-SA
Not affiliated with Stack Overflow
Rip Tutorial:
Roadmap: roadmap

Comparable and Comparator


  • public class MyClass implements Comparable<MyClass>
  • public class MyComparator implements Comparator<SomeOtherClass>
  • public int compareTo(MyClass other)
  • public int compare(SomeOtherClass o1, SomeOtherClass o2)


When implementing a compareTo(..) method which depends upon a double, do not do the following:

public int comareTo(MyClass other) {
    return (int)(doubleField - other.doubleField); //THIS IS BAD

The truncation caused by the (int) cast will cause the method to sometimes incorrectly return 0 instead of a positive or negative number, and can thus lead to comparison and sorting bugs.

Instead, the simplest correct implementation is to use, as such:

public int comareTo(MyClass other) {
    return,other.doubleField); //THIS IS GOOD

A non-generic version of Comparable<T>, simply Comparable, has existed since Java 1.2. Other than for interfacing with legacy code, it's always better to implement the generic version Comparable<T>, as it doesn't require casting upon comparison.

It is very standard for a class to be comparable to itself, as in:

public class A implements Comparable<A>

While it is possible to break from this paradigm, be cautious when doing so.

A Comparator<T> can still be used on instances of a class if that class implements Comparable<T>. In this case, the Comparator's logic will be used; the natural ordering specified by the Comparable implementation will be ignored.

Related Examples