Suponha que eu preciseTreeSet com elementos classificados com alguma lógica de domínio. Por essa lógica, não importa a ordem de alguns elementos que não sejam iguais, portanto, o método compare pode retornar 0, mas, neste caso, eu não poderia colocá-los emTreeSet.

Então, pergunta: quais desvantagens terei de código como este:

class Foo implements Comparable<Foo>{}
new TreeSet<Foo>(new Comparator<Foo>(){
    @Override
    public int compare(Foo o1, Foo o2) {
        int res = o1.compareTo(o2);
        if(res == 0 || !o1.equals(o2)){
            return o1.hashCode() - o2.hashCode();
        }
        return res;
    }
});

Atualizar:

Está bem. Se deve sempre haver uma consistência entre os métodosequals(), hashcode() ecompareTo(), como @ S.P. Floyd - seanizer e outros disseram. Se seria melhor ou até bom se eu removerComparable interface e mover essa lógica emComparator (Eu posso fazer isso sem encapsulamento quebrado)? Então será:

class Foo{}
new TreeSet<Foo>(new Comparator<Foo>(){
    @Override
    public int compare(Foo o1, Foo o2) {
        //some logic start
        if(strictliBigger(o1, o2)){ return 1;}
        if(strictliBigger(o2, o1)){ return -1;}
        //some logic end
        if(res == 0 || !o1.equals(o2)){
            return o1.hashCode() - o2.hashCode();
        }
        return res;
    }
});

Atualização 2:

SeriaSystem.identityHashCode(x) ser melhor quehashCode() se eu não precisar de classificação estável?