Der Hauptinhalt dieses Artikels ist die korrekte Bewertungsmethode von HashCode in Java wie folgt.
Es gibt eine Optimierung für Hash -Listen, die den Hash -Code des Objekts zwischenspeichern können. Wenn der Hash -Code nicht übereinstimmt, überprüft er nicht die Äquivalenz des Objekts und betrachtet ihn direkt als ein anderes Objekt. Wenn der Hash -Code (HashCode) gleich ist, erkennt er, ob die Objekte gleich sind.
Wenn die Objekte denselben Hash -Code (HashCode) haben, werden sie demselben Hash -Eimer zugeordnet. Wenn der HashCode aller Objekte in der Hash -Liste gleich ist, entartet die Hash -Liste zu einer verknüpften Liste, die ihre Abfrageeffizienz stark reduziert.
Eine gute Hash -Funktion neigt normalerweise dazu, "ungleiche Hash -Codes für Objekte zu generieren, auf die nicht warten wollen". Im Idealfall sollte die Hash -Funktion gleichmäßig Instanzen im Set verteilen, die nicht so weiter auf alle möglichen Hashes gehen möchten, aber es ist sehr schwierig, diese ideale Situation vollständig zu erreichen. Hier ist eine relativ einfache und effektive Hashing -Methode:
1. Speichern Sie einen konstanten Wert ungleich Null, wie 17, in einer Variablen vom Typ int als Ergebnis.
2. Führen Sie für jede Schlüsseldomäne F im Objekt ( in Bezug auf jede Domäne, die an der Equals -Methode beteiligt ist ) die folgenden Schritte aus:
result = 31 * result + c; Der Multiplikationsvorgang besteht darin, eine bessere Hash -Funktion zu erhalten. Wenn beispielsweise die Hash -Funktion der String -Multiplikation ausgelöst wird, haben alle Zeichenfolgen mit unterschiedlicher alphabetischer Reihenfolge denselben Hash -Code. Der Grund, warum 31 hier ausgewählt wird, ist, dass es sich um eine seltsame Primzahl handelt. Wenn der Multiplikator eine gleichmäßige Zahl und die Multiplikationsüberläufe ist, gehen die Informationen verloren, da sich die Multiplizierung mit 2 der Verschiebung entspricht. Die Vorteile der Verwendung von Primzahlen sind nicht offensichtlich, aber die Hash -Ergebnisse werden konventionell zur Berechnung der Hash -Ergebnisse verwendet. 31 hat ein gutes Merkmal, das heißt, die Verschiebung und Subtraktion anstelle der Multiplikation zu verwenden, was eine bessere Leistung erzielen kann: 31 * i == (i << 5) - i. Die heutigen VMs können diese Optimierung automatisch implementieren.Wenn eine Klasse unveränderlich ist (alle Domänen sind endgültige Modifikationen, und alle Domänen sind grundlegende Typen oder unveränderliche Klassen), und der Overhead der Berechnung von Hash -Codes ist ebenfalls relativ hoch, dann sollten Sie den Hash -Code innerhalb des Objekts untersuchen.
public class hashcodedemo {static class hashcodeclass {private endgültige boolean bresult; Private Final Byte ByteValue; privates Final Char Charvalue; privates endgültiges kurzes Shortvalue; private endgültige intValue; privates längeres langes Langstrecken; privates Final Float FloatValue; Privates Final Double Double Value; private endgültige String String String; Private Final Final INT [] ArrayValue; // flüchtig bedeutet, dass die Variable jedes Mal im Speicher gespeichert und abgerufen wird, um sicherzustellen, dass die Variable der neueste private volatile int Hashcode ist. 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) {// Setzen Sie einen Anfangswert ungleich Null, um den Konflikt des Null-Domänen-Int-Ergebniss zu erhöhen. // Wenn der Multiplikator weggelassen wird, haben alle Zeichenfolgen mit unterschiedlichen alphabetischen Reihenfolge denselben Hash -Code endgültig int hash_code = 31; result = Hash_code * Ergebnis + (Bresult? 1: 0); result = Hash_code * result + byteValue; result = Hash_Code * Ergebnis + charValue; result = Hash_code * Ergebnis + Shortvalue; result = hash_code * result + intvalue; result = hash_code * result + (int) (longvalue ^ (longvalue >>> 32)); result = hash_code * result + float.floattointbits (floatValue); langes doppelongValue = double.doubletolongbits (DoubleValue); result = Hash_Code * Ergebnis + (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ückgabeergebnis; } 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 ()); }}Ausgabe
str = com.demo.test.hashcodedemo $ hashcodeclass, str.hashcode = -205823051obj.hashcode = 946611167str = com.demo.test.hashcodedemo $ HashCodeclass, STR.HASHCODE=-205823051OBJ=com.demo.test.hashCodedemo$HashCodeclass@386c23df
Zusammenfassen
In dem oben genannten Artikel geht es um diesen Artikel, in dem die richtige Bewertungsmethode von Hashcode in Java erörtert wird, und ich hoffe, dass es für alle hilfreich sein wird. Interessierte Freunde können weiterhin auf andere verwandte Themen auf dieser Website verweisen. Wenn es Mängel gibt, hinterlassen Sie bitte eine Nachricht, um darauf hinzuweisen. Vielen Dank an Freunde für Ihre Unterstützung für diese Seite!