Java Academy · Leçon

Implémenter hashCode

Écrivez des fonctions de hachage correctes

Implémenter hashCode est une leçon Java Academy gratuite sur CoddyKit. Ceci est la leçon 3 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.

Objectifs d’un bon hashCode

Un hashCode() correct doit :

Renvoyer la même valeur pour des objets égaux (le contrat).
Répartir les objets différents sur de nombreuses valeurs distinctes.
Être peu coûteux à calculer.

Un hashCode médiocre qui renvoie une constante respecte tout de même le contrat, mais transforme la map en liste chaînée lente.

public class Main {
    public static void main(String[] args) {
        // Legal but terrible: every object collides
        System.out.println("constant hashCode is legal but kills performance");
    }
}

Objects.hash pour le cas courant

L’approche correcte la plus simple est Objects.hash(field1, field2, ...).

Elle gère les valeurs null et combine les champs avec un algorithme standard. Utilisez les mêmes champs que ceux comparés dans equals.

import java.util.Objects;

public class Main {
    static class User {
        final String name; final int age;
        User(String name, int age) { this.name = name; this.age = age; }
        @Override public int hashCode() { return Objects.hash(name, age); }
    }
    public static void main(String[] args) {
        User a = new User("Ada", 36);
        User b = new User("Ada", 36);
        System.out.println(a.hashCode() == b.hashCode());
    }
}

Le multiplicateur classique 31

Pour un hash écrit à la main, le modèle standard multiplie un résultat cumulatif par 31, puis ajoute le hash de chaque champ.

31 est un nombre premier impair, et 31 * x équivaut à (x << 5) - x ; la JVM peut donc l’optimiser.

public class Main {
    static class User {
        final String name; final int age;
        User(String name, int age) { this.name = name; this.age = age; }
        @Override public int hashCode() {
            int result = 17;
            result = 31 * result + (name == null ? 0 : name.hashCode());
            result = 31 * result + age;
            return result;
        }
    }
    public static void main(String[] args) {
        System.out.println(new User("Ada", 36).hashCode());
    }
}

Hachage des types primitifs

Chaque type primitif possède une manière recommandée d’être haché :

int : utilisez directement la valeur.
long : (int)(value ^ (value >>> 32)).
boolean : 1 ou 0.
double : Double.hashCode(value).

public class Main {
    public static void main(String[] args) {
        long id = 4_000_000_000L;
        int longHash = (int) (id ^ (id >>> 32));
        System.out.println("long hash: " + longHash);
        System.out.println("double hash: " + Double.hashCode(3.14));
        System.out.println("bool hash: " + Boolean.hashCode(true));
    }
}

Hachage des tableaux

N’appelez pas directement hashCode() sur un tableau ; cette méthode utilise l’identité, et non le contenu.

Utilisez Arrays.hashCode(arr) pour un tableau simple, ou Arrays.deepHashCode(arr) pour des tableaux imbriqués.

import java.util.Arrays;

public class Main {
    public static void main(String[] args) {
        int[] a = {1, 2, 3};
        int[] b = {1, 2, 3};
        System.out.println("identity equal: " + (a.hashCode() == b.hashCode()));
        System.out.println("content equal: " + (Arrays.hashCode(a) == Arrays.hashCode(b)));
    }
}

Synchroniser equals et hashCode

Les champs utilisés dans hashCode() doivent constituer un sous-ensemble des champs utilisés dans equals() (idéalement, exactement les mêmes).

Si equals compare davantage de champs que hashCode, deux objets égaux partagent tout de même un hash. C’est autorisé. En revanche, si hashCode utilise un champ ignoré par equals, vous rompez le contrat.

import java.util.Objects;

public class Main {
    static class Coord {
        final int x, y;
        Coord(int x, int y) { this.x = x; this.y = y; }
        @Override public boolean equals(Object o) {
            return o instanceof Coord c && c.x == x && c.y == y;
        }
        @Override public int hashCode() { return Objects.hash(x, y); }
    }
    public static void main(String[] args) {
        Coord a = new Coord(3, 4), b = new Coord(3, 4);
        System.out.println(a.equals(b) && a.hashCode() == b.hashCode());
    }
}

Mise en cache du hash

Pour des objets immutables dont le hachage est coûteux, vous pouvez mettre le résultat en cache dans un champ.

String fait exactement cela en interne. Ne procédez ainsi que si l’objet est réellement immuable, afin que la valeur mise en cache ne devienne jamais obsolète.

import java.util.Objects;

public class Main {
    static final class Key {
        final String a, b;
        private int hash; // 0 until computed
        Key(String a, String b) { this.a = a; this.b = b; }
        @Override public int hashCode() {
            int h = hash;
            if (h == 0) { h = Objects.hash(a, b); hash = h; }
            return h;
        }
    }
    public static void main(String[] args) {
        Key k = new Key("x", "y");
        System.out.println(k.hashCode());
        System.out.println(k.hashCode());
    }
}

La répartition est importante

Un hashCode bien réparti distribue les clés uniformément entre les compartiments. Comptons les codes de hachage distincts pour un lot d’objets.

Plus les valeurs sont distinctes, moins il y a de collisions et plus la map est rapide.

import java.util.HashSet;
import java.util.Objects;
import java.util.Set;

public class Main {
    record Pair(int a, int b) {}
    public static void main(String[] args) {
        Set<Integer> hashes = new HashSet<>();
        for (int i = 0; i < 100; i++) {
            hashes.add(Objects.hash(i, i * 7));
        }
        System.out.println("distinct hashes: " + hashes.size());
    }
}

Un mauvais exemple de répartition Bad

Additionner les champs sans multiplication produit des collisions : (1,2) et (2,1) ont tous deux un hash égal à 3.

Le multiplicateur 31 rompt cette symétrie, car l’ordre devient alors important.

public class Main {
    static int badHash(int a, int b) { return a + b; }
    static int goodHash(int a, int b) { return 31 * a + b; }
    public static void main(String[] args) {
        System.out.println("bad (1,2): " + badHash(1, 2) + ", (2,1): " + badHash(2, 1));
        System.out.println("good (1,2): " + goodHash(1, 2) + ", (2,1): " + goodHash(2, 1));
    }
}

Privilégier les enregistrements pour les types valeur

Pour de simples conteneurs de données, un record génère automatiquement un hashCode correct et bien réparti.

Ne rédigez hashCode à la main que si vous avez besoin d’une sémantique personnalisée ou si vous ne pouvez pas utiliser un enregistrement.

public class Main {
    record Money(long cents, String currency) {}
    public static void main(String[] args) {
        Money a = new Money(1099, "USD");
        Money b = new Money(1099, "USD");
        System.out.println(a.equals(b));
        System.out.println(a.hashCode() == b.hashCode());
    }
}

Mise en pratique

Une classe valeur complète : des champs immuables, equals et hashCode fondés sur les mêmes champs, ainsi qu’un toString propre.

import java.util.Objects;

public class Main {
    static final class Version {
        final int major, minor, patch;
        Version(int major, int minor, int patch) {
            this.major = major; this.minor = minor; this.patch = patch;
        }
        @Override public boolean equals(Object o) {
            return o instanceof Version v && v.major == major && v.minor == minor && v.patch == patch;
        }
        @Override public int hashCode() { return Objects.hash(major, minor, patch); }
        @Override public String toString() { return major + "." + minor + "." + patch; }
    }
    public static void main(String[] args) {
        Version v = new Version(2, 1, 0);
        System.out.println(v + " hash=" + v.hashCode());
    }
}

Vérification rapide

Testez vos compétences en matière de hashCode.

Récapitulatif

Vous avez appris à implémenter hashCode correctement :

Utilisez Objects.hash(...) dans le cas courant.
Le modèle du multiplicateur 31 pour le hachage écrit à la main.
Hachez les tableaux avec Arrays.hashCode, et non avec la méthode par défaut.
Gardez les champs de hashCode synchronisés avec equals et privilégiez les enregistrements.

Ensuite, découvrez comment Java 8+ convertit en arbre les compartiments surchargés.

import java.util.Objects;

public class Main {
    public static void main(String[] args) {
        System.out.println("hashCode recap done: " + Objects.hash("done"));
    }
}

Questions Fréquemment Posées

La leçon « Implémenter hashCode » est-elle gratuite ?

Oui — le texte complet de « Implémenter hashCode » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Implémenter hashCode » ?

Écrivez des fonctions de hachage correctes Tu pratiques Java Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Java Academy ?

Aucune expérience préalable n'est requise. Java Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 3 sur 4.

Combien de temps prend la leçon « Implémenter hashCode » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Java Academy ?

Oui. Chaque leçon Java Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Java Academy