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:
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!