Lernen Comparator: Benutzerdefinierter Vergleich von Daten

Swipe um das Menü anzuzeigen

Betrachten wir die zweite funktionale Schnittstelle, Comparator, analysieren, wie sie den Vergleich implementiert, und verstehen den Unterschied zwischen Comparator und Comparable.

Was ist Comparator?

Die Schlüsselmethode in der funktionalen Schnittstelle Comparator ist:

int compare(T o1, T o2);

Die Methode compare(T o1, T o2) gibt zurück:

Eine negative Zahl, wenn o1 kleiner als o2 ist;
Null, wenn o1 und o2 gleich sind;
Eine positive Zahl, wenn o1 größer als o2 ist.

Praktische Anwendung

Implementierung der Sortierung von Book-Objekten unter Verwendung des Comparator Interface. Anstatt der Implementierung der Vergleichsmethode innerhalb der Book-Klasse selbst verwenden Sie statische Methoden des Comparator zur Definition der Sortierlogik.

Main.java


              1234567891011121314151617181920212223242526272829303132333435363738394041424344454647484950515253
            
package com.example;

import java.util.List;
import java.util.ArrayList;
import java.util.Comparator;

public class Main {
    public static void main(String[] args) {
        List<Book> books = new ArrayList<>();
        books.add(new Book("The Great Gatsby", "F. Scott Fitzgerald", 1925));
        books.add(new Book("To Kill a Mockingbird", "Harper Lee", 1960));
        books.add(new Book("1984", "George Orwell", 1949));
  
        // Sort by title
        books.sort(Comparator.comparing(Book::getTitle));
        System.out.println("Sorted by title: " + books);
        
        System.out.println("------------------------");

        // Sort by author
        books.sort(Comparator.comparing(Book::getAuthor));
        System.out.println("Sorted by author: " + books);
    }
}

class Book {
    private String title;
    private String author;
    private int year;

    public Book(String title, String author, int year) {
       this.title = title;
       this.author = author;
       this.year = year;
    }

    public String getTitle() {
       return title;
    }

    public String getAuthor() {
       return author;
    }

    public int getYear() {
       return year;
    }

    @Override
    public String toString() {
       return title + " by " + author + " (" + year + ")";
    }
}

In diesem Beispiel wird das Comparator-Interface verwendet, um die Liste books zu sortieren. Aber warum wurde die Methode comparing() anstelle von compare() verwendet?

Wenn die Methode compare() verwendet werden soll, muss ein Comparator-Objekt erstellt und die compare-Methode implementiert werden.

public static Comparator<Book> titleComparator = new Comparator<Book>() {
    @Override
    public int compare(Book b1, Book b2) {
        return b1.getTitle().compareTo(b2.getTitle());
    }
};

Dieser Code definiert einen Comparator<Book> mithilfe einer anonymen Klasse, um zwei Book-Objekte anhand ihres title zu vergleichen.

Da String das Interface Comparable implementiert, wird die Methode compareTo() verwendet, um die Titel lexikografisch zu vergleichen. Sie gibt einen negativen, null oder positiven Wert zurück.

Alternativ kann dasselbe Ergebnis mit einem Lambda-Ausdruck für eine kürzere Implementierung erzielt werden:

(b1, b2) -> b1.getTitle().compareTo(b2.getTitle());

Es gibt jedoch einen noch einfacheren Ansatz: die Verwendung der Methode Comparator.comparing(). Diese Methode übernimmt die Vergleichslogik automatisch für Sie und macht den Code dadurch lesbarer und kürzer.

Sie übergeben einfach eine Methodenreferenz, die das zu vergleichende Feld extrahiert.

Comparator.comparing(Book::getTitle)

Die Methode sort() der Liste ruft den übergebenen Comparator auf, der wiederum die Reihenfolge der Elemente bestimmt, indem er sie anhand der von den angegebenen Methoden zurückgegebenen Werte vergleicht.

Mehrfaches Sortieren

Um nach mehreren Kriterien zu sortieren, kann die Methode thenComparing verwendet werden:

books.sort(
       Comparator.comparing(Book::getYear) // First by year
           .thenComparing(Book::getTitle) // Then by title
);

Dieses Beispiel zeigt, wie eine Liste von Büchern zuerst nach ihrem Veröffentlichungs-year und anschließend nach dem title sortiert wird. Beim Sortiervorgang werden die Bücher zunächst anhand ihres year verglichen. Haben zwei Bücher das gleiche year, erfolgt die Sortierung anhand des title, um die endgültige Reihenfolge festzulegen.

Umgekehrtes Sortieren

Das Umkehren der Sortierreihenfolge in Java ist nützlich, wenn Elemente zunächst nach einem Kriterium und anschließend in umgekehrter Reihenfolge nach einem weiteren Kriterium sortiert werden sollen.

Die Methoden reversed() und Comparator.reverseOrder() steuern die Sortierrichtung, funktionieren jedoch unterschiedlich.

books.sort(
    Comparator.comparing(Book::getYear).reversed() // Sort by year (descending)
        .thenComparing(Book::getTitle, Comparator.reverseOrder()) // Then by title (descending)
);

Die Bücher werden zunächst nach ihrem Veröffentlichungsjahr in absteigender Reihenfolge mit reversed() sortiert. Wenn mehrere Bücher das gleiche year haben, sortiert thenComparing() sie anhand des title in umgekehrter alphabetischer Reihenfolge mit Comparator.reverseOrder().

Dies stellt sicher, dass die neuesten Bücher zuerst erscheinen und innerhalb desselben Jahres die Titel von Z bis A angeordnet werden.

Unterschiede zwischen Comparable und Comparator

Das Comparable-Interface wird verwendet, wenn eine Klasse eine natürliche Ordnung besitzt, beispielsweise die Sortierung nach einem einzelnen Feld. Comparator wird verwendet, wenn nach mehreren Kriterien sortiert werden soll oder wenn eine benutzerdefinierte Reihenfolge für Objekte festgelegt werden muss.