Comparator et Comparable

Introduction

Dans les applications Java, nous avons souvent besoin de comparer et de trier des objets. Pour les types de données primitifs tels que les entiers ou les chaînes de caractères, Java sait déjà comment les comparer. Cependant, pour les objets personnalisés, nous devons indiquer à Java comment ils doivent être comparés et ordonnés.

Java fournit deux interfaces pour nous aider dans ce domaine :

• L'interface Comparable permet à une classe de définir son ordre naturel
• L'interface Comparator fournit une logique de comparaison externe qui peut être utilisée pour différents critères de tri

Dans ce lab (atelier), vous apprendrez à implémenter ces deux interfaces et à les utiliser pour trier des collections d'objets de diverses manières.

Skills Graph

Comprendre l'interface Comparable

L'interface Comparable est utilisée lorsqu'une classe a un ordre naturel. Par exemple, les chaînes de caractères sont naturellement ordonnées de manière alphabétique, et les entiers sont naturellement ordonnés de manière numérique.

Lorsqu'une classe implémente l'interface Comparable, elle doit définir une méthode compareTo() qui spécifie comment les instances de la classe doivent être ordonnées.

Créer une classe Étudiant de base

Créons une simple classe Student pour démontrer comment utiliser l'interface Comparable. Nous allons définir un étudiant avec un nom, un moyenne générale (GPA) et un numéro d'inscription.

1. Ouvrez le WebIDE et créez un nouveau fichier nommé Student.java dans le répertoire ~/project avec le code suivant :

public class Student implements Comparable<Student> {
    private String name;
    private double gpa;
    private int regNo;

    public Student(String name, double gpa, int regNo) {
        this.name = name;
        this.gpa = gpa;
        this.regNo = regNo;
    }

    // Implémentation de la méthode compareTo de l'interface Comparable
    @Override
    public int compareTo(Student other) {
        // Comparaison des étudiants en fonction de leur moyenne générale (GPA)
        if (this.gpa < other.gpa) {
            return -1;
        } else if (this.gpa > other.gpa) {
            return 1;
        } else {
            return 0;
        }
    }

    // Getters
    public String getName() {
        return name;
    }

    public double getGpa() {
        return gpa;
    }

    public int getRegNo() {
        return regNo;
    }

    @Override
    public String toString() {
        return name + ", GPA: " + gpa + ", Reg No: " + regNo;
    }
}

Comprenons ce code :

• La classe Student implémente l'interface Comparable<Student>
• La méthode compareTo() compare les étudiants en fonction de leur moyenne générale (GPA)
• Si la moyenne générale (GPA) de l'étudiant actuel est inférieure à celle de l'autre étudiant, nous retournons -1
• Si la moyenne générale (GPA) de l'étudiant actuel est supérieure à celle de l'autre étudiant, nous retournons 1
• Si les moyennes générales (GPA) sont égales, nous retournons 0

Maintenant, créons un simple programme de test pour voir comment nous pouvons utiliser l'interface Comparable pour trier les étudiants.

2. Créez un nouveau fichier nommé ComparableDemo.java dans le répertoire ~/project avec le code suivant :

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class ComparableDemo {
    public static void main(String[] args) {
        // Création d'une liste d'étudiants
        List<Student> students = new ArrayList<>();
        students.add(new Student("John", 3.5, 101));
        students.add(new Student("Mary", 3.8, 102));
        students.add(new Student("Alice", 3.2, 103));
        students.add(new Student("Bob", 3.9, 104));

        // Affichage de la liste non triée
        System.out.println("Liste d'étudiants non triée :");
        for (Student student : students) {
            System.out.println(student);
        }

        // Tri de la liste en utilisant l'ordre naturel (défini par la méthode compareTo)
        Collections.sort(students);

        // Affichage de la liste triée
        System.out.println("\nÉtudiants triés par moyenne générale (GPA) (en utilisant Comparable) :");
        for (Student student : students) {
            System.out.println(student);
        }
    }
}

Ce programme :

1. Crée une liste d'objets Student

2. Affiche la liste non triée

3. Trie la liste en utilisant Collections.sort() qui utilise l'ordre naturel défini par la méthode compareTo()

4. Affiche la liste triée

5. Maintenant, compilons et exécutons notre code pour voir le résultat :

cd ~/project
javac Student.java ComparableDemo.java
java ComparableDemo

Vous devriez voir un résultat similaire à :

Liste d'étudiants non triée :
John, GPA: 3.5, Reg No: 101
Mary, GPA: 3.8, Reg No: 102
Alice, GPA: 3.2, Reg No: 103
Bob, GPA: 3.9, Reg No: 104

Étudiants triés par moyenne générale (GPA) (en utilisant Comparable) :
Alice, GPA: 3.2, Reg No: 103
John, GPA: 3.5, Reg No: 101
Mary, GPA: 3.8, Reg No: 102
Bob, GPA: 3.9, Reg No: 104

Comme vous pouvez le voir, les étudiants sont maintenant triés par leur moyenne générale (GPA) dans l'ordre croissant. C'est l'ordre naturel que nous avons défini dans la méthode compareTo().

Création et utilisation de comparateurs

Alors que l'interface Comparable définit un ordre naturel pour une classe, il arrive parfois que nous ayons besoin de trier des objets en fonction de critères différents. C'est là que l'interface Comparator entre en jeu.

L'interface Comparator nous permet de définir une logique d'ordre personnalisée qui est séparée de la classe comparée. Cela signifie que nous pouvons avoir plusieurs façons de trier la même classe d'objets.

Création d'un comparateur pour le tri par nom

Créons un Comparator qui trie les étudiants par leur nom de manière alphabétique :

1. Créez un nouveau fichier nommé StudentNameComparator.java dans le répertoire ~/project avec le code suivant :

import java.util.Comparator;

public class StudentNameComparator implements Comparator<Student> {
    @Override
    public int compare(Student s1, Student s2) {
        // Compare students based on their names
        return s1.getName().compareTo(s2.getName());
    }
}

Ce Comparator :

• Implémente l'interface Comparator<Student>
• Définit une méthode compare() qui prend deux objets Student
• Compare les étudiants en fonction de leur nom en utilisant la méthode compareTo() de la classe String

2. Maintenant, créons un programme pour démontrer comment utiliser ce Comparator. Créez un fichier nommé ComparatorDemo.java dans le répertoire ~/project :

import java.util.ArrayList;
import java.util.Collections;
import java.util.List;

public class ComparatorDemo {
    public static void main(String[] args) {
        // Create a list of students
        List<Student> students = new ArrayList<>();
        students.add(new Student("John", 3.5, 101));
        students.add(new Student("Mary", 3.8, 102));
        students.add(new Student("Alice", 3.2, 103));
        students.add(new Student("Bob", 3.9, 104));

        // Print the unsorted list
        System.out.println("Unsorted Student List:");
        for (Student student : students) {
            System.out.println(student);
        }

        // Sort by name using the StudentNameComparator
        Collections.sort(students, new StudentNameComparator());

        // Print the list sorted by name
        System.out.println("\nStudents sorted by name (using Comparator):");
        for (Student student : students) {
            System.out.println(student);
        }
    }
}

Ce programme :

1. Crée une liste d'objets Student

2. Affiche la liste non triée

3. Trie la liste en utilisant Collections.sort() avec notre StudentNameComparator personnalisé

4. Affiche la liste triée

5. Compilons et exécutons notre code :

cd ~/project
javac Student.java StudentNameComparator.java ComparatorDemo.java
java ComparatorDemo

Vous devriez voir un résultat similaire à :

Unsorted Student List:
John, GPA: 3.5, Reg No: 101
Mary, GPA: 3.8, Reg No: 102
Alice, GPA: 3.2, Reg No: 103
Bob, GPA: 3.9, Reg No: 104

Students sorted by name (using Comparator):
Alice, GPA: 3.2, Reg No: 103
Bob, GPA: 3.9, Reg No: 104
John, GPA: 3.5, Reg No: 101
Mary, GPA: 3.8, Reg No: 102

Comme vous pouvez le voir, les étudiants sont maintenant triés par ordre alphabétique de leur nom, plutôt que par leur moyenne générale (GPA).

Utilisation d'expressions lambda pour les comparateurs

Java 8 a introduit les expressions lambda, qui peuvent simplifier la création de comparateurs. Au lieu de créer une classe séparée, nous pouvons définir la logique de comparaison directement.

4. Créez un nouveau fichier nommé LambdaComparatorDemo.java dans le répertoire ~/project :

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

public class LambdaComparatorDemo {
    public static void main(String[] args) {
        // Create a list of students
        List<Student> students = new ArrayList<>();
        students.add(new Student("John", 3.5, 101));
        students.add(new Student("Mary", 3.8, 102));
        students.add(new Student("Alice", 3.2, 103));
        students.add(new Student("Bob", 3.9, 104));

        // Sort by registration number using lambda expression
        Collections.sort(students, (s1, s2) -> s1.getRegNo() - s2.getRegNo());

        // Print the list sorted by registration number
        System.out.println("Students sorted by registration number (using lambda):");
        for (Student student : students) {
            System.out.println(student);
        }

        // Sort by name using method reference
        Collections.sort(students, Comparator.comparing(Student::getName));

        // Print the list sorted by name
        System.out.println("\nStudents sorted by name (using method reference):");
        for (Student student : students) {
            System.out.println(student);
        }
    }
}

Ce programme démontre :

1. L'utilisation d'une expression lambda pour créer un comparateur qui trie les étudiants par numéro d'inscription

2. L'utilisation de la méthode Comparator.comparing() avec une référence de méthode pour créer un comparateur qui trie les étudiants par nom

3. Compilez et exécutez ce code :

cd ~/project
javac Student.java LambdaComparatorDemo.java
java LambdaComparatorDemo

Vous devriez voir un résultat similaire à :

Students sorted by registration number (using lambda):
John, GPA: 3.5, Reg No: 101
Mary, GPA: 3.8, Reg No: 102
Alice, GPA: 3.2, Reg No: 103
Bob, GPA: 3.9, Reg No: 104

Students sorted by name (using method reference):
Alice, GPA: 3.2, Reg No: 103
Bob, GPA: 3.9, Reg No: 104
John, GPA: 3.5, Reg No: 101
Mary, GPA: 3.8, Reg No: 102

Les étudiants sont d'abord triés par numéro d'inscription, puis par nom.

Techniques de tri avancées

Dans les applications du monde réel, nous avons souvent besoin d'une logique de tri plus complexe, comme :

• Trier par plusieurs critères (par exemple, trier par moyenne générale (GPA), et si les GPA sont égaux, trier par nom)
• Trier dans l'ordre inverse
• Créer des chaînes de comparateurs personnalisés

Explorons ces techniques avancées.

Tri par plusieurs critères

1. Créez un nouveau fichier nommé MultiCriteriaDemo.java dans le répertoire ~/project :

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

public class MultiCriteriaDemo {
    public static void main(String[] args) {
        // Create a list of students with some having the same GPA
        List<Student> students = new ArrayList<>();
        students.add(new Student("John", 3.5, 101));
        students.add(new Student("Mary", 3.8, 102));
        students.add(new Student("Alice", 3.5, 103)); // Same GPA as John
        students.add(new Student("Bob", 3.8, 104));   // Same GPA as Mary
        students.add(new Student("Charlie", 3.2, 105));

        // Print the unsorted list
        System.out.println("Unsorted Student List:");
        for (Student student : students) {
            System.out.println(student);
        }

        // Sort first by GPA, then by name
        Comparator<Student> byGpa = Comparator.comparing(Student::getGpa);
        Comparator<Student> byName = Comparator.comparing(Student::getName);

        // Combine the comparators using thenComparing
        Comparator<Student> byGpaThenName = byGpa.thenComparing(byName);

        // Sort the list
        Collections.sort(students, byGpaThenName);

        // Print the sorted list
        System.out.println("\nStudents sorted by GPA, then by name:");
        for (Student student : students) {
            System.out.println(student);
        }
    }
}

Ce programme :

1. Crée une liste d'étudiants, certains ayant le même GPA

2. Crée un comparateur pour le GPA et un comparateur pour le nom

3. Combine ces comparateurs en utilisant la méthode thenComparing()

4. Trie les étudiants d'abord par GPA, puis par nom si les GPA sont égaux

5. Compilez et exécutez le code :

cd ~/project
javac Student.java MultiCriteriaDemo.java
java MultiCriteriaDemo

Vous devriez voir un résultat similaire à :

Unsorted Student List:
John, GPA: 3.5, Reg No: 101
Mary, GPA: 3.8, Reg No: 102
Alice, GPA: 3.5, Reg No: 103
Bob, GPA: 3.8, Reg No: 104
Charlie, GPA: 3.2, Reg No: 105

Students sorted by GPA, then by name:
Charlie, GPA: 3.2, Reg No: 105
Alice, GPA: 3.5, Reg No: 103
John, GPA: 3.5, Reg No: 101
Bob, GPA: 3.8, Reg No: 104
Mary, GPA: 3.8, Reg No: 102

Notez que les étudiants ayant le même GPA (Alice et John avec 3,5, Bob et Mary avec 3,8) sont triés par ordre alphabétique.

Tri dans l'ordre inverse

3. Créez un nouveau fichier nommé ReverseOrderDemo.java dans le répertoire ~/project :

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

public class ReverseOrderDemo {
    public static void main(String[] args) {
        // Create a list of students
        List<Student> students = new ArrayList<>();
        students.add(new Student("John", 3.5, 101));
        students.add(new Student("Mary", 3.8, 102));
        students.add(new Student("Alice", 3.2, 103));
        students.add(new Student("Bob", 3.9, 104));
        students.add(new Student("Charlie", 3.0, 105));

        // Print the unsorted list
        System.out.println("Unsorted Student List:");
        for (Student student : students) {
            System.out.println(student);
        }

        // Method 1: Using Collections.reverseOrder() with a comparator
        Comparator<Student> byGpa = Comparator.comparing(Student::getGpa);
        Comparator<Student> byGpaReversed = Collections.reverseOrder(byGpa);

        Collections.sort(students, byGpaReversed);

        System.out.println("\nStudents sorted by GPA in descending order (Method 1):");
        for (Student student : students) {
            System.out.println(student);
        }

        // Method 2: Using the reversed() method of Comparator
        Collections.sort(students, Comparator.comparing(Student::getName).reversed());

        System.out.println("\nStudents sorted by name in reverse alphabetical order (Method 2):");
        for (Student student : students) {
            System.out.println(student);
        }
    }
}

Ce programme démontre deux façons de trier dans l'ordre inverse :

1. Utiliser Collections.reverseOrder() pour inverser un comparateur

2. Utiliser la méthode reversed() d'un comparateur

3. Compilez et exécutez le code :

cd ~/project
javac Student.java ReverseOrderDemo.java
java ReverseOrderDemo

Vous devriez voir un résultat similaire à :

Unsorted Student List:
John, GPA: 3.5, Reg No: 101
Mary, GPA: 3.8, Reg No: 102
Alice, GPA: 3.2, Reg No: 103
Bob, GPA: 3.9, Reg No: 104
Charlie, GPA: 3.0, Reg No: 105

Students sorted by GPA in descending order (Method 1):
Bob, GPA: 3.9, Reg No: 104
Mary, GPA: 3.8, Reg No: 102
John, GPA: 3.5, Reg No: 101
Alice, GPA: 3.2, Reg No: 103
Charlie, GPA: 3.0, Reg No: 105

Students sorted by name in reverse alphabetical order (Method 2):
Mary, GPA: 3.8, Reg No: 102
John, GPA: 3.5, Reg No: 101
Charlie, GPA: 3.0, Reg No: 105
Bob, GPA: 3.9, Reg No: 104
Alice, GPA: 3.2, Reg No: 103

Le premier tri affiche les étudiants dans l'ordre décroissant de leur GPA, et le deuxième tri affiche les étudiants dans l'ordre alphabétique inverse de leur nom.

Chaîne de tri complexe

5. Créons un autre exemple qui combine plusieurs critères et un tri inverse. Créez un fichier nommé ComplexSortingDemo.java dans le répertoire ~/project :

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

public class ComplexSortingDemo {
    public static void main(String[] args) {
        // Create a list of students with varied data
        List<Student> students = new ArrayList<>();
        students.add(new Student("John", 3.5, 101));
        students.add(new Student("Mary", 3.8, 102));
        students.add(new Student("Alice", 3.5, 103)); // Same GPA as John
        students.add(new Student("Bob", 3.8, 104));   // Same GPA as Mary
        students.add(new Student("Charlie", 3.2, 105));
        students.add(new Student("David", 3.2, 106)); // Same GPA as Charlie

        // Print the unsorted list
        System.out.println("Unsorted Student List:");
        for (Student student : students) {
            System.out.println(student);
        }

        // Create a complex sorting chain:
        // 1. Sort by GPA in descending order
        // 2. If GPAs are equal, sort by name in ascending order
        // 3. If names are also equal, sort by registration number in descending order
        Comparator<Student> complexComparator = Comparator
            .comparing(Student::getGpa, Comparator.reverseOrder())
            .thenComparing(Student::getName)
            .thenComparing(Student::getRegNo, Comparator.reverseOrder());

        Collections.sort(students, complexComparator);

        System.out.println("\nStudents sorted by complex criteria:");
        System.out.println("(GPA descending, then name ascending, then reg. number descending)");
        for (Student student : students) {
            System.out.println(student);
        }
    }
}

Ce programme crée une chaîne de tri complexe qui :

1. Trie d'abord les étudiants par GPA dans l'ordre décroissant

2. Si les GPA sont égaux, trie par nom dans l'ordre croissant

3. Si le GPA et le nom sont également égaux, trie par numéro d'inscription dans l'ordre décroissant

4. Compilez et exécutez le code :

cd ~/project
javac Student.java ComplexSortingDemo.java
java ComplexSortingDemo

Vous devriez voir un résultat similaire à :

Unsorted Student List:
John, GPA: 3.5, Reg No: 101
Mary, GPA: 3.8, Reg No: 102
Alice, GPA: 3.5, Reg No: 103
Bob, GPA: 3.8, Reg No: 104
Charlie, GPA: 3.2, Reg No: 105
David, GPA: 3.2, Reg No: 106

Students sorted by complex criteria:
(GPA descending, then name ascending, then reg. number descending)
Bob, GPA: 3.8, Reg No: 104
Mary, GPA: 3.8, Reg No: 102
Alice, GPA: 3.5, Reg No: 103
John, GPA: 3.5, Reg No: 101
Charlie, GPA: 3.2, Reg No: 105
David, GPA: 3.2, Reg No: 106

Dans ce résultat :

• Bob et Mary ont tous deux un GPA de 3,8, mais Bob vient en premier par ordre alphabétique
• Alice et John ont tous deux un GPA de 3,5, mais Alice vient en premier par ordre alphabétique
• Charlie et David ont tous deux un GPA de 3,2, et Charlie vient en premier par ordre alphabétique

Cela démontre comment vous pouvez créer une logique de tri complexe et multi-niveaux en enchaînant des comparateurs.

Construction d'une application de tri complète

Maintenant que nous avons appris à propos de l'interface Comparable, de l'interface Comparator et de diverses techniques de tri, mettons tout ensemble dans une application complète.

Nous allons créer un système de gestion d'étudiants qui permet de trier les étudiants de différentes manières.

1. Tout d'abord, créons une version mise à jour de notre classe Student. Cette version implémentera Comparable et inclura une méthode toString() améliorée pour un meilleur affichage. Créez un fichier nommé StudentManager.java dans le répertoire ~/project :

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

class Student implements Comparable<Student> {
    private String name;
    private double gpa;
    private int regNo;
    private String major;

    public Student(String name, double gpa, int regNo, String major) {
        this.name = name;
        this.gpa = gpa;
        this.regNo = regNo;
        this.major = major;
    }

    @Override
    public int compareTo(Student other) {
        // Default natural ordering by registration number
        return this.regNo - other.regNo;
    }

    // Getters
    public String getName() {
        return name;
    }

    public double getGpa() {
        return gpa;
    }

    public int getRegNo() {
        return regNo;
    }

    public String getMajor() {
        return major;
    }

    @Override
    public String toString() {
        return String.format("%-10s | GPA: %.1f | Reg No: %-5d | Major: %-10s",
                            name, gpa, regNo, major);
    }
}

public class StudentManager {
    private List<Student> students;

    public StudentManager() {
        students = new ArrayList<>();
        // Add some sample students
        students.add(new Student("John", 3.5, 101, "Computer Science"));
        students.add(new Student("Mary", 3.8, 102, "Physics"));
        students.add(new Student("Alice", 3.5, 103, "Mathematics"));
        students.add(new Student("Bob", 3.9, 104, "Computer Science"));
        students.add(new Student("Charlie", 3.2, 105, "Physics"));
        students.add(new Student("David", 3.6, 106, "Mathematics"));
        students.add(new Student("Eve", 3.8, 107, "Biology"));
    }

    public void displayStudents() {
        System.out.println("----------------------------------------------------------");
        System.out.println("Name       | GPA   | Reg No | Major      ");
        System.out.println("----------------------------------------------------------");
        for (Student student : students) {
            System.out.println(student);
        }
        System.out.println("----------------------------------------------------------");
    }

    public void sortByNaturalOrder() {
        Collections.sort(students);
        System.out.println("\nStudents sorted by registration number (natural order):");
        displayStudents();
    }

    public void sortByName() {
        Collections.sort(students, Comparator.comparing(Student::getName));
        System.out.println("\nStudents sorted by name:");
        displayStudents();
    }

    public void sortByGpaDescending() {
        Collections.sort(students, Comparator.comparing(Student::getGpa).reversed());
        System.out.println("\nStudents sorted by GPA (descending):");
        displayStudents();
    }

    public void sortByMajorThenGpa() {
        Collections.sort(students,
            Comparator.comparing(Student::getMajor)
                     .thenComparing(Student::getGpa, Comparator.reverseOrder()));
        System.out.println("\nStudents sorted by major, then by GPA (descending):");
        displayStudents();
    }

    public static void main(String[] args) {
        StudentManager manager = new StudentManager();
        Scanner scanner = new Scanner(System.in);

        while (true) {
            System.out.println("\nStudent Manager");
            System.out.println("1. Display students (unsorted)");
            System.out.println("2. Sort by registration number");
            System.out.println("3. Sort by name");
            System.out.println("4. Sort by GPA (highest first)");
            System.out.println("5. Sort by major, then by GPA (highest first)");
            System.out.println("6. Exit");
            System.out.print("Enter your choice: ");

            int choice = scanner.nextInt();

            switch (choice) {
                case 1:
                    System.out.println("\nUnsorted student list:");
                    manager.displayStudents();
                    break;
                case 2:
                    manager.sortByNaturalOrder();
                    break;
                case 3:
                    manager.sortByName();
                    break;
                case 4:
                    manager.sortByGpaDescending();
                    break;
                case 5:
                    manager.sortByMajorThenGpa();
                    break;
                case 6:
                    System.out.println("Exiting program. Goodbye!");
                    scanner.close();
                    return;
                default:
                    System.out.println("Invalid choice. Please try again.");
            }
        }
    }
}

Cette application :

1. Définit une classe Student avec un nom, un GPA (moyenne générale), un numéro d'inscription et une spécialité

2. Implémente Comparable pour définir l'ordre naturel par numéro d'inscription

3. Crée une classe StudentManager qui gère une liste d'étudiants

4. Fournit des méthodes pour trier les étudiants de différentes manières

5. Inclut une interface simple pilotée par menu pour que l'utilisateur puisse choisir différentes options de tri

6. Compilez et exécutez l'application :

cd ~/project
javac StudentManager.java
java StudentManager

3. Testez l'application en essayant diverses options de tri. Voici une interaction exemple :

Student Manager
1. Display students (unsorted)
2. Sort by registration number
3. Sort by name
4. Sort by GPA (highest first)
5. Sort by major, then by GPA (highest first)
6. Exit
Enter your choice: 1

Unsorted student list:
----------------------------------------------------------
Name       | GPA   | Reg No | Major
----------------------------------------------------------
John       | GPA: 3.5 | Reg No: 101   | Major: Computer Science
Mary       | GPA: 3.8 | Reg No: 102   | Major: Physics
Alice      | GPA: 3.5 | Reg No: 103   | Major: Mathematics
Bob        | GPA: 3.9 | Reg No: 104   | Major: Computer Science
Charlie    | GPA: 3.2 | Reg No: 105   | Major: Physics
David      | GPA: 3.6 | Reg No: 106   | Major: Mathematics
Eve        | GPA: 3.8 | Reg No: 107   | Major: Biology
----------------------------------------------------------

Student Manager
1. Display students (unsorted)
2. Sort by registration number
3. Sort by name
4. Sort by GPA (highest first)
5. Sort by major, then by GPA (highest first)
6. Exit
Enter your choice: 3

Students sorted by name:
----------------------------------------------------------
Name       | GPA   | Reg No | Major
----------------------------------------------------------
Alice      | GPA: 3.5 | Reg No: 103   | Major: Mathematics
Bob        | GPA: 3.9 | Reg No: 104   | Major: Computer Science
Charlie    | GPA: 3.2 | Reg No: 105   | Major: Physics
David      | GPA: 3.6 | Reg No: 106   | Major: Mathematics
Eve        | GPA: 3.8 | Reg No: 107   | Major: Biology
John       | GPA: 3.5 | Reg No: 101   | Major: Computer Science
Mary       | GPA: 3.8 | Reg No: 102   | Major: Physics
----------------------------------------------------------

Student Manager
1. Display students (unsorted)
2. Sort by registration number
3. Sort by name
4. Sort by GPA (highest first)
5. Sort by major, then by GPA (highest first)
6. Exit
Enter your choice: 5

Students sorted by major, then by GPA (descending):
----------------------------------------------------------
Name       | GPA   | Reg No | Major
----------------------------------------------------------
Eve        | GPA: 3.8 | Reg No: 107   | Major: Biology
Bob        | GPA: 3.9 | Reg No: 104   | Major: Computer Science
John       | GPA: 3.5 | Reg No: 101   | Major: Computer Science
David      | GPA: 3.6 | Reg No: 106   | Major: Mathematics
Alice      | GPA: 3.5 | Reg No: 103   | Major: Mathematics
Mary       | GPA: 3.8 | Reg No: 102   | Major: Physics
Charlie    | GPA: 3.2 | Reg No: 105   | Major: Physics
----------------------------------------------------------

Student Manager
1. Display students (unsorted)
2. Sort by registration number
3. Sort by name
4. Sort by GPA (highest first)
5. Sort by major, then by GPA (highest first)
6. Exit
Enter your choice: 6
Exiting program. Goodbye!

Vous pouvez expérimenter avec différentes options de tri pour voir comment la liste d'étudiants est affichée différemment à chaque fois.

Cette application complète démontre la puissance et la flexibilité des interfaces Comparable et Comparator en Java. Elle vous permet de trier des objets de diverses manières pour répondre à différentes exigences de votre application.

Résumé

Dans ce laboratoire, vous avez appris à comparer et trier des objets en Java en utilisant les interfaces Comparable et Comparator.

Concepts clés abordés :

1. Interface Comparable

   • Implémentation de la méthode compareTo() pour définir l'ordre naturel d'une classe
   • Utilisation de Collections.sort() avec des objets triés naturellement

2. Interface Comparator

   • Création de comparateurs personnalisés pour différents critères de tri
   • Utilisation de Collections.sort() avec un comparateur personnalisé
   • Utilisation d'expressions lambda et de références de méthode pour créer des comparateurs de manière concise

3. Techniques de tri avancées

   • Tri par plusieurs critères en utilisant thenComparing()
   • Tri dans l'ordre inverse en utilisant Collections.reverseOrder() ou reversed()
   • Création de chaînes de tri complexes

4. Application pratique

   • Construction d'un système de gestion d'étudiants complet avec diverses options de tri
   • Implémentation d'une interface utilisateur pour démontrer différentes capacités de tri

Ces capacités de tri sont fondamentales pour de nombreuses applications Java, en particulier celles qui traitent des collections de données. Que vous triiez des étudiants dans un système de gestion d'étudiants, des commandes dans une application de commerce électronique ou tout autre type de données, les techniques que vous avez apprises dans ce laboratoire vous aideront à implémenter une logique de tri efficace et flexible.