equals() et hashCode()

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

Lors de la comparaison d'objets en Java, l'opérateur == vérifie si deux références pointent vers le même emplacement mémoire. Pour comparer le contenu réel des objets, vous devez surcharger la méthode equals().

public class Person {
    private String name;
    private int age;
    
    @Override
    public boolean equals(Object obj) {
        if (this == obj) return true;
        if (obj == null || getClass() != obj.getClass()) return false;
        Person person = (Person) obj;
        return age == person.age && name.equals(person.name);
    }
}

La méthode equals() suit un modèle standard : vérifiez d'abord s'il s'agit du même objet, puis vérifiez le type, et enfin comparez les champs pertinents.

Chaque fois que vous redéfinissez equals(), vous devez également redéfinir hashCode(). C'est un contrat en Java : les objets qui sont égaux doivent avoir le même code de hachage. Les collections basées sur le hachage comme HashMap et HashSet s'appuient sur cette règle pour fonctionner correctement.

@Override
public int hashCode() {
    return Objects.hash(name, age);
}

La méthode utilitaire Objects.hash() génère un code de hachage à partir des mêmes champs utilisés dans equals(). Si deux objets Person ont les mêmes name et age, ils seront considérés comme égaux et produiront des codes de hachage identiques, garantissant un comportement cohérent dans les collections.

Défi

Facile

Construisons un système de dossiers d'étudiants qui implémente correctement l'égalité des objets. Vous allez créer une classe Student où deux étudiants sont considérés comme égaux s'ils ont le même identifiant d'étudiant et le même nom, qu'ils soient ou non le même objet en mémoire.

Vous organiserez votre code sur deux fichiers :

Student.java : Créez une classe représentant un étudiant avec trois champs privés : studentId (String), name (String) et gpa (double). Incluez un constructeur pour initialiser tous les champs et des méthodes getter pour chaque champ.
Surchargez la méthode equals() de sorte que deux objets Student soient considérés comme égaux lorsqu'ils ont le même studentId ET le même name. Suivez le modèle standard : vérifiez la référence identique, vérifiez la nullité et le type, puis comparez les champs pertinents.

Surchargez la méthode hashCode() en utilisant Objects.hash() avec les mêmes champs que ceux utilisés dans equals(). N'oubliez pas d'importer java.util.Objects en haut de votre fichier.
Main.java : Donnez vie à votre classe Student en comparant des objets étudiants. Vous recevrez six entrées représentant deux étudiants : l'ID, le nom et le GPA du premier étudiant, suivis de l'ID, du nom et du GPA du second étudiant.
Créez les deux objets Student, puis effectuez trois comparaisons et affichez les résultats :
1. Affichez "Same reference: " suivi du résultat indiquant si le premier étudiant est égal à lui-même (devrait toujours être vrai)
2. Affichez "Content equality: " suivi du résultat indiquant si le premier étudiant est égal au second (basé sur votre implémentation de equals)
3. Affichez "Hash codes match: " suivi du résultat indiquant si les deux étudiants ont le même code de hachage

Vous recevrez six entrées : l'ID du premier étudiant (String), le nom du premier étudiant (String), le GPA du premier étudiant (double), l'ID du second étudiant (String), le nom du second étudiant (String) et le GPA du second étudiant (double).

Remarquez comment, lorsque deux étudiants ont des identifiants et des noms correspondants, equals() retourne true ET leurs codes de hachage correspondent — c'est le contrat que vous devez maintenir !

Aide-mémoire

L'opérateur == vérifie si deux références pointent vers le même emplacement mémoire, et non si les objets ont le même contenu.

Pour comparer le contenu des objets, surchargez la méthode equals() en suivant ce modèle :

@Override
public boolean equals(Object obj) {
    if (this == obj) return true;  // Même référence
    if (obj == null || getClass() != obj.getClass()) return false;  // Null ou type différent
    Person person = (Person) obj;  // Cast vers le type correct
    return age == person.age && name.equals(person.name);  // Comparer les champs
}

Chaque fois que vous surchargez equals(), vous devez également surcharger hashCode(). C'est un contrat Java : des objets égaux doivent avoir le même code de hachage.

@Override
public int hashCode() {
    return Objects.hash(name, age);
}

Utilisez Objects.hash() avec les mêmes champs que ceux utilisés dans equals(). Cela garantit que les collections basées sur le hachage comme HashMap et HashSet fonctionnent correctement.

Essayez vous-même

import java.util.Scanner;

class Main {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        
        // Lire les données du premier étudiant
        String id1 = scanner.nextLine();
        String name1 = scanner.nextLine();
        double gpa1 = scanner.nextDouble();
        scanner.nextLine(); // consommer le saut de ligne
        
        // Lire les données du deuxième étudiant
        String id2 = scanner.nextLine();
        String name2 = scanner.nextLine();
        double gpa2 = scanner.nextDouble();
        
        // TODO: Créer deux objets Student en utilisant les données d'entrée
        
        // TODO: Afficher "Same reference: " suivi du résultat indiquant si student1 est égal à lui-même
        
        // TODO: Afficher "Content equality: " suivi du résultat indiquant si student1 est égal à student2
        
        // TODO: Afficher "Hash codes match: " suivi du résultat indiquant si les deux étudiants ont le même code de hachage
    }
}