Comparator-Interface

Teil des Abschnitts Objektorientierte Programmierung der Java-Journey von Coddy — Lektion 45 von 87.

Während Comparable die natürliche Ordnung einer Klasse definiert, müssen Sie Objekte manchmal auf unterschiedliche Weise sortieren. Das Comparator Interface ermöglicht es Ihnen, separate Vergleichslogik zu erstellen, ohne die ursprüngliche Klasse zu ändern.

Ein Comparator ist ein externes Objekt, das zwei Objekte desselben Typs vergleicht. Dies ist nützlich, wenn Sie mehrere Sortieroptionen wünschen oder wenn Sie die Klasse selbst nicht ändern können:

import java.util.Comparator;

class NameComparator implements Comparator<Person> {
    @Override
    public int compare(Person p1, Person p2) {
        return p1.getName().compareTo(p2.getName());
    }
}

class AgeComparator implements Comparator<Person> {
    @Override
    public int compare(Person p1, Person p2) {
        return p1.getAge() - p2.getAge();
    }
}

Sie können den Comparator dann an Sortiermethoden übergeben:

List<Person> people = new ArrayList<>();
people.add(new Person("Charlie", 30));
people.add(new Person("Alice", 25));

Collections.sort(people, new NameComparator());  // Nach Name sortiert
Collections.sort(people, new AgeComparator());   // Nach Alter sortiert

Für prägnanten Code können Sie Lambda-Ausdrücke verwenden, da Comparator ein funktionales Interface ist:

Collections.sort(people, (p1, p2) -> p1.getName().compareTo(p2.getName()));

Der entscheidende Unterschied: Comparable wird von der Klasse implementiert, die verglichen wird, und definiert eine natürliche Ordnung, während Comparator eine separate Klasse ist, die unbegrenzte benutzerdefinierte Sortierungen definieren kann.

Aufgabe

Einfach

Lassen Sie uns ein Mitarbeiter-Sortiersystem erstellen, das die Leistungsfähigkeit des Comparator-Interfaces demonstriert. Sie werden mehrere Comparatoren erstellen, um Mitarbeiter auf verschiedene Arten zu sortieren – nach Gehalt und nach Name – ohne die Klasse Employee selbst zu verändern.

Sie werden Ihren Code über vier Dateien organisieren:

Employee.java: Erstellen Sie eine Klasse, die einen Mitarbeiter mit drei privaten Feldern darstellt: name (String), department (String) und salary (double). Fügen Sie einen Konstruktor zur Initialisierung aller Felder und Getter-Methoden für jedes Feld hinzu. Überschreiben Sie toString(), um Folgendes zurückzugeben: [name] ([department]) - $[salary]
SalaryComparator.java: Erstellen Sie einen Comparator, der Mitarbeiter nach Gehalt in absteigender Reihenfolge sortiert (höchstbezahlte zuerst). Implementieren Sie das Comparator<Employee>-Interface und dessen compare()-Methode. Verwenden Sie Double.compare() für den sicheren Vergleich von Gehaltswerten.
NameComparator.java: Erstellen Sie einen weiteren Comparator, der Mitarbeiter alphabetisch nach Namen in aufsteigender Reihenfolge (A bis Z) sortiert. Implementieren Sie Comparator<Employee> und verwenden Sie die compareTo()-Methode von String für den Vergleich.
Main.java: Führen Sie alles zusammen, indem Sie eine Liste von Mitarbeitern erstellen und diese mit Ihren Comparatoren sortieren. Sie erhalten Eingaben für drei Mitarbeiter, jeweils in einer separaten Zeile im Format: name,department,salary
Erstellen Sie eine ArrayList von Mitarbeitern und demonstrieren Sie dann beide Sortieransätze:
1. Sortieren Sie zuerst nach Gehalt unter Verwendung Ihres SalaryComparator und geben Sie jeden Mitarbeiter aus
2. Geben Sie eine Leerzeile aus
3. Sortieren Sie dann nach Namen unter Verwendung Ihres NameComparator und geben Sie jeden Mitarbeiter aus

Sie erhalten drei Eingabezeilen, die jeweils Mitarbeiterdaten im Format name,department,salary enthalten.

Zum Beispiel könnte eine Eingabezeile so aussehen: Alice,Engineering,75000.0

Denken Sie daran, java.util.Comparator in Ihren Comparator-Dateien sowie java.util.ArrayList, java.util.Collections und java.util.Scanner in Ihrer Main-Datei zu importieren. Beachten Sie, wie Comparatoren es Ihnen ermöglichen, mehrere Sortierstrategien extern zu definieren – die Klasse Employee muss nichts darüber wissen, wie sie sortiert werden könnte!

Spickzettel

Das Comparator-Interface ermöglicht es Ihnen, externe Vergleichslogik zum Sortieren von Objekten zu erstellen, ohne die ursprüngliche Klasse zu ändern. Dies ist nützlich, wenn Sie mehrere Sortieroptionen benötigen.

Ein Comparator vergleicht zwei Objekte desselben Typs durch Implementierung der compare()-Methode:

import java.util.Comparator;

class NameComparator implements Comparator<Person> {
    @Override
    public int compare(Person p1, Person p2) {
        return p1.getName().compareTo(p2.getName());
    }
}

Übergeben Sie den Comparator an Sortiermethoden:

Collections.sort(people, new NameComparator());

Sie können Lambda-Ausdrücke für prägnanten Code verwenden, da Comparator ein funktionales Interface ist:

Collections.sort(people, (p1, p2) -> p1.getName().compareTo(p2.getName()));

Verwenden Sie zum Vergleichen numerischer Werte Wrapper-Klassenmethoden wie Double.compare() für einen sicheren Vergleich:

class AgeComparator implements Comparator<Person> {
    @Override
    public int compare(Person p1, Person p2) {
        return p1.getAge() - p2.getAge();
    }
}

Hauptunterschied: Comparable definiert eine natürliche Ordnung innerhalb der Klasse selbst, während Comparator eine separate Klasse ist, die unbegrenzt viele benutzerdefinierte Sortierungen extern definieren kann.

Probier es selbst

import java.util.ArrayList;
import java.util.Collections;
import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Drei Mitarbeiter aus der Eingabe lesen
        // Format jeder Zeile: Name,Abteilung,Gehalt
        String line1 = scanner.nextLine();
        String line2 = scanner.nextLine();
        String line3 = scanner.nextLine();
        
        // TODO: Jede Zeile parsen und Employee-Objekte erstellen
        // Hinweis: Verwenden Sie split(","), um die Werte zu trennen
        
        // TODO: Erstellen Sie eine ArrayList von Mitarbeitern und fügen Sie alle drei hinzu
        
        // TODO: Nach Gehalt sortieren mit SalaryComparator und jeden Mitarbeiter ausgeben
        // Hinweis: Verwenden Sie Collections.sort(list, comparator)
        
        // TODO: Eine Leerzeile ausgeben
        
        // TODO: Nach Name sortieren mit NameComparator und jeden Mitarbeiter ausgeben
    }
}