Interface Comparator

Fait partie de la section Programmation Orientée Objet du Journey Java de Coddy. Leçon 45 sur 87.

Alors que Comparable définit l’ordre naturel d’une classe, vous devez parfois trier les objets de différentes manières. L’interface Comparator vous permet de créer une logique de comparaison distincte sans modifier la classe d’origine.

Un Comparator est un objet externe qui compare deux objets du même type. C’est utile lorsque vous souhaitez disposer de plusieurs options de tri ou lorsque vous ne pouvez pas modifier la classe elle-même :

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

Vous pouvez ensuite transmettre le comparateur aux méthodes de tri :

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

Collections.sort(people, new NameComparator());  // Trié par nom
Collections.sort(people, new AgeComparator());   // Trié par âge

Pour un code concis, vous pouvez utiliser des expressions lambda puisque Comparator est une interface fonctionnelle :

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

La différence essentielle : Comparable est implémentée par la classe comparée et définit un ordre naturel, tandis que Comparator est une classe distincte qui peut définir un nombre illimité d’ordres personnalisés.

Défi

Facile

Construisons un système de tri des employés qui démontre la puissance de l'interface Comparator. Vous allez créer plusieurs comparateurs pour trier les employés de différentes manières, par salaire et par nom, sans modifier la classe Employee elle-même.

Vous allez organiser votre code dans quatre fichiers :

Employee.java : créez une classe représentant un employé avec trois champs privés : name (String), department (String) et salary (double). Ajoutez un constructeur pour initialiser tous les champs ainsi que des méthodes getter pour chacun d'eux. Redéfinissez toString() afin qu'elle renvoie : [name] ([department]) - $[salary]
SalaryComparator.java : créez un comparateur qui trie les employés par salaire dans l'ordre décroissant (les mieux rémunérés en premier). Implémentez l'interface Comparator<Employee> et sa méthode compare(). Utilisez Double.compare() pour comparer les valeurs de salaire de manière sûre.
NameComparator.java : créez un autre comparateur qui trie les employés par nom, dans l'ordre croissant (de A à Z). Implémentez Comparator<Employee> et utilisez la méthode compareTo() de String pour la comparaison.
Main.java : rassemblez tout en créant une liste d'employés et en les triant à l'aide de vos comparateurs. Vous recevrez les données de trois employés, chacune sur une ligne distincte, au format : name,department,salary
Créez un ArrayList d'employés, puis présentez les deux approches de tri :
1. Commencez par trier par salaire à l'aide de votre SalaryComparator et affichez chaque employé
2. Affichez une ligne vide
3. Triez ensuite par nom à l'aide de votre NameComparator et affichez chaque employé

Vous recevrez trois lignes d'entrée, chacune contenant les données d'un employé au format : name,department,salary

Par exemple, une ligne d'entrée peut ressembler à ceci : Alice,Engineering,75000.0

N'oubliez pas d'importer java.util.Comparator dans vos fichiers de comparateurs, ainsi que java.util.ArrayList, java.util.Collections et java.util.Scanner dans votre fichier Main. Remarquez comment les comparateurs vous permettent de définir plusieurs stratégies de tri de manière externe : la classe Employee n'a pas besoin de savoir comment elle pourrait être triée !

Essayez vous-même

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);
        
        // Lire trois employés depuis l'entrée
        // Format de chaque ligne : name,department,salary
        String line1 = scanner.nextLine();
        String line2 = scanner.nextLine();
        String line3 = scanner.nextLine();
        
        // TODO: Analyser chaque ligne et créer des objets Employee
        // Hint: Utilisez split(",") pour séparer les valeurs
        
        // TODO: Créer une ArrayList d'employés et ajouter les trois
        
        // TODO: Trier par salaire en utilisant SalaryComparator et afficher chaque employé
        // Hint: Utilisez Collections.sort(list, comparator)
        
        // TODO: Afficher une ligne vide
        
        // TODO: Trier par nom en utilisant NameComparator et afficher chaque employé
    }
}