Detaillierte Erklärung des Java8-Komparators zum Sortieren einer Liste

Java8-Komparator – Ausführliche Erklärung zum Sortieren von Listen

In diesem Artikel sehen wir mehrere Details zum Sortieren von Listen im Java 8-Beispiel.

Alphabetisch sortierenStringListe

List<String> cities = Arrays.asList(
       "Milan",
       "london",
       "San Francisco",
       "Tokyo",
       "New Delhi"
);
System.out.println(cities);
//[Milan, london, San Francisco, Tokyo, New Delhi]
cities.sort(String.CASE_INSENSITIVE_ORDER);
System.out.println(cities);
//[london, Milan, New Delhi, San Francisco, Tokyo]
cities.sort(Comparator.naturalOrder());
System.out.println(cities);
//[Milan, New Delhi, San Francisco, Tokyo, london]

Londons „L“ verwendet Kleinbuchstaben, um Comparator.naturalOrder() (zuerst zurückgeben) besser hervorzuheben. Differenz zwischen einem Komparator, der Großbuchstaben sortiert Buchstaben) und String.CASE_INSENSITIVE_ORDER (ein Komparator, der Buchstaben ohne Berücksichtigung der Groß- und Kleinschreibung zurückgibt).

Grundsätzlich haben wir in Java 7 Collection.sort(), das eine Liste und schließlich einen Komparator akzeptiert – in Java 8 haben wir das neue List.sort(), das einen Komparator akzeptiert.

Sortieren Sie eine Liste von Ganzzahlen

List<Integer> numbers = Arrays.asList(6, 2, 1, 4, 9);
System.out.println(numbers); //[6, 2, 1, 4, 9]
numbers.sort(Comparator.naturalOrder());
System.out.println(numbers); //[1, 2, 4, 6, 9]

Sortieren Sie eine Liste nach einem Zeichenfolgenfeld

Angenommen, wir haben eine Movie-Klasse und möchten „ nach Titel „title“ sortiert die Liste. Wir können Comparator.comparing() verwenden und eine -Funktion übergeben, die das Feld extrahiert, das zum Sortieren des Titels verwendet wird – in diesem Fall.

List<Movie> movies = Arrays.asList(
        new Movie("Lord of the rings"),
        new Movie("Back to the future"),
        new Movie("Carlito&#39;s way"),
        new Movie("Pulp fiction"));
movies.sort(Comparator.comparing(Movie::getTitle));
movies.forEach(System.out::println);

Ausgabe:

Movie{title='Back to the future'}
Movie{title='Carlito's way'}
Movie{title='Lord of the rings'}
Movie{title='Pulp fiction'}

Vielleicht werden Sie feststellen, dass wir keinen Komparator übergeben, die Liste jedoch korrekt sortiert ist. Dies liegt daran, dass title – das extrahierte Feld – eine Zeichenfolge ist und Zeichenfolgen die Comparable -Schnittstelle implementieren. Wenn Sie sich die Implementierung von Comparator.comparing() ansehen, werden Sie feststellen, dass sie CompareTo für den extrahierten Schlüssel aufruft.

return (Comparator<T> & Serializable)
            (c1, c2) -> keyExtractor.apply(c1).compareTo(keyExtractor.apply(c2));

Sortieren Sie die Liste nach Double-Feld

Auf ähnliche Weise können wir Comparator.comparingDouble() verwenden, um Double-Werte zu vergleichen. Im Beispiel möchten wir eine Liste von Filmen von der höchsten zur niedrigsten Bewertung ordnen.

List<Movie> movies = Arrays.asList(
        new Movie("Lord of the rings", 8.8),
        new Movie("Back to the future", 8.5),
        new Movie("Carlito&#39;s way", 7.9),
        new Movie("Pulp fiction", 8.9));
movies.sort(Comparator.comparingDouble(Movie::getRating)
                      .reversed());
movies.forEach(System.out::println);

Wir verwenden die umgekehrte Funktion auf dem Komparator, um die standardmäßige natürliche Reihenfolge vom niedrigsten zum höchsten umzukehren. Comparator.comparingDouble() verwendet Double.compare() intern.

Wenn Sie int oder long vergleichen müssen, können Sie vergleichendeInt() bzw. vergleichendeLong() verwenden.

Sortieren Sie die Liste mit einem benutzerdefinierten Komparator

Im vorherigen Beispiel haben wir keinen Komparator angegeben, da dies nicht erforderlich war, aber sehen wir uns ein Beispiel an, in dem wir einen eigenen Komparator definiert haben. Unsere Movie-Klasse verfügt über ein neues Feld – „starred“ – das mithilfe des dritten -Konstruktorparameters festgelegt wird. Im Beispiel wollen wir die Liste so sortieren, dass die markierten Filme ganz oben in der Liste stehen.

List<Movie> movies = Arrays.asList(
        new Movie("Lord of the rings", 8.8, true),
        new Movie("Back to the future", 8.5, false),
        new Movie("Carlito&#39;s way", 7.9, true),
        new Movie("Pulp fiction", 8.9, false));
movies.sort(new Comparator<Movie>() {
    @Override
    public int compare(Movie m1, Movie m2) {
        if(m1.getStarred() == m2.getStarred()){
            return 0;
        }
        return m1.getStarred() ? -1 : 1;
     }
});
movies.forEach(System.out::println);

Das Ergebnis wird sein:

Movie{starred=true, title='Lord of the rings', rating=8.8}
Movie{starred=true, title='Carlito's way', rating=7.9}
Movie{starred=false, title='Back to the future', rating=8.5}
Movie{starred=false, title='Pulp fiction', rating=8.9}

Wir können natürlich LambdaAusdruck anstelle der Anonymous-Klasse wie folgt verwenden:

movies.sort((m1, m2) -> {
    if(m1.getStarred() == m2.getStarred()){
        return 0;
    }
    return m1.getStarred() ? -1 : 1;
});

Wir können Comparator.comparing() auch wieder verwenden:

movies.sort(Comparator.comparing(Movie::getStarred, (star1, star2) -> {
    if(star1 == star2){
         return 0;
    }
    return star1 ? -1 : 1;
}));

Im neuesten Beispiel nimmt Comparator.comparing() das erste Argument als Funktion, die den zum Sortieren verwendeten Schlüssel extrahiert, und Pass Comparator als zweiter Parameter. Der Komparator verwendet extrahierte Schlüssel zum Vergleich. Star1 und Star2 sind tatsächlich boolesche Werte, die jeweils m1.getStarred() und m2.getStarred() darstellen.

Sortieren Sie die Liste mit einer Vergleichskette

Im letzten Beispiel werden wir die Filme mit den besten Filmen anführen und dann nach Bewertung sortieren.

List<Movie> movies = Arrays.asList(
        new Movie("Lord of the rings", 8.8, true),
        new Movie("Back to the future", 8.5, false),
        new Movie("Carlito&#39;s way", 7.9, true),
        new Movie("Pulp fiction", 8.9, false));
movies.sort(Comparator.comparing(Movie::getStarred)
                      .reversed()
                      .thenComparing(Comparator.comparing(Movie::getRating)
                      .reversed())
);
movies.forEach(System.out::println);

Die Ausgabe ist:

Movie{starred=true, title='Lord of the rings', rating=8.8}
Movie{starred=true, title='Carlito's way', rating=7.9}
Movie{starred=false, title='Pulp fiction', rating=8.9}
Movie{starred=false, title='Back to the future', rating=8.5}

Wie Sie sehen, sortieren wir zuerst nach Sternen und dann nach Bewertung – beides umgekehrt, weil wir den höchsten Wert und die tatsächliche Zahl wollen eins.

Das obige ist der detaillierte Inhalt vonDetaillierte Erklärung des Java8-Komparators zum Sortieren einer Liste. Für weitere Informationen folgen Sie bitte anderen verwandten Artikeln auf der PHP chinesischen Website!