Quelle utilisation de la méthode compareTo est plus compréhensible?

Question

Je veux trier les objets en fonction des valeurs booléennes et je veux trier les valeurs vraies avant les valeurs fausses.

Laquelle de ces implémentations de compareTo est plus lisible?

Utiliser -1 pour modifier le comportement par défaut

public class Example implements Comparable<Example>{ 

    Boolean isOk; 

    public int compareTo(Example o) { 
     return -1 * this.isOk.compareTo(o.isOk); 
    } 

} 

ou sur les côtés échange de la méthode booléenne # compareTo?

public class ExampleTwo implements Comparable<ExampleTwo>{ 

    Boolean isOk; 

    public int compareTo(ExampleTwo o) { 
     return o.isOk.compareTo(this.isOk); 
    } 

} 

Answer 1

La première forme est tout simplement faux - parce que si compareTo retours Integer.MIN_VALUE, il va essayer de nier - et entraîner Integer.MIN_VALUE à nouveau. Le moyen le plus simple de résoudre ce problème consiste simplement à utiliser le code du second extrait.

D'autre part:

• Les deux pourraient échouer si isOk est nulle
• Si vous êtes vraiment seulement à l'aide booléens, une simple table de vérité peut être plus simple
• Il est possible que Boolean.compareTo ne reviendra jamais Integer.MIN_VALUE. Je ne compterais pas sur cela cependant.

Answer 2

j'utiliser la Ordering class de Guava (anciennement Google Collections), il met en œuvre Comparator, de sorte qu'il peut être utilisé comme solution de remplacement:

Ordering<Object> reverseOrdering = Ordering.natural().reverse();