compareTo() et Comparable

Fait partie de la section Programmation Orientée Objet du Journey Java de Coddy — leçon 44 sur 87.

L'interface Comparable permet aux objets de définir leur ordre naturel. En implémentant cette interface, votre classe peut être triée automatiquement en utilisant des méthodes comme Collections.sort() ou stockée dans des collections triées comme TreeSet.

L'interface vous oblige à implémenter une seule méthode : compareTo(). Cette méthode compare l'objet actuel avec un autre objet et renvoie un entier indiquant leur ordre relatif :

Valeur négative : cet objet vient avant l'autre
Zéro : les deux objets sont égaux
Valeur positive : cet objet vient après l'autre

public class Person implements Comparable<Person> {
    private String name;
    private int age;
    
    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }
    
    @Override
    public int compareTo(Person other) {
        return this.age - other.age;  // Trier par âge croissant
    }
}

Une fois implémenté, le tri devient simple :

List<Person> people = new ArrayList<>();
people.add(new Person("Alice", 30));
people.add(new Person("Bob", 25));
Collections.sort(people);  // Maintenant trié par âge : Bob, Alice

Pour comparer des chaînes de caractères ou d'autres champs Comparable, vous pouvez déléguer à leur méthode compareTo() au lieu d'utiliser la soustraction : return this.name.compareTo(other.name);. Cette approche est plus sûre et gère correctement les cas particuliers.

Défi

Facile

Construisons un système de classement de films qui utilise l'interface Comparable pour trier les films selon leurs notes. Vous allez créer une classe Movie qui sait comment se comparer à d'autres films, permettant un tri automatique de la note la plus élevée à la plus basse.

Vous organiserez votre code sur deux fichiers :

Movie.java : Créez une classe représentant un film qui peut être comparé à d'autres films. Un Movie possède trois champs privés : title (String), director (String), et rating (double, de 0.0 à 10.0). Incluez un constructeur pour initialiser tous les champs et des méthodes getter pour chacun.
Faites en sorte que votre classe Movie implémente Comparable<Movie> et remplacez la méthode compareTo(). Les films doivent être triés par note par ordre décroissant (le mieux noté en premier). Lors de la comparaison de doubles, utilisez Double.compare() pour une comparaison sécurisée — n'oubliez pas d'inverser l'ordre pour un tri décroissant !

Remplacez toString() pour retourner : [title] by [director] - Rating: [rating]
Main.java : Donnez vie à votre classe Movie en créant une liste de films et en les triant. Vous recevrez en entrée trois films, chacun sur une ligne séparée au format : title,director,rating
Analysez chaque ligne pour créer des objets Movie, ajoutez-les à une ArrayList, puis utilisez Collections.sort() pour trier la liste. Grâce à votre implémentation de Comparable, les films s'organiseront automatiquement par note !

Après le tri, affichez chaque film sur sa propre ligne en utilisant le format toString(). Le film le mieux noté doit apparaître en premier.

Vous recevrez trois lignes d'entrée, chacune contenant des données de film au format : title,director,rating

Par exemple, une ligne d'entrée pourrait ressembler à : Inception,Christopher Nolan,8.8

N'oubliez pas d'importer java.util.ArrayList, java.util.Collections, et java.util.Scanner dans votre fichier Main. Remarquez comment l'implémentation de Comparable vous permet de trier vos objets personnalisés avec un seul appel de méthode — aucun comparateur supplémentaire n'est nécessaire !

Aide-mémoire

L'interface Comparable permet aux objets de définir leur ordre naturel pour un tri automatique.

Implémentez la méthode compareTo() qui renvoie :

Une valeur négative : cet objet vient avant l'autre
Zéro : les deux objets sont égaux
Une valeur positive : cet objet vient après l'autre

public class Person implements Comparable<Person> {
    private int age;
    
    @Override
    public int compareTo(Person other) {
        return this.age - other.age;  // Trier par âge croissant
    }
}

Triez les objets en utilisant Collections.sort() :

List<Person> people = new ArrayList<>();
people.add(new Person("Alice", 30));
people.add(new Person("Bob", 25));
Collections.sort(people);  // Trié par âge

Pour comparer des chaînes de caractères, déléguez à leur méthode compareTo() :

return this.name.compareTo(other.name);

Pour comparer des doubles en toute sécurité, utilisez Double.compare() :

return Double.compare(this.rating, other.rating);  // Croissant
return Double.compare(other.rating, this.rating);  // Décroissant

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 lignes de données de films
        String line1 = scanner.nextLine();
        String line2 = scanner.nextLine();
        String line3 = scanner.nextLine();
        
        // TODO: Créer une ArrayList pour stocker des objets Movie
        
        // TODO: Analyser chaque ligne (format : title,director,rating)
        // Hint: Utiliser split(",") pour séparer les parties
        // Hint: Utiliser Double.parseDouble() pour le rating
        
        // TODO: Créer des objets Movie et les ajouter à la liste
        
        // TODO: Trier la liste en utilisant Collections.sort()
        
        // TODO: Afficher chaque film (un par ligne)
    }
}