Le contenu principal de cet article est la méthode d'évaluation correcte de HashCode en Java, comme suit.
Il existe une optimisation pour les listes de hachage qui peuvent mettre en cache le code de hachage de l'objet. Si le code de hachage ne correspond pas, il ne vérifiera pas l'équivalence de l'objet et considérera directement qu'il s'agit d'un objet différent. Si le code de hash (HashCode) est égal, il détectera si les objets sont égaux.
Si les objets ont le même code de hachage (HashCode), ils sont mappés au même seau de hachage. Si le code hash de tous les objets dans la liste de hachage est le même, la liste de hachage se dégénérera en une liste liée, ce qui réduit considérablement son efficacité de requête.
Une bonne fonction de hachage tend généralement à "générer des codes de hachage inégaux pour les objets qui ne veulent pas attendre". Idéalement, la fonction de hachage devrait répartir uniformément les instances de l'ensemble qui ne veulent pas être ainsi à tous les hachages possibles, mais il est très difficile d'atteindre pleinement cette situation idéale. Voici une méthode de hachage relativement simple et efficace:
1. Enregistrer une valeur constante non nulle, comme 17, dans une variable de type int appelé résultat.
2. Pour chaque domaine clé F dans l'objet ( se référant à chaque domaine impliqué dans la méthode égaux ), complétez les étapes suivantes:
result = 31 * result + c; L'opération de multiplication consiste à obtenir une meilleure fonction de hachage. Par exemple, si la fonction de hachage de la chaîne omet la multiplication, alors toutes les chaînes avec un ordre alphabétique différent auront le même code de hachage. La raison pour laquelle 31 est choisi ici est parce que c'est un numéro de premier ordre. Si le multiplicateur est un nombre pair et que la multiplication déborde, les informations seront perdues car la multiplication avec 2 est équivalente au déplacement. Les avantages de l'utilisation de nombres premiers ne sont pas évidents, mais les résultats du hachage sont conventionnellement utilisés pour calculer les résultats du hachage. 31 a une bonne fonctionnalité, c'est-à-dire en utilisant le décalage et la soustraction au lieu de la multiplication, qui peuvent obtenir de meilleures performances: 31 * i == (i << 5) - i. Les machines virtuelles d'aujourd'hui peuvent implémenter automatiquement cette optimisation.Si une classe est immuable (tous les domaines sont des modifications finales et que tous les domaines sont des types de base ou des classes immuables), et que la surcharge de calcul des codes de hachage est également relativement élevée, vous devriez alors considérer le cache du code de hachage à l'intérieur de l'objet.
classe publique HashCodeDemo {classe statique HashCodeClass {private final boolean bresult; Byte de l'octet final final privé; Final privé Char Charvalue; Finale privée courte courte de la valeur courte; Int final privé intvalue; Finale privée longue longue valeur; Float Float final privé; Double double valeur privée; chaîne finale finale privée Str; finale privée finale int [] arrayvalue; // Volatile signifie que la variable est stockée et récupérée en mémoire à chaque fois pour s'assurer que la variable est la dernière HashCode INT volatile privé; public hashCodeClass () {Bresult = false; bytevalue = 1; charvalue = 'a'; ShortValue = 1; intValue = 1; longValue = 1L; floatValue = 1,0f; DoubleValue = 1.0D; str = getClass (). getName (); arrayValue = new int [] {1,2,3,4,5}; } @Override public int hashcode () {if (hashcode == 0) {// Définissez une valeur initiale non nulle pour augmenter le conflit du domaine zéro résultat = 17; // Si le multiplicateur est omis, toutes les chaînes avec un ordre alphabétique différent auront le même code de hachage final int hash_code = 31; result = hash_code * result + (Bresult? 1: 0); result = hash_code * result + bytevalue; result = hash_code * result + charvalue; result = hash_code * result + shortvalue; result = hash_code * result + intValue; result = hash_code * result + (int) (longValue ^ (longValue >>> 32)); result = hash_code * result + float.floattointBits (floatValue); Long DoublelongValue = double.doubletolongbits (doubleValue); result = hash_code * Result + (int) (DoublelongValue ^ (DoublelongValue >>> 32)); result = hash_code * result + (str == null? 0: str.hashcode ()); System.out.println ("str =" + str + ", str.hashcode =" + str.hashcode ()); result = hash_code * result + arrayvalue.hashcode (); Résultat de retour; } return hashcode; }} public static void main (String [] args) {hashCodeclass obj = new HashCodeClass (); System.out.println ("obj.hashcode =" + obj.hashcode ()); System.out.println ("obj =" + obj.toString ()); }}Sortir
str = com.demo.test.hashcodedemo $ hashcodeclass, str.hashcode = -205823051obj.hashcode = 946611167str = com.demo.test.hashcodedemo $ hashcodeclass, str.hashcode=-205823051obj=com.demo.test.hashcodemo$hashcodeclass@386c23df
Résumer
Ce qui précède concerne cet article en discutant de la méthode d'évaluation correcte de HashCode en Java, et j'espère qu'elle sera utile à tout le monde. Les amis intéressés peuvent continuer à se référer à d'autres sujets connexes sur ce site. S'il y a des lacunes, veuillez laisser un message pour le signaler. Merci vos amis pour votre soutien pour ce site!