Java hashcode d'un champ

Si votre objet est mutable, il est acceptable de modifier son code de hachage au fil du temps. Bien sûr, vous devriez préférer des objets immuables ( Efficace Java 2nd édition, point 15: minimiser l'utabilité em>).

Voici la recette de hashcode de Josh Bloch, de Efficient Java 2nd Edition, point 9 : Toujours remplacer hashcode code> lorsque vous remplacez égale code> em>: p>

Recette de code de hachage Java 2nd édition efficace h3>

• Stockez une valeur constante non nulle, disons 17, dans une variable int code> appelé résultat code>. li>.
• Compute un int code> hashcode C code> pour chaque champ:
  • Si le champ est un booléen code>, calculez (f? 1: 0) code> li>
  • Si le champ est un octet, char, court, int code>, calculez (int) f code> li>
  • Si le champ est un long code>, calculez (int) (f ^ (f >>> 32)) code> li>
  • Si le champ est un float code>, calculez float.floattingbits (f) code> li>
  • Si le champ est un double code>, calculez double.doubletolongbits (f) code>, puis hachage le long code> comme dans ci-dessus. li>
  • Si le champ est une référence d'objet et la méthode de cette classe est égale code> compare le champ en appelant de manière récursive égale code>, invoquer de manière récursive hashcode code> sur le champ . Si la valeur du champ est null code>, retour 0. li>
  • Si le champ est un tableau, traitez-le comme si chaque élément est un champ distinct. Si chaque élément d'un champ de tableau est significatif, vous pouvez utiliser l'un des méthodes TRAASAYS.HASTCODE CODE> Ajouté dans la version 1.5. LI> ul> li>
  • combine le hashcode C code> dans résultat code> comme suit: résultat = 31 * résultat + c; code> li> li> ul>

    Il serait correct de suivre la recette tel quel, même avec un seul champ. Faites juste l'action appropriée en fonction du type de champ. P>

    Notez qu'il existe des bibliothèques qui simplifient cela pour vous, par exemple. hashcodebuilder code> de Apache Commons Lang ou juste arrairies.hashscode / deevhashCode code> de java.util.arrays code> . p>

    Ces bibliothèques vous permettent de simplement écrire quelque chose comme ceci: p>

    import org.apache.commons.lang.builder.*;
    
    public class CustomType implements Comparable<CustomType> {
        // constructors, etc
        // let's say that the "significant" fields are field1, field2, field3
        @Override public String toString() {
            return new ToStringBuilder(this)
                .append("field1", field1)
                .append("field2", field2)
                .append("field3", field3)
                    .toString();
        }
        @Override public boolean equals(Object o) {
            if (o == this) { return true; }
            if (!(o instanceof CustomType)) { return false; }
            CustomType other = (CustomType) o;
            return new EqualsBuilder()
                .append(this.field1, other.field1)
                .append(this.field2, other.field2)
                .append(this.field3, other.field3)
                    .isEquals();
        }
        @Override public int hashCode() {
            return new HashCodeBuilder(17, 37)
                .append(field1)
                .append(field2)
                .append(field3)
                    .toHashCode();
        }
        @Override public int compareTo(CustomType other) {
            return new CompareToBuilder()
                .append(this.field1, other.field1)
                .append(this.field2, other.field2)
                .append(this.field3, other.field3)
                    .toComparison();
        }
    }
    

Si vous voulez que des objets avec différents identifiants identifiés par cet identifiant, tout ce que vous avez à faire est de le renvoyer / le comparer.

private final int id;

public int hashCode() { return id; }

public boolean equals(Object o) { 
    return o instanceof ThisClass && id == ((ThisClass)o).id;
}

Peu importe que le nombre de champs sont utilisés pour calculer HashCode. Mais il compte travailler avec égaux () . Si un est égal à B, leur hachage doit être identique.

Si vous détestez HashCode :) et votre objet ne sera jamais mis aux conteneurs à base de hash (HASHMAP, HASHSET ..), il suffit de quitter HashCode () seul, laissez la classe de base à calculer HashCode.