Création d'une méthode hashCode () - Java

J'ai un peu de mal à écrire un hashCode() méthode d'une classe que j'ai créée. Cette classe est destinée à être utilisée à l'intérieur d'un TreeSet, et en tant que tel, il implémente Comparable. La classe comporte les variables suivantes:

public class Node implements Comparable<Node> {
   Matrix matrix;
   int[] coordinates= new int[2];
   Node father;
   int depth;
   int cost;

Voici la mise en œuvre de la compareTo() méthode. Je veux le TreeSet pour organiser ces nœuds des structures par leur coût, par conséquent, compareTo() retourne le résultat d'une simple soustraction.

public int compareTo(Node nodeToCompare) {
    return this.cost - nodeToCompare.cost;
}

J'ai aussi mis en place un equals() méthode.

public boolean equals(Object objectToCompare) {
    if(objectToCompare== this) {return true;}
    if(objectToCompare== null || objectToCompare.getClass()!= this.getClass()) {return false;}

    Node objectNode= (Node) objectToCompare;
    return this.father.equals(objectNode.father) &&
            this.depth== objectNode.depth &&
            this.cost== objectNode.cost &&
            this.matrix.equals(objectNode.matrix) &&
            Arrays.equals(this.coordinates, objectNode.coordinates);
}

Ayant dit tout cela, j'ai quelques questions:

Depuis que j'ai mis en place un nouveau equals() méthode, dois-je mettre en place un nouveau hashCode() méthode?
Comment puis-je mettre en place une nouvelle hashCode method() avec ces variables? (Notez que la variable de la matrice du type de la Matrice a une hashCode() méthode de mise en œuvre)

C'est tout!

source d'informationauteur Gonçalo Lourenço

19

Votre compareTo méthode n'est pas compatible avec votre equals méthode: votre compareTo méthode affirme que les deux instances sont équivalents s'ils ont le même cost — tels qu'un TreeSet ne peut jamais contenir au plus une instance avec un cost — mais votre equals méthode dit qu'ils sont équivalents s'ils ont le même cost et sont les mêmes dans les diverses autres façons.

Donc, en supposant que votre equals méthode est correcte:
- vous avez besoin pour réparer votre compareTo méthode pour être en accord avec elle.
- vous avez besoin pour créer un hashCode méthode qui est cohérent avec lui. Je recommande d'utiliser le même genre de logique est utilisé par java.util.Liste.hashCode()qui est un simple et efficace pour assembler le hash-codes de composants objets dans un ordre précis; fondamentalement, vous pouvez écrire quelque chose comme:
```
int hashCode = 1; 
hashCode = 31 * hashCode + (père == null ? 0 : le père.hashCode()); 
hashCode = 31 * hashCode + profondeur; 
hashCode = 31 * hashCode + coût; 
hashCode = 31 * hashCode + de la matrice.hashCode(); 
hashCode = 31 * hashCode + java.util.Les tableaux de.hashCode(coordonnées); 
retour hashCode;
```
7

Intellij IDEA pouvez faire cela comme un 'clic-droit'. Juste de voir qu'il fait correctement, vous apprendra beaucoup.

Et vous devez remplacer les deux en tout cas.
3

Le contrat pour la méthode hashCode stipule que si deux objets sont égaux, puis de l'appel d'hashCode() devrait vous donner le même résultat sous forme d'entier. Le contraire n'a pas à être vrai, c'est à dire si deux hashCodes sont les mêmes, les objets n'ont pas d'égaux les uns aux autres.

Regardant votre méthode equals (qui a besoin de la variable traduction btw), vous pouvez ajouter les hashCodes de tous les membres internes variables qui doivent être égaux pour votre méthode equals pour donner une vraie. par exemple,
```
public int hashCode() {
    return this.matrix.hashCode() + 
           this.coordinates[0] + 
           this.coordinates[1] + 
           this.father.hashCode() +
           this.depth + this.cost;               
}
```
Ci-dessus suppose que la matrice et le père ne sont jamais les valeurs null, vous devez vous assurer que vous vérifiez les valeurs null si ce n'est pas le cas.

Si vous vous sentez plus aventureux, vous pouvez multiplier un peu de ci-dessus avec un premier pour vous assurer que vous n'obtenez pas hashCode de collisions de données différentes (cela va aider à améliorer les performances si vous utilisez votre classe en tables de hachage et hashMaps). Si vous avez besoin de répondre pour les valeurs null, la méthode ci-dessus peut être écrit un peu mieux comme ceci:
```
public int hashCode() {
    return ((this.matrix == null) ? 0 : this.matrix.hashCode()) + 
           17 * this.coordinates[0] + 
           this.coordinates[1] + 
           ((this.father == null) ? 0 : this.father.hashCode()) +
           31 * this.depth + 19 * this.cost;               
}
```
0

Si votre collection est petite, vous pouvez retourner constante de la méthode hashCode. Il utiliser pour rapidement trouver. hashCodes est comme les boîtes de garder ces éléments. Les règles sont les suivantes:
1. Égal éléments doivent être dans la même zone (qui ont le même hashCode) - certainement;
2. Pas égal éléments peuvent être dans la même ou dans les différentes cases.
Ensuite, vous revenez constante, vous obéissez à ces 2 règles, mais il peut réduire considérablement les performances sur les pas de petites listes (en raison de la JVM va chercher dans tous les éléments, et pas dans des éléments dans la même case seulement). Mais de retour constante, c'est la mauvaise approche.

PS: Désolé pour mon écriture. L'anglais n'est pas ma langue maternelle.

PPS: en général, vous avez à mettre en œuvre la méthode hashCode de la même manière que equals (utiliser les mêmes éléments)

Vous devez vous connecter pour publier un commentaire.