Comment les codes de hachage pour les énumérations sont-ils calculés en Java, et en combinant enum hashCodes pour une clé de HashMap?

J'ai une classe qui contient différentes énumérations (les différents types). Cette classe est utilisé comme clé pour un HashMap. Les classes hashCode est actuellement mis en œuvre comme ceci:

  public static class Key implements Comparable<Key> {
    final int a;
    final Enum1 enum1;
    final Enum2 enum2;

    @Override
    public int hashCode() {
      return a ^ enum1.hashCode() ^ enum2.hashCode();
    }

    //... definition of equals and toString ...
  }

Maintenant, si les énumérations hashCode serait juste de retour de l'indice de la valeur d'enum dans l'enum définition, ce ne serait pas optimal (trop nombreux affrontements). La définition de la méthode pour Enum.hashCode() est-ce:

/**
 * Returns a hash code for this enum constant.
 *
 * @return a hash code for this enum constant.
 */
public final int hashCode() {
    return super.hashCode();
}

En supposant que cette délégués à Object.hashCode()tout devrait bien se passer parce que pour chaque constante enum il n'existe qu'un seul exemple, et Object.hashCode() sera, en théorie, être quelque chose comme un entier dérivée à partir de l'adresse interne de l'objet. Suis-je le droit?

PS: bien sûr, vous devrez utiliser quelque chose de plus complexe lorsque le même enum est utilisé plusieurs fois dans une clé.

source d'informationauteur Axel

9

Oui, vous avez raison en ce que le hashcode d'un enum élément viendra de l'instance statique, liés à des positions de mémoire, et être unique.

D'autre part, il existe de meilleures façons de générer un hashcode avec moins de probabilité de collision. Découvrez, par exemple, les valeurs par défaut que eclipse peut générer automatiquement pour vous (cliquez avec le bouton droit de la Source> Générer hashCode et equals)
```
public int hashCode() {
    final int prime = 31;
    int result = 1;
    result = prime * result + ((enum1 == null) ? 0 : enum1.hashCode());
    result = prime * result + ((enum2 == null) ? 0 : enum2.hashCode());
    return result;
}
```
En jetant des nombres premiers dans le mélange (le précis de mathématiques m'échappe), vous sont censés être un peu plus résistant.

Remarque vous pouvez également laisser eclipse générer une méthode equals pour vous! (Même un toString). Pas dire que vous devez aveuglément confiance en eux, mais ils sont généralement un très bon début.

Dans Java 8, vous pouvez utiliser Objects.hash() à cette fin.

Par exemple, vous pouvez réécrire votre hashCode à

//
import static java.util.Objects.hash;

//
@Override
public int hashCode() {
  return hash(a, enum1, enum2);
}

1

Comme il est dit ci-dessus,Enum sont immuables dans le Java,
De sorte que le hashcode généré pour un Enum est une incrustation parfaite pour un Hachage collection,tout comme la Chaîne sont parfaits clés.

La déclaration d'enum est un type spécial de déclaration de classe. Un type enum a public, auto-tapé membres, pour chacun des enum constantes. Tous énumérer les classes sont de haute qualité toString, hashCode et equals méthodes. Tous sont Sérialisables, Comparable et efficace de finale. Aucun n'est Clonable. Tous les "méthodes de l'Objet", sauf toString sont finales: nous nous occupons de la comparaison et de la sérialisation, et de veiller à t
chapeau c'est bien fait.
0

Viens de tester cela sur un Oracle 1.6 JVM. L'enum en effet, les délégués à l'Objet.hashCode(). Et il varie entre les différentes pistes. Gardez à l'esprit que les touches ne sont donc pas stables entre les différentes Vm /VM instances. Ainsi, lorsque vous sérialiser la table de hachage et de le lire dans une autre machine virtuelle, vous ne serez pas en mesure de regarder des valeurs à l'aide des touches qui ont été construits dans cette machine virtuelle.

Vous devez vous connecter pour publier un commentaire.