Einführung und Differenzbeispiele von Comparator und Comparable in Java

In diesem Artikel werden zunächst die beiden Schnittstellen Comparable und Comparator sowie deren Unterschiede vorgestellt und anschließend anhand von Beispielen deren Verwendung veranschaulicht.

Comparable-Einführung

Comparable ist eine Sortierschnittstelle.

Wenn eine Klasse die Comparable-Schnittstelle implementiert, bedeutet dies „Diese Klasse unterstützt die Sortierung“. Da die Klasse, die die Comparable-Schnittstelle implementiert, das Sortieren unterstützt, kann die Liste (oder das Array) über Collections.sort (oder) verarbeitet werden, vorausgesetzt, es gibt nun eine „Liste (oder ein Array) von Objekten der Klasse, die die Comparable-Schnittstelle implementiert“. Arrays.sort) Sortieren.

Darüber hinaus können „Objekte von Klassen, die die Comparable-Schnittstelle implementieren“ als Schlüssel in „Ordered Maps (wie TreeMap)“ oder Elemente in „Ordered Sets (TreeSet)“ verwendet werden, ohne dass ein Vergleichsgerät angegeben werden muss.

1. Der Code von Comparable lautet wie folgt:

public interface Comparable<T> {public int compareTo(T o);
}

2. Der Code von Comparator lautet wie folgt:

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 Der Hauptunterschied zu Comparator ist:

　(1) Comparator und Comparable sind beide interne Komparatorschnittstellen in Java und werden zum Sortieren einer benutzerdefinierten Klasse verwendet

　 (2) Der Unterschied besteht darin, dass die Implementierung der Comparable-Schnittstelle innerhalb der Klasse definiert ist und der Vergleichscode in die interne Struktur der Klasse eingebettet werden muss

　(3). Der Komparator wird außerhalb der Klasse implementiert, und der erste Komparator wird separat implementiert. Es sind keine strukturellen Änderungen an der ursprünglichen Klasse erforderlich ist nicht aufdringlich.

Implementieren Sie beispielsweise die Comparable-Schnittstelle:

    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;  
        }  
    }

Beispiel für die Implementierung der Comparator-Schnittstelle:

    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;  
        }     
    }

Rufen Sie dann ScoreComparator auf:

Arrays.sort(score, new ScoreComparator());

Das obige ist der detaillierte Inhalt vonEinführung und Differenzbeispiele von Comparator und Comparable in Java. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!