Maison >Java >javaDidacticiel >Introduction et exemples de différences de Comparator et Comparable en Java
Cet article présente d'abord les deux interfaces Comparable et Comparator, ainsi que leurs différences, puis utilise des exemples pour illustrer leur utilisation ;
Introduction à Comparable
Comparable est une interface de tri.
Si une classe implémente l'interface Comparable, cela signifie "cette classe prend en charge le tri". Étant donné que la classe qui implémente l'interface Comparable prend en charge le tri, en supposant qu'il existe désormais une "Liste (ou tableau) d'objets de la classe qui implémente l'interface Comparable", la Liste (ou le tableau) peut être traitée via Collections.sort (ou Arrays.sort) Trier.
De plus, les « objets des classes qui implémentent l'interface Comparable » peuvent être utilisés comme clés dans les « Cartes ordonnées (telles que TreeMap) » ou comme éléments dans les « Ensembles ordonnés (TreeSet) » sans spécifier de périphérique de comparaison.
1. Le code du Comparable est le suivant :
public interface Comparable<T> {public int compareTo(T o); }
2. Le code du Comparateur est le suivant
public interface Comparator<T> {int compare(T o1, T o2);boolean equals(Object obj); // jdk1.8 后的方法default Comparator<T> reversed() {return Collections.reverseOrder(this); }default Comparator<T> thenComparing(Comparator<? super T> other) { Objects.requireNonNull(other);return (Comparator<T> & Serializable) (c1, c2) -> {int res = compare(c1, c2);return (res != 0) ? res : other.compare(c1, c2); }; }default <U> Comparator<T> thenComparing( Function<? super T, ? extends U> keyExtractor, Comparator<? super U> keyComparator) {return thenComparing(comparing(keyExtractor, keyComparator)); }default <U extends Comparable<? super U>> Comparator<T> thenComparing( Function<? super T, ? extends U> keyExtractor) {return thenComparing(comparing(keyExtractor)); }default Comparator<T> thenComparingInt(ToIntFunction<? super T> keyExtractor) {return thenComparing(comparingInt(keyExtractor)); }default Comparator<T> thenComparingLong(ToLongFunction<? super T> keyExtractor) {return thenComparing(comparingLong(keyExtractor)); }default Comparator<T> thenComparingDouble(ToDoubleFunction<? super T> keyExtractor) {return thenComparing(comparingDouble(keyExtractor)); }public static <T extends Comparable<? super T>> Comparator<T> reverseOrder() {return Collections.reverseOrder(); } @SuppressWarnings("unchecked")public static <T extends Comparable<? super T>> Comparator<T> naturalOrder() {return (Comparator<T>) Comparators.NaturalOrderComparator.INSTANCE; }public static <T> Comparator<T> nullsFirst(Comparator<? super T> comparator) {return new Comparators.NullComparator<>(true, comparator); }public static <T> Comparator<T> nullsLast(Comparator<? super T> comparator) {return new Comparators.NullComparator<>(false, comparator); }public static <T, U> Comparator<T> comparing( Function<? super T, ? extends U> keyExtractor, Comparator<? super U> keyComparator) { Objects.requireNonNull(keyExtractor); Objects.requireNonNull(keyComparator);return (Comparator<T> & Serializable) (c1, c2) -> keyComparator.compare(keyExtractor.apply(c1), keyExtractor.apply(c2)); }public static <T, U extends Comparable<? super U>> Comparator<T> comparing( Function<? super T, ? extends U> keyExtractor) { Objects.requireNonNull(keyExtractor);return (Comparator<T> & Serializable) (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2)); }public static <T> Comparator<T> comparingInt(ToIntFunction<? super T> keyExtractor) { Objects.requireNonNull(keyExtractor);return (Comparator<T> & Serializable) (c1, c2) -> Integer.compare(keyExtractor.applyAsInt(c1), keyExtractor.applyAsInt(c2)); }public static <T> Comparator<T> comparingLong(ToLongFunction<? super T> keyExtractor) { Objects.requireNonNull(keyExtractor);return (Comparator<T> & Serializable) (c1, c2) -> Long.compare(keyExtractor.applyAsLong(c1), keyExtractor.applyAsLong(c2)); }public static<T> Comparator<T> comparingDouble(ToDoubleFunction<? super T> keyExtractor) { Objects.requireNonNull(keyExtractor);return (Comparator<T> & Serializable) (c1, c2) -> Double.compare(keyExtractor.applyAsDouble(c1), keyExtractor.applyAsDouble(c2)); } }
Comparable La principale différence avec Comparator est :
(1) Comparator et Comparable sont tous deux des interfaces de comparaison internes en Java et sont utilisées pour trier une classe personnalisée
(2) La différence est que l'implémentation de l'interface Comparable est définie à l'intérieur de la classe et que le code de comparaison doit être intégré dans la structure interne de la classe
(3).Le comparateur est implémenté en dehors de la classe, et le premier comparateur est implémenté séparément. Il n'est pas nécessaire d'apporter des modifications structurelles à la classe d'origine, et il. est non intrusif.
Par exemple, implémentez l'interface Comparable :
class Score implements Comparable<Score>{ public int score; public int time; public int getScore() { return score; } public void setScore(int score) { this.score = score; } public int getTime() { return time; } public void setTime(int time) { this.time = time; } @Override public int compareTo(Score o) { if(this.time>o.time) return 1; else if(this.time==o.time) return 0; else return -1; } public Score(int score, int time) { super(); this.score = score; this.time = time; } }
Exemple d'implémentation de l'interface Comparator :
class ScoreComparator implements Comparator<Score>{ @Override public int compare(Score o1, Score o2) { if(o1.time>o2.time) return 1; else if(o1.time==o2.time) return 0; else return -1; } }Puis appelez ScoreComparator :
Ce qui précède est le contenu détaillé de. pour plus d'informations, suivez d'autres articles connexes sur le site Web de PHP en chinois!