Formations — 1 037 leçons en français

Accueil › Java › Égalité, hachage et comparaison

Égalité, hachage et comparaison

Aller plus loin en objetdebutant

== compare des références sur des objets (le même emplacement en mémoire), jamais leur contenu :

Produit p1 = new Produit("Clavier", 49.90);
Produit p2 = new Produit("Clavier", 49.90);

p1 == p2;        // false : deux objets distincts
p1.equals(p2);   // dépend de la redéfinition d'equals()

Sans redéfinition, equals() hérité d'Object se comporte exactement comme ==. Pour comparer le contenu, il faut redéfinir equals() — et, systématiquement en même temps, hashCode() :

public class Produit {
    private final String nom;
    private final double prix;

    @Override
    public boolean equals(Object o) {
        if (this == o) return true;
        if (!(o instanceof Produit autre)) return false;
        return Double.compare(prix, autre.prix) == 0 && Objects.equals(nom, autre.nom);
    }

    @Override
    public int hashCode() {
        return Objects.hash(nom, prix);
    }
}

Règle absolue : deux objets égaux selon equals() doivent avoir le même hashCode(). Casser cette règle rend un objet introuvable dans une HashMap ou un HashSet, même après un equals() qui aurait renvoyé true.

equals() et hashCode() redéfinis ensemble clé « Clavier » hashCode 2043 seau = h % 4 seau 0 seau 1 seau 2 seau 3 Clavier trouvé equals ✓ hashCode() oublié : l'identité sert de hachage clé « Clavier » hashCode 7781 seau = h % 4 seau 0 seau 1 vide seau 2 seau 3 Clavier introuvable jamais testé
hashCode() choisit le seau, equals() compare à l'intérieur du seau. Mauvais seau, et equals() n'est même jamais appelé — d'où l'objet « perdu » dans la map.

Pour trier ou ordonner, deux interfaces distinctes : Comparable définit un ordre naturel unique par classe (compareTo), Comparator définit un ordre externe, autant qu'on veut (compare).

Les termes à connaître

== (opérateur)

Sur des objets, compare les références (même emplacement en mémoire), pas leur contenu. Sur des types primitifs, compare les valeurs. Deux objets avec un contenu identique mais créés séparément sont == faux.

equals()

Méthode héritée d'Object, à redéfinir pour comparer le contenu de deux objets plutôt que leur référence. Par défaut (sans redéfinition), equals() se comporte exactement comme ==.

Contrat d'equals

Règles que toute redéfinition d'equals doit respecter : réflexive (x.equals(x) vrai), symétrique (x.equals(y) ⟺ y.equals(x)), transitive (x.equals(y) et y.equals(z) ⟹ x.equals(z)), cohérente (résultat stable tant que les objets ne changent pas), et x.equals(null) toujours faux.

Contrat equals/hashCode

Deux objets égaux selon equals() doivent obligatoirement avoir le même hashCode(). L'inverse n'est pas exigé : deux objets non égaux peuvent avoir le même hashCode (une collision, normale et gérée).

Comparable

Interface avec la méthode compareTo(T autre), qui définit l'ordre naturel d'un type — un seul ordre possible par classe. Utilisée par Collections.sort(), TreeSet, TreeMap sans argument supplémentaire.

Comparator

Interface fonctionnelle avec la méthode compare(T a, T b), qui définit un ordre externe à la classe comparée. Permet de définir plusieurs ordres différents (par prix, par nom…) sans toucher à la classe elle-même.

Lire l'explication détaillée et faire le quiz →

Cette page présente la partie essentielle de la leçon. Les exemples commentés, les pièges courants et les trois questions de quiz sont dans l'application.