Uma breve discussão sobre o método de avaliação correto do HashCode em Java

O principal conteúdo deste artigo é o método de avaliação correto do HashCode em Java, como segue.

Há uma otimização para listas de hash que podem cache o código de hash do objeto. Se o código hash não corresponder, ele não verificará a equivalência do objeto e considerará diretamente um objeto diferente. Se o código hash (HashCode) for igual, ele detectará se os objetos são iguais.

Se os objetos tiverem o mesmo código de hash (HashCode), eles serão mapeados para o mesmo balde de hash. Se o código de hash de todos os objetos na hashlist for o mesmo, a hashlist degenerará em uma lista vinculada, o que reduz bastante sua eficiência de consulta.

Uma boa função de hash geralmente tende a "gerar códigos de hash desiguais para objetos que não querem esperar". Idealmente, a função de hash deve distribuir uniformemente instâncias no conjunto que não querem ser assim por todos os hashes possíveis, mas é muito difícil alcançar totalmente essa situação ideal. Aqui está um método de hash relativamente simples e eficaz:

1. Economize um valor constante diferente de zero, como 17, em uma variável de tipo int chamada resultado.

2. Para cada domínio -chave f no objeto ( referindo -se a cada domínio envolvido no método igual ), complete as seguintes etapas:

• Calcule o código de hash do tipo int para este campo
• Se o campo é do tipo booleano, então (F? 1: 0)
• Se o campo for de tipo byte, char, curto ou int, então ((int) f)
• Se o campo for do tipo longo, então (int) (f ^ (f >>> 32))
• Se o campo for do tipo flutuante, então float.floattointbits (f) é calculado
• Se o campo for do tipo duplo, calcule o dobro.DoubleTolongBits (f) e calcule o valor do hash para o valor longo do tipo longo obtido de acordo com as etapas acima.
• Se o domínio for uma referência de objeto e o método igual da classe compara seu domínio chamando de forma igual, o HashCode também será chamado recursivamente de acordo com o método acima para esse domínio.
• Se o campo for uma matriz, cada elemento deve ser processado como um campo separado e os princípios acima devem ser aplicados recursivamente. Se cada elemento na matriz for importante, você também poderá usar diretamente o método ARRAYS.HASHCODE.
• De acordo com a fórmula a seguir, o Código C HASH obtido nas etapas acima é mesclado em resultado em sequência: result = 31 * result + c; A operação de multiplicação é obter uma melhor função de hash. Por exemplo, se a função de hash da String omitter a multiplicação, todas as seqüências com ordem alfabética diferentes terão o mesmo código de hash. A razão pela qual 31 é escolhida aqui é porque é um número primo estranho. Se o multiplicador for um número par e a multiplicação transborda, as informações serão perdidas porque multiplicar com 2 é equivalente ao deslocamento. Os benefícios do uso de números primos não são óbvios, mas os resultados de hash são usados ​​convencionalmente para calcular os resultados do hash. 31 tem um bom recurso, ou seja, usando turno e subtração em vez de multiplicação, que pode obter melhor desempenho: 31 * i == (i << 5) - i. As VMs de hoje podem implementar automaticamente essa otimização.

Se uma classe for imutável (todos os domínios são modificações finais e todos os domínios são tipos básicos ou são classes imutáveis), e a sobrecarga do cálculo dos códigos de hash também é relativamente alta, considere o cache o código de hash dentro do objeto.

 classe pública hashcodedemo {classe estática hashcodeclass {private final boolean bresult; byte final final de byte final privado; Charvalue final final privado; curto -curto final privado; private final int intvalue; Private final Long LongValue; Float FloatValue final privado; DoubleValue duplo final privado; string final final privada str; Private Final Int [] ArrayValue; // volátil significa que a variável é armazenada e recuperada na memória sempre para garantir que a variável seja o mais recente hashcode volátil privado; 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) {// Defina um valor inicial diferente de zero para aumentar o conflito do domínio zero int resultado = 17; // Se o multiplicador for omitido, todas as cordas com ordem alfabética diferentes terão o mesmo código de 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 * resultado + shortValue; resultado = hash_code * resultado + intvalue; resultado = hash_code * resultado + (int) (longValue ^ (longValue >>> 32)); resultado = hash_code * resultado + float.floattointbits (floatValue); DoublelongValue longo = duplo.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; } retornar hashCode; }} public static void main (string [] args) {hashcodeclass obj = new hashcodeclass (); System.out.println ("obj.hashcode =" + obj.hashcode ()); System.out.println ("obj ="+obj.toString ()); }}

Saída

 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

Resumir

O exposto acima é sobre este artigo discutindo o método de avaliação correto do HashCode em Java, e espero que seja útil para todos. Amigos interessados ​​podem continuar se referindo a outros tópicos relacionados neste site. Se houver alguma falha, deixe uma mensagem para apontá -la. Obrigado amigos pelo seu apoio para este site!