El contenido principal de este artículo es el método de evaluación correcto de hashcode en Java, de la siguiente manera.
Hay una optimización para las listas hash que pueden almacenar en caché el código hash del objeto. Si el código hash no coincide, no verificará la equivalencia del objeto y lo considerará directamente como un objeto diferente. Si el código hash (hashcode) es igual, detectará si los objetos son iguales.
Si los objetos tienen el mismo código hash (hashcode), se asignan al mismo cubo hash. Si el choque de todos los objetos en la lista de Hashlist es el mismo, la lista de hash degenerará en una lista vinculada, lo que reduce en gran medida su eficiencia de consulta.
Una buena función hash generalmente tiende a "generar códigos hash desiguales para objetos que no quieren estar esperando". Idealmente, la función hash debería distribuir uniformemente instancias en el conjunto que no quieran estar así en todos los hashes posibles, pero es muy difícil lograr completamente esta situación ideal. Aquí hay un método de hashing relativamente simple y efectivo:
1. Guarde un valor constante no cero, como 17, en una variable de tipo int llamada resultado.
2. Para cada dominio clave F en el objeto ( refiriéndose a cada dominio involucrado en el método igual ), complete los siguientes pasos:
result = 31 * result + c; La operación de multiplicación es obtener una mejor función hash. Por ejemplo, si la función hash de la cadena omite la multiplicación, entonces todas las cadenas con un orden alfabético diferente tendrán el mismo código hash. La razón por la que se elige 31 aquí es porque es un número primo impar. Si el multiplicador es un número uniforme y la multiplicación se desborda, la información se perderá porque multiplicar con 2 es equivalente al desplazamiento. Los beneficios del uso de números primos no son obvios, pero los resultados del hash se utilizan convencionalmente para calcular los resultados hash. 31 tiene una buena característica, es decir, usar Shift y Resta en lugar de multiplicación, lo que puede lograr un mejor rendimiento: 31 * i == (i << 5) - i. Las máquinas virtuales de hoy pueden implementar automáticamente esta optimización.Si una clase es inmutable (todos los dominios son modificaciones finales, y todos los dominios son tipos básicos o son clases inmutables), y la sobrecarga de calcular los códigos hash también es relativamente alto, entonces debe considerar la caché del código hash dentro del objeto.
clase pública Hashcodedemo {clase estática HashCodeClass {private final Boolean Bresult; Private Final Final Byte Bytevalue; Private Final Char Charvalue; Valor de cortocircuito final privado; Private Final Int Value; Valor largo de larga duración privada; Valor flotante final privado; Valor doble doble privado final final; Cadena final privada final Str; Private final final int [] ArrayValue; // Volátil significa que la variable se almacena y se recupera en la memoria cada vez para garantizar que la variable sea el último intento de hashcode privado volátil; public HashCodeClass () {Bresult = false; bytevalue = 1; charvalue = 'a'; Valor de corto = 1; intValue = 1; Valor largo = 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) {// Establecer un valor inicial distinto de cero para aumentar el conflicto del dominio cero int result = 17; // Si se omite el multiplicador, todas las cadenas con un orden alfabético diferente tendrán el mismo código hash final int hash_code = 31; resultado = hash_code * resultado + (Bresult? 1: 0); resultado = hash_code * resultado + byteValue; resultado = hash_code * resultado + charvalue; resultado = hash_code * result + shortValue; resultado = hash_code * resultado + intValue; resultado = hash_code * resultado + (int) (longValue ^ (longValue >>> 32)); resultado = hash_code * resultado + float.floatTointBits (floatValue); Long DoubleLongValue = double.Doubletolongbits (DoubleValue); resultado = hash_code * resultado + (int) (doubleLongValue ^ (doubleLongValue >>> 32)); resultado = hash_code * resultado + (str == null? 0: str.hashcode ()); System.out.println ("str =" + str + ", str.hashcode =" + str.hashcode ()); resultado = hash_code * resultado + arrayValue.hashcode (); resultado de retorno; } 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 ()); }}Producción
str = com.demo.test.hashcodedemo $ hashcodeclass, str.hashcode = -2055823051obj.hashcode = 946611167str = com.demo.test.hashcodedemo $ hashcodeclass, str.hashcode=-205823051obj=com.demo.test.hashcodedemo$hashcodeclass@386c23df
Resumir
Lo anterior tiene que ver con este artículo que discute el método de evaluación correcto de hashcode en Java, y espero que sea útil para todos. Los amigos interesados pueden continuar referiéndose a otros temas relacionados en este sitio. Si hay alguna deficiencia, deje un mensaje para señalarlo. ¡Gracias amigos por su apoyo para este sitio!