Is this right or wrong?

Question

Here is an excerpt from API doc for the interface, java.util.Comparator,
Caution should be exercised when using a comparator capable of imposing an ordering inconsistent with equals to order a sorted set (or sorted map). Suppose a sorted set (or sorted map) with an explicit Comparator c is used with elements (or keys) drawn from a set S. If the ordering imposed by c on S is inconsistent with equals, the sorted set (or sorted map) will behave "strangely." In particular the sorted set (or sorted map) will violate the general contract for set (or map), which is defined in terms of equals.
For example, if one adds two keys a and b such that (a.equals((Object)b) && c.compare((Object)a, (Object)b) != 0) to a sorted set with comparator c, the second add operation will return false (and the size of the sorted set will not increase) because a and b are equivalent from the sorted set's perspective.
Is it right? Will the second add operation fail?
In my opinion, the sorted set performs ordering in terms of compare/compareTo method, while a set decides whether to accept or refuse a new element by equals method. If this is the case, then under the situation described in the API doc, a and b are NOT equivalent from the sorted set's prespective, thus a and b can both be added successfully. And only if this happened, we could say[i] total ordering inconsistent with equals could work well for sorted set, but breaks the general contract for the set.
I'm totally confused.

Answer 1

I think the API comment you mention got it backwards. Did you whip up an example
to test this yourself?
import java.util.*;
public class Example {
    public int compare; //used to define comparator
    public int equal;   //used to define equals
    public Example(int compare, int equal) {
        this.compare = compare;
        this.equal = equal;
    public boolean equals(Object o) {
        if (!(o instanceof Example))
            return false;
        return equal == ((Example)o).equal;
    public String toString() {
        return "(compare=" + compare + ", equal=" + equal + ")";
    public static class C implements Comparator {
        public int compare(Object o1, Object o2) {
            return ((Example)o1).compare - ((Example)o2).compare;
    public static void main(String[] args) throws Exception {
        C c = new C();
        Set s = new TreeSet(c);
        Example a = new Example(0, 0);
        Example b = new Example(1, 0);
        System.out.println("a.equals(b) = " + a.equals(b));
        System.out.println("c.compare(a,b) = " + c.compare(a,b));
        s.add(a);
        System.out.println("after adding a, s =" + s);
        s.add(b);
        System.out.println("after adding b, s =" + s);
}