Meilleure implémentation de la méthode hashCode pour une collection

Comment décidons-nous de la meilleure implémentation de la hashCode()méthode pour une collection (en supposant que la méthode equals a été remplacée correctement)?

La meilleure mise en œuvre? C'est une question difficile car elle dépend du modèle d'utilisation.

Dans presque tous les cas, une bonne mise en œuvre raisonnable a été proposée dans Josh Bloch 's Effective Java dans le point 8 (deuxième édition). Le mieux est de le chercher là-haut car l'auteur y explique pourquoi l'approche est bonne.

Une version courte

1. Créez un int resultet attribuez une valeur non nulle .

2. Pour chaque champ f testé dans la equals()méthode, calculez un code de hachage cpar:

   • Si le champ f est a boolean: calculer (f ? 0 : 1);
   • Si le f champ est byte, char, shortou int: calculer (int)f;
   • Si le champ f est a long: calculer (int)(f ^ (f >>> 32));
   • Si le champ f est a float: calculer Float.floatToIntBits(f);
   • Si le champ f est a double: calculez Double.doubleToLongBits(f)et gérez la valeur de retour comme chaque valeur longue;
   • Si le champ f est un objet : utilisez le résultat de la hashCode()méthode ou 0 si f == null;
   • Si le champ f est un tableau : voyez chaque champ comme un élément distinct et calculez la valeur de hachage de manière récursive et combinez les valeurs comme décrit ci-dessous.

3. Combinez la valeur de hachage cavec result:

   result = 37 * result + c

4. Revenir result

Cela devrait se traduire par une distribution correcte des valeurs de hachage pour la plupart des situations d'utilisation.

Si vous êtes satisfait de l'implémentation effective de Java recommandée par dmeister, vous pouvez utiliser un appel de bibliothèque au lieu de lancer le vôtre:

@Override
public int hashCode() {
    return Objects.hashCode(this.firstName, this.lastName);
}

Cela nécessite Guava ( com.google.common.base.Objects.hashCode) ou la bibliothèque standard de Java 7 ( java.util.Objects.hash) mais fonctionne de la même manière.

Il est préférable d'utiliser les fonctionnalités fournies par Eclipse qui font un très bon travail et vous pouvez mettre vos efforts et votre énergie dans le développement de la logique métier.

Bien que cela soit lié à la Androiddocumentation (Wayback Machine) et à mon propre code sur Github , cela fonctionnera pour Java en général. Ma réponse est une extension de la réponse de dmeister avec juste du code qui est beaucoup plus facile à lire et à comprendre.

@Override 
public int hashCode() {

    // Start with a non-zero constant. Prime is preferred
    int result = 17;

    // Include a hash for each field.

    // Primatives

    result = 31 * result + (booleanField ? 1 : 0);                   // 1 bit   » 32-bit

    result = 31 * result + byteField;                                // 8 bits  » 32-bit 
    result = 31 * result + charField;                                // 16 bits » 32-bit
    result = 31 * result + shortField;                               // 16 bits » 32-bit
    result = 31 * result + intField;                                 // 32 bits » 32-bit

    result = 31 * result + (int)(longField ^ (longField >>> 32));    // 64 bits » 32-bit

    result = 31 * result + Float.floatToIntBits(floatField);         // 32 bits » 32-bit

    long doubleFieldBits = Double.doubleToLongBits(doubleField);     // 64 bits (double) » 64-bit (long) » 32-bit (int)
    result = 31 * result + (int)(doubleFieldBits ^ (doubleFieldBits >>> 32));

    // Objects

    result = 31 * result + Arrays.hashCode(arrayField);              // var bits » 32-bit

    result = 31 * result + referenceField.hashCode();                // var bits » 32-bit (non-nullable)   
    result = 31 * result +                                           // var bits » 32-bit (nullable)   
        (nullableReferenceField == null
            ? 0
            : nullableReferenceField.hashCode());

    return result;

}

ÉDITER

En règle générale, lorsque vous remplacez hashcode(...), vous souhaitez également remplacer equals(...). Donc pour ceux qui le feront ou l'ont déjà implémenté equals, voici une bonne référence de mon Github ...

@Override
public boolean equals(Object o) {

    // Optimization (not required).
    if (this == o) {
        return true;
    }

    // Return false if the other object has the wrong type, interface, or is null.
    if (!(o instanceof MyType)) {
        return false;
    }

    MyType lhs = (MyType) o; // lhs means "left hand side"

            // Primitive fields
    return     booleanField == lhs.booleanField
            && byteField    == lhs.byteField
            && charField    == lhs.charField
            && shortField   == lhs.shortField
            && intField     == lhs.intField
            && longField    == lhs.longField
            && floatField   == lhs.floatField
            && doubleField  == lhs.doubleField

            // Arrays

            && Arrays.equals(arrayField, lhs.arrayField)

            // Objects

            && referenceField.equals(lhs.referenceField)
            && (nullableReferenceField == null
                        ? lhs.nullableReferenceField == null
                        : nullableReferenceField.equals(lhs.nullableReferenceField));
}

Assurez-vous d'abord qu'equals est correctement implémenté. Extrait d' un article IBM DeveloperWorks :

• Symétrie: pour deux références, a et b, a.equals (b) si et seulement si b.equals (a)
• Réflexivité: pour toutes les références non nulles, a.equals (a)
• Transitivité: si a.equals (b) et b.equals (c), alors a.equals (c)

Assurez-vous ensuite que leur relation avec hashCode respecte le contact (du même article):

• Cohérence avec hashCode (): deux objets égaux doivent avoir la même valeur hashCode ()

Enfin, une bonne fonction de hachage doit s'efforcer d'approcher la fonction de hachage idéale .

about8.blogspot.com, vous avez dit

si equals () retourne vrai pour deux objets, hashCode () devrait retourner la même valeur. Si equals () retourne false, hashCode () devrait retourner des valeurs différentes

Je ne peux pas être d'accord avec toi. Si deux objets ont le même hashcode, cela ne signifie pas nécessairement qu'ils sont égaux.

Si A est égal à B, A.hashcode doit être égal à B.hascode

mais

si A.hashcode est égal à B.hascode, cela ne signifie pas que A doit être égal à B

Si vous utilisez eclipse, vous pouvez générer equals()et hashCode()utiliser:

Source -> Générer hashCode () et equals ().

En utilisant cette fonction, vous pouvez décider quels champs vous souhaitez utiliser pour l'égalité et le calcul du code de hachage, et Eclipse génère les méthodes correspondantes.

Il y a une bonne mise en œuvre du Effective Java de hashcode()et equals()logique dans Apache Commons Lang . Commander HashCodeBuilder et EqualsBuilder .

Juste une note rapide pour compléter une autre réponse plus détaillée (en termes de code):

Si je considère la question de savoir comment créer une table de hachage en Java et en particulier l' entrée FAQ jGuru , je pense que d'autres critères sur lesquels un code de hachage pourrait être jugé sont:

• synchronisation (l'algo prend-il en charge l'accès simultané ou non)?
• échec de l'itération sécurisée (l'algo détecte-t-il une collection qui change pendant l'itération)
• valeur nulle (le code de hachage prend-il en charge la valeur nulle dans la collection)

Si je comprends bien votre question, vous avez une classe de collection personnalisée (c'est-à-dire une nouvelle classe qui s'étend de l'interface Collection) et vous souhaitez implémenter la méthode hashCode ().

Si votre classe de collection étend AbstractList, vous n'avez pas à vous en préoccuper, il existe déjà une implémentation de equals () et hashCode () qui fonctionne en itérant à travers tous les objets et en ajoutant leurs hashCodes () ensemble.

   public int hashCode() {
      int hashCode = 1;
      Iterator i = iterator();
      while (i.hasNext()) {
        Object obj = i.next();
        hashCode = 31*hashCode + (obj==null ? 0 : obj.hashCode());
      }
  return hashCode;
   }

Maintenant, si ce que vous voulez est la meilleure façon de calculer le code de hachage pour une classe spécifique, j'utilise normalement l'opérateur ^ (bitwise exclusif ou) pour traiter tous les champs que j'utilise dans la méthode equals:

public int hashCode(){
   return intMember ^ (stringField != null ? stringField.hashCode() : 0);
}

@ about8: il y a là un bug assez sérieux.

Zam obj1 = new Zam("foo", "bar", "baz");
Zam obj2 = new Zam("fo", "obar", "baz");

même hashcode

vous voulez probablement quelque chose comme

public int hashCode() {
    return (getFoo().hashCode() + getBar().hashCode()).toString().hashCode();

(pouvez-vous obtenir hashCode directement depuis int en Java ces jours-ci? Je pense qu'il fait une diffusion automatique .. si c'est le cas, sautez la toString, c'est moche.)

Comme vous l'avez spécifiquement demandé pour les collections, j'aimerais ajouter un aspect que les autres réponses n'ont pas encore mentionné: Un HashMap ne s'attend pas à ce que ses clés changent leur code de hachage une fois qu'elles sont ajoutées à la collection. Serait contraire à l'objectif ...

Utilisez les méthodes de réflexion sur Apache Commons EqualsBuilder et HashCodeBuilder .

J'utilise un petit wrapper Arrays.deepHashCode(...)car il gère correctement les tableaux fournis comme paramètres

public static int hash(final Object... objects) {
    return Arrays.deepHashCode(objects);
}

toute méthode de hachage qui distribue uniformément la valeur de hachage sur la plage possible est une bonne implémentation. Voir java efficace ( http://books.google.com.au/books?id=ZZOiqZQIbRMC&dq=effective+java&pg=PP1&ots=UZMZ2siN25&sig=kR0n73DHJOn-D77qGj0wOxAxiZw&hl=en&sa=X&oi=book_result&resnum=1&ct=result ), il y a un bon conseil là pour la mise en œuvre de hashcode (point 9 je pense ...).

Je préfère utiliser les méthodes utilitaires de Google Collections lib de la classe Objects qui m'aident à garder mon code propre. Très souvent equals, les hashcodeméthodes sont faites à partir du modèle IDE, donc elles ne sont pas propres à lire.

Voici une autre démonstration de l'approche JDK 1.7+ avec les logiques de superclasse prises en compte. Je le vois comme assez pratique avec la classe Object hashCode (), une pure dépendance JDK et aucun travail manuel supplémentaire. Veuillez noter que la Objects.hash()tolérance est nulle.

Je n'ai inclus aucune equals()implémentation mais en réalité vous en aurez bien sûr besoin.

import java.util.Objects;

public class Demo {

    public static class A {

        private final String param1;

        public A(final String param1) {
            this.param1 = param1;
        }

        @Override
        public int hashCode() {
            return Objects.hash(
                super.hashCode(),
                this.param1);
        }

    }

    public static class B extends A {

        private final String param2;
        private final String param3;

        public B(
            final String param1,
            final String param2,
            final String param3) {

            super(param1);
            this.param2 = param2;
            this.param3 = param3;
        }

        @Override
        public final int hashCode() {
            return Objects.hash(
                super.hashCode(),
                this.param2,
                this.param3);
        }
    }

    public static void main(String [] args) {

        A a = new A("A");
        B b = new B("A", "B", "C");

        System.out.println("A: " + a.hashCode());
        System.out.println("B: " + b.hashCode());
    }

}

L'implémentation standard est faible et son utilisation entraîne des collisions inutiles. Imaginez un

class ListPair {
    List<Integer> first;
    List<Integer> second;

    ListPair(List<Integer> first, List<Integer> second) {
        this.first = first;
        this.second = second;
    }

    public int hashCode() {
        return Objects.hashCode(first, second);
    }

    ...
}

Maintenant,

new ListPair(List.of(a), List.of(b, c))

et

new ListPair(List.of(b), List.of(a, c))

ont la même chose hashCode, à savoir 31*(a+b) + cque le multiplicateur utilisé pour List.hashCodeest réutilisé ici. De toute évidence, les collisions sont inévitables, mais produire des collisions inutiles est tout simplement ... inutile.

Il n'y a rien de vraiment intelligent à utiliser 31. Le multiplicateur doit être impair afin d'éviter de perdre des informations (tout multiplicateur pair perd au moins le bit le plus significatif, des multiples de quatre en perdent deux, etc.). Tout multiplicateur impair est utilisable. Les petits multiplicateurs peuvent conduire à un calcul plus rapide (le JIT peut utiliser des décalages et des ajouts), mais étant donné que la multiplication a une latence de seulement trois cycles sur Intel / AMD moderne, cela n'a guère d'importance. Les petits multiplicateurs entraînent également plus de collision pour les petites entrées, ce qui peut parfois être un problème.

L'utilisation d'un nombre premier est inutile car les nombres premiers n'ont aucune signification dans l'anneau Z / (2 ** 32).

Donc, je recommanderais d'utiliser un grand nombre impair choisi au hasard (n'hésitez pas à prendre un nombre premier). Comme les processeurs i86 / amd64 peuvent utiliser une instruction plus courte pour les opérandes s'inscrivant dans un seul octet signé, il y a un avantage de vitesse minuscule pour les multiplicateurs comme 109. Pour minimiser les collisions, prenez quelque chose comme 0x58a54cf5.

L'utilisation de multiplicateurs différents à différents endroits est utile, mais probablement pas suffisante pour justifier le travail supplémentaire.

Lors de la combinaison de valeurs de hachage, j'utilise généralement la méthode de combinaison utilisée dans la bibliothèque boost c ++, à savoir:

seed ^= hasher(v) + 0x9e3779b9 + (seed<<6) + (seed>>2);

Cela fait un assez bon travail pour assurer une distribution uniforme. Pour une discussion sur le fonctionnement de cette formule, voir le post StackOverflow: Nombre magique dans boost :: hash_combine

Il y a une bonne discussion sur les différentes fonctions de hachage sur: http://burtleburtle.net/bob/hash/doobs.html

Pour une classe simple, il est souvent plus facile d'implémenter hashCode () en fonction des champs de classe qui sont vérifiés par l'implémentation equals ().

public class Zam {
    private String foo;
    private String bar;
    private String somethingElse;

    public boolean equals(Object obj) {
        if (this == obj) {
            return true;
        }

        if (obj == null) {
            return false;
        }

        if (getClass() != obj.getClass()) {
            return false;
        }

        Zam otherObj = (Zam)obj;

        if ((getFoo() == null && otherObj.getFoo() == null) || (getFoo() != null && getFoo().equals(otherObj.getFoo()))) {
            if ((getBar() == null && otherObj. getBar() == null) || (getBar() != null && getBar().equals(otherObj. getBar()))) {
                return true;
            }
        }

        return false;
    }

    public int hashCode() {
        return (getFoo() + getBar()).hashCode();
    }

    public String getFoo() {
        return foo;
    }

    public String getBar() {
        return bar;
    }
}

La chose la plus importante est de garder cohérents hashCode () et equals (): si equals () renvoie true pour deux objets, alors hashCode () devrait retourner la même valeur. Si equals () retourne false, hashCode () devrait retourner des valeurs différentes.