Como usar o hashmap em java

Antes de saber como usar um hashmap em java, o leitor precisa saber o que é um hashmap. Considere os seguintes pares de frutas de chave/valores e suas cores: Apple vermelho => vermelho
Banana => amarelo
limão => amarelo pálido
cal => verde amarelo
Kivi => verde
Abacate => verde
Uva => roxo
Fig => roxo
=> - - - - -
=> - - - - -
=> - - - - -

A coluna à esquerda tem as chaves, e a coluna à direita tem os valores correspondentes. Observe que os frutos, kivi e abacate têm a mesma cor, verde. Além disso, as frutas, uvas e figos têm a mesma cor, roxa. No final da lista, três locais estão esperando por suas próprias cores. Esses locais não têm frutas correspondentes; Em outras palavras, esses três locais não têm chaves correspondentes.

Todos os locais, preenchidos ou não, à direita, são chamados de baldes. Para cada valor, há uma chave. As chaves são únicas. Os valores não precisam ser únicos. Este é um relacionamento muitos para um.

O que é armazenado na tabela é a coluna certa. Isto é, o que é armazenado na tabela são os valores. As chaves não precisam ser armazenadas. A chave é enviada como um argumento para uma função chamada uma função de hash para chegar a um valor. A função hash produz o índice correspondente que está associado a um valor específico.

Qualquer estrutura que se adapte a todas as descrições acima é chamada de hash. Com o hashmap em java, as chaves são de um tipo de objeto, e os valores são de outro tipo de objeto. Pode haver uma chave nula, e pode haver mais de um valor nulo.

O tamanho de um hashmap é o número de pares de chave/valor (entradas). A capacidade de um hashmap é o número de baldes, preenchidos ou não. A capacidade deve sempre ser maior que o tamanho.

Com a introdução acima, o leitor agora pode aprender a usar um hashmap em java.

Conteúdo do artigo

• Construção
• Incluindo pares de chave/valor
• Tamanho do hashmap
• Lendo o hashmap
• Modificando o hashmap
• Conclusão

Construção

O hashmap é uma classe a partir da qual um objeto de hashmap pode ser criado. Criar um objeto de uma classe é construir o objeto. Existem 4 maneiras de construir um hashmap em java.

Fator de carga

O fator de carga é o número de pares de chave/valor divididos pelo número de baldes.

Hashmap ()

Este método construtor criaria um hashmap de capacidade 16 e do fator de carga 0.75. Isso significa que o número de baldes será 16 (e vazio), e o fator de carga padrão é 0.75. Após a criação do hashmap, os pares de chave/valor serão incluídos. Nesse caso, quando o número de pares de chave/valor atinge 12, em 12/16 = 0.75, o hashmap será reformulado automaticamente. Isso significa que aumentará automaticamente o número de baldes para 32 (duplicação). O código a seguir mostra como criar um objeto de hashmap usando este construtor:

importar java.util.*;
classe TheClass
public static void main (string [] args)
Hashmap hm = new hashmap ();

A classe Hashmap está em Java.pacote Util. Para este código, as chaves seriam cordas e os valores também seriam strings.

HashMap (int InitialCapacity)

Isso permite que o programador comece com uma capacidade diferente, mas ainda com um fator de carga de 0.75. Ilustração:

importar java.util.*;
classe TheClass
public static void main (string [] args)
Hashmap hm = novo hashmap (20);

Então, o objeto Hasmap aqui começa com 20 baldes vazios. Aqui as chaves são inteiros. Eles diferem dos índices de matriz no sentido de que o primeiro índice não é necessariamente zero. Além disso, os índices não são contíguos. Por exemplo, o primeiro índice talvez 20; o próximo é 35, aquele depois de 52, etc.

Nota: Com o hashmap, a ordem dos pares de chave/valor não é mantida. Ou seja, se um conjunto de pares de chave/valor estiver incluído em uma ordem, ao exibir o conteúdo, o pedido será diferente, embora todos os pares de chave/valor incluídos ainda estejam lá.

Os pares de chave/valor para o hashmap são mais bem chamados de mapeamentos.

HashMap (int InitialCapacity, Float LoadFactor)

Aqui, o fator de carga também é citado. O fator de carga é um tipo de flutuação e não um tipo inteiro. Aqui, um fator de carga diferente de 0.75 é citado. Existem vantagens e desvantagens em ter um fator de carga que difere de 0.75 - Veja mais tarde. Ilustração:

importar java.util.*;
classe TheClass
public static void main (string [] args)
Hashmap hm = novo hashmap (20,0.62f);

Observe o uso de 'f' como o sufixo para o fator de carga.

Hashmap (mapa m)
Este construtor criará um hashmap a partir de um mapa que já existe - veja mais tarde.

Incluindo pares de chave/valor

Put (K -Key, V Valor)
Este método relaciona um valor específico a uma chave específica. A chave é realmente hash em um índice que está diretamente associado ao valor. No entanto, é o programador ou usuário que decide sobre o valor e sua chave. O exemplo a seguir cria um hasmap, hm e inclui todos os pares de chave/valor e os baldes vazios de cima:

importar java.util.*;
classe TheClass
public static void main (string [] args)
Hashmap hm = novo hashmap (11);
HM.put ("maçã vermelha", "vermelha");
HM.put ("banana", "amarelo");
HM.put ("limão", "amarelo pálido");
HM.put ("limão", "verde amarelo");
HM.put ("kivi", "verde");
HM.put ("abacate", "verde");
HM.put ("uva", "roxo");
HM.put ("fig", "roxo");

A capacidade é 11. O número de pares de chave/valor é 8. Isso significa que o tamanho é 8. Portanto, o fator de carga efetivo é 8/11 = 0.73f. O número de baldes vazios é 11 - 8 = 3.

Putifabsent (K -Key, V Valor)
Isso inclui o par de chaves/valor se a chave ainda não existir no hashmap. Nesse caso, o valor de retorno é nulo. Se a chave já existir, nada muda, e o valor antigo da chave é retornado. Se o código a seguir for adicionado à parte inferior do código acima (em main ()), a saída será nula:

String v = hm.putifabsent ("melancia", "verde");
Sistema.fora.println (v);

Nota: Put (Key K, Valor V) deslocaria o par de chave/valor para a chave em questão que já está lá, efetivamente fornecendo um novo valor para a chave.

Tamanho do hashmap

O tamanho do hashmap é o número de pares de chave/valor.

tamanho()
A declaração a seguir retornará o tamanho do hashmap:

int sz = hm.tamanho();

está vazia()
Este método, retorna true se o hashmap não contiver mapeamentos de valor-chave, ou false caso contrário. Exemplo:

Booleano BL = HM.está vazia();
Sistema.fora.println (bl);

Um hashmap vazio pode ter baldes vazios.

Lendo o hashmap

Get (chave do objeto)
Retorna (copia) o valor correspondente à chave; ou retorna nulo se não houver valor correspondente. Exemplo:

String str = hm.obtenha ("banana");
Sistema.fora.println (str);

ContainsKey (chave do objeto)
Retorna verdadeiro se houver um mapeamento para essa chave em particular; falso caso contrário. Exemplo:

Booleano BL = HM.ContainsKey ("banana");

contém valores (valor do objeto)
Retorna true se houver um mapeamento para esse valor; falso caso contrário. Exemplo:

Booleano BL = HM.contém valores ("verde");

conjunto de chaves()
Este método retorna todas as chaves dos pares de chave/valor. Exemplo Código:

Definir st = hm.conjunto de chaves();
para (String Val: ST)
Sistema.fora.impressão (val + ",");
Sistema.fora.println ();

Observe que o objeto de retorno é um conjunto. Se o hashmap original acima for usado, a saída seria:

limão, kivi, fig, uva, limão, abacate, maçã vermelha, banana,

Observe que a ordem não é a ordem em que as chaves foram incluídas.

valores ()
Este método retorna uma coleção de todos os valores no hashmap. Exemplo Código:

Coleção Cl = HM.valores ();
para (String Val: Cl)
Sistema.fora.impressão (val + ",");
Sistema.fora.println ();

Observe que o objeto de retorno é uma coleção. Se o hashmap original acima for usado, a saída seria:

amarelo pálido, verde, roxo, roxo, amarelo verde, verde, vermelho, amarelo,

Observe que a ordem não é a ordem em que os valores foram incluídos.

Entryset ()
Isso retorna todos os pares de chave/valor, mas o programador precisa separar cada tecla de seu valor correspondente. Exemplo Código:

Definir STM = HM.entrada de entrada ();
para (mapa.Entrada KV: STM)
Sistema.fora.println (kv.getKey () + "=>" + kV.Obter valor());

Se o hashmap original acima for usado, a saída seria:

limão => amarelo pálido
Kivi => verde
Fig => roxo
Uva => roxo
cal => verde amarelo
Abacate => verde
Apple vermelho => vermelho
Banana => amarelo

Observe que a ordem não é a ordem em que os pares de chave/valor foram incluídos.

Modificando o hashmap

Put (K -Key, V Valor)
O método put () é semelhante ao método putifabsent (), pois se a chave já existir, o valor antigo será retornado e, se a chave ainda não existir, o nulo será retornado. Não se esqueça que o put () substitui o valor antigo se a chave já existir. Se a chave ainda não existir, put () inclui a nova entrada (par de chaves/valores).

Substitua (Key K, Valor V)
Para uma chave que já está em vigor, esse método é usado para substituir o valor da chave correspondente. O hashmap é uma estrutura muitos para um. Um código de exemplo para o hashmap acima é:

String v = hm.substituir ("banana", "branco");
Sistema.fora.println (v);
String str = hm.obtenha ("banana");
Sistema.fora.println (str);

A saída é:

amarelo
branco

O método replate () retorna o valor antigo. Se a chave não existir, ele retorna nulo e nada será substituído.

Substitua (K -Key, V OldValue, V NewValue)
Isso permite a substituição de um valor específico que o programador está ciente. Ele retorna verdadeiro se tivesse sucesso e falso se não. Exemplo Código para o objeto Hashmap acima é:

Booleano BL = HM.substituir ("uva", "roxo", "marrom");
Sistema.fora.println (bl);

Remover (chave do objeto)
Isso remove o par de chave/valor mapeado pela chave. Retorna o valor correspondente removido. Ele retorna nulo se a chave não estiver presente. O código de exemplo para o hashmap acima é:

String v = hm.remover ("banana");
Sistema.fora.println (v);

Remover (chave do objeto, valor do objeto)
Isso permite a remoção de uma entrada (par de chaves/valores) para um valor específico que o programador está ciente. Ele retorna verdadeiro se tivesse sucesso e falso se não. Exemplo Código para o objeto Hashmap acima é:

Booleano BL = HM.remover ("abacate", "verde");
Sistema.fora.println (bl);

Conclusão

Uma matriz pode ser considerada um mapeamento de índices para valores (de um tipo específico). Um hashmap deve ser usado quando o mapeamento de um tipo de objeto para outro tipo de objeto for necessário. Dessa maneira, existem pares de chave/valor. Um hash é uma estrutura de dados em que o número de valores é limitado, mas o número de teclas possíveis é mais do que o número de valores possíveis. E então as chaves precisam ser hashed para chegar aos valores. Java Hashmap por sua função implícita de hash foi apresentada acima. O programador pode escrever sua própria função de hash (mapeamento). No entanto, esse é um tópico para algum outro momento.

Chrys