The a.compareTo(b) function is used to determine the order of 2
objects. If a is is ordinally higher, it returns 1; lower returns -1;
and the same value returns 0;
Take the following example.
public class CompareTest{
public static void main(String[] args){
String a = "a";
String b = "b";
String c = "a";
System.out.println("a.compareTo(b) = "+a.compareTo(b));
System.out.println("b.compareTo(a) = "+b.compareTo(a));
System.out.println("a.compareTo(c) = "+a.compareTo(c));
}
}
running this program gives the following output:
a.compareTo(b) = -1
b.compareTo(a) = 1
a.compareTo(c) = 0
JavaDocs:
-------------
public int compareTo(Object o)
Compares this object with the specified object for order. Returns
a negative integer, zero, or a positive integer as this object is less
than, equal to, or greater than the specified object.
In the foregoing description, the notation sgn(expression)
designates the mathematical signum function, which is defined to
return one of -1, 0, or 1 according to whether the value of expression
is negative, zero or positive. The implementor must ensure
sgn(x.compareTo(y)) == -sgn(y.compareTo(x)) for all x and y. (This
implies that x.compareTo(y) must throw an exception iff y.compareTo(x)
throws an exception.)
The implementor must also ensure that the relation is transitive:
(x.compareTo(y)>0 && y.compareTo(z)>0) implies x.compareTo(z)>0.
Finally, the implementer must ensure that x.compareTo(y)==0
implies that sgn(x.compareTo(z)) == sgn(y.compareTo(z)), for all z.
It is strongly recommended, but not strictly required that
(x.compareTo(y)==0) == (x.equals(y)). Generally speaking, any class
that implements the Comparable interface and violates this condition
should clearly indicate this fact. The recommended language is "Note:
this class has a natural ordering that is inconsistent with equals."
Parameters:
o - the Object to be compared.
Returns:
a negative integer, zero, or a positive integer as this object
is less than, equal to, or greater than the specified object.
Throws:
ClassCastException - if the specified object's type prevents
it from being compared to this Object.