Comparator和Comparable的compare和compareTo方法的协定

Question

When implementing the Comparator and Comparable interfaces, is it required to ensure that:

If

• x.compare(Object obj1, Object obj2) == x.compare(Object obj3, Object obj2)

or

• obj1.compareTo(obj2) == obj3.compareTo(obj2) ,

then obj1.equals(obj3) must be true ?

Answer 1

Not necessarily.

What you're describing is the transitive relation between three given objects, and as far as both of the interfaces are concerned, the relationship while using them must be transitive between them.

This is to say, given three classes A , B , and C that are comparable amongst each other, if A.compareTo(B) == 0 && B.compareTo(C) == 0 , then A.compareTo(C) == 0 . The same principle applies for Comparator .

What you're now conflating is the difference between compareTo and equals . While these two are closely related, there isn't anything to enforce the very strong recommendation provided in the documentation:

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."

It is certainly possible and valid to have an equals definition inconsistent with compareTo or even compare , but depending on the nature of the program, it can lead to obscure bugs. If you find yourself in a situation in which you need to rely on both equals and compareTo (or compare ), document it and be consistent with its usage.

Answer 2

No, because the comparing of two objects only establishes that one is greater than, equal to, or less than the other. Normally the result returned from a comparator is one of (-1,0,1). For example:

comparator.compare(1,5) == -1
comparator.compare(1,3) == -1
comparator.compare(3,1) == 1
comparator.compare(5,3) == 1
comparator.compare(3,3) == 0

This makes it much easier for developers to compare between objects. If the contract required that the scale of the difference be returned, it would be very difficult to implement such a method for, say, strings. In order to obtain an exact value difference, the entire contents of both strings would have to be read, which could be very bad for performance, especially if each of these strings we very large. Because a determination only has to be made about which is larger than the other, normally only small portions of the strings need be compared to determine which is "larger" than the other. The only time the entire string would have to be processed is if they were in fact equal. This performance issue is also the reason why hashes are preferred, when possible