what is hashmap java
Este tutorial de HashMap Java explica o que é um HashMap em Java e como usá-lo. Inclui como declarar, inicializar, iterar, implementar e imprimir HashMap:
HashMap em Java é uma coleção baseada em Map e consiste em pares de valores-chave. Um HashMap é denotado por ou. Um elemento HashMap pode ser acessado usando uma chave, ou seja, devemos saber a chave para acessar o elemento HashMap.
Um HashMap usa uma técnica chamada “Hashing”. No hashing, uma string mais longa é convertida em uma string mais curta aplicando algum algoritmo ou 'função hash'. Uma string é convertida em uma string mais curta, pois ajuda na busca mais rápida. Ele também é usado para indexação eficiente.
=> Visite aqui a série exclusiva de tutoriais de treinamento em Java.
O que você aprenderá:
- HashMap em Java
- Mapa Java Vs HashMap
- Conclusão
HashMap em Java
Um HashMap é semelhante a HashTable, com a diferença de que o HashMap não é sincronizado e permite valores nulos para chave e valor.
Algumas das características importantes do HashMap são fornecidas abaixo:
- HashMap é implementado em Java na classe “Hashmap” que faz parte do pacote java.util.
- A classe HashMap herda da classe “AbstractMap”, que implementa parcialmente a interface Map.
- HashMap também implementa interfaces ‘clonáveis’ e ‘serializáveis’.
- HashMap permite valores duplicados, mas não permite chaves duplicadas. O HashMap também permite vários valores nulos, mas uma chave nula pode ser apenas uma.
- O HashMap não está sincronizado e também não garante a ordem dos elementos.
- A classe Java HashMap tem uma capacidade inicial de 16 e o fator de carga padrão (inicial) é 0,75.
Como declarar um HashMap em Java?
Um HashMap em Java é parte do pacote java.util. Portanto, se precisarmos usar HashMap em nosso código, primeiro precisamos importar a classe de implementação usando uma das seguintes instruções:
import java.util.*;
OU
import java.util.HashMap;
A declaração geral da classe HashMap é:
public class HashMap extends AbstractMap implements Map, Cloneable, Serializable
Aqui, K => tipo de chave presente no mapa
V => tipo de valores mapeados para as chaves no mapa
Crie um HashMap
Um HashMap em Java pode ser criado da seguinte maneira:
import java.util.HashMap; HashMap cities_map = new HashMap ();
A instrução acima inclui primeiro a classe HashMap em Java. Então, na próxima instrução, criamos um HashMap chamado ‘cities_map’ com o tipo de chave como Inteiro e Valores como String.
Depois que o HashMap é criado, precisamos inicializá-lo com valores.
Como inicializar o mapa de hash?
Podemos inicializar o HashMap usando o método put, colocando alguns valores no mapa.
O programa abaixo mostra a inicialização do HashMap em Java.
import java.util.*; class Main{ public static void main(String args[]){ //create a HashMap and print HashMap colorsMap=new HashMap(); System.out.println('Initial Map: '+colorsMap); //put some initial values into it using put method colorsMap.put(100,'Red'); colorsMap.put(101,'Green'); colorsMap.put(102,'Blue'); //print the HashMap System.out.println('After adding elements:'); for(Map.Entry m:colorsMap.entrySet()){ System.out.println(m.getKey()+' '+m.getValue()); } } }
Resultado:
Mapa inicial: {}
Depois de adicionar elementos:
100 rede
101 Green
102 Blue
Como um HashMap funciona internamente?
Sabemos que HashMap é uma coleção de pares de valores-chave e usa uma técnica chamada ‘Hashing’. Internamente, o HashMap é uma matriz de nós. O HashMap usa array e LinkedList para armazenar pares de valores-chave.
A seguir, está uma estrutura de um nó de HashMap que é representado programaticamente como uma classe.
Como visto na representação de nó acima, um nó tem uma estrutura semelhante a um nó de lista vinculada. Uma matriz desses nós é chamada de Bucket. Cada bucket pode não ter a mesma capacidade e pode ter mais de um nó também.
O desempenho do HashMap é influenciado por dois parâmetros:
(i) Capacidade Inicial: A capacidade é definida como o número de depósitos no HashMap. A capacidade inicial é definida como a capacidade do objeto HashMap quando ele é criado. A capacidade do HashMap é sempre multiplicada por 2.
(ii) LoadFactor: LoadFactor é o parâmetro que mede quando o rehashing - aumentando a capacidade, será feito.
Observe que, se a capacidade for alta, o fator de carga será pequeno, pois nenhum novo hashing será necessário. Da mesma forma, quando a capacidade é baixa, o fator de carga será alto, pois precisaremos refazer com frequência. Portanto, devemos ter cuidado ao escolher cuidadosamente esses dois fatores para projetar um hashMap eficiente.
Como iterar um HashMap?
O HashMap precisa ser percorrido para manipular ou imprimir os pares de valores-chave.
Existem duas maneiras pelas quais podemos percorrer ou iterar através do HashMap.
- Usando o loop for
- Usando o loop while e o iterador.
O programa Java abaixo mostra a implementação de ambos os métodos.
Primeiro, recuperamos o conjunto de entradas do HashMap usando o método entrySet e, em seguida, percorremos o conjunto usando o loop for. Em seguida, imprimimos os pares de valores-chave usando os métodos getKey () e getValue (), respectivamente.
Para percorrer o HashMap usando um loop while, primeiro definimos um iterador para o HashMap e, em seguida, acessamos os pares de valor-chave usando o iterador.
import java.util.*; public class Main{ public static void main(String [] args) { //create a HashMap and initialize it HashMap cities_map = new HashMap(); cities_map.put(10, 'MUM'); cities_map.put(1, 'DL'); cities_map.put(20, 'PUN'); cities_map.put(7, 'GOA'); cities_map.put(3, 'HYD'); //print using for loop System.out.println('HashMap using for Loop:'); System.out.println(' KEY VALUE'); for (Map.Entry mapSet : cities_map.entrySet()) { System.out.println(' '+mapSet.getKey() + ' ' + mapSet.getValue()); } //print using while loop with iterator System.out.println('HashMap using while Loop:'); System.out.println(' KEY VALUE'); Iterator iterator = cities_map.entrySet().iterator(); while (iterator.hasNext()) { Map.Entry mapSet2 = (Map.Entry) iterator.next(); System.out.println(' '+mapSet2.getKey() + ' ' + mapSet2.getValue()); } } }
Resultado:
HashMap usando for Loop:
VALOR CHAVE
1 DL
3 LONG
20 PUN
7 GOA
10 MUM
HashMap usando while Loop:
VALOR CHAVE
1 DL
3 LONG
20 PUN
7 GOA
10 MUM
Imprimir um Hash Map
Vamos ver outro exemplo de impressão do hashMap usando o loop foreach mostrado no programa abaixo.
import java.util.HashMap; public class Main { public static void main(String[] args) { // create a HashMap and initialize HashMap colors = new HashMap(); colors.put('Red', 1); colors.put('Orange', 5); colors.put('Magenta', 8); //print the HashMap System.out.println('HashMap contents:'); System.out.println(' KEY VALUE'); for (String i : colors.keySet()) { System.out.println(' ' + i + ' ' + colors.get(i)); } } }
Resultado:
Conteúdo do HashMap:
VALOR CHAVE
Rede 1
Magenta 8
Laranja 5
Construtor / métodos HashMap em Java
As tabelas a seguir mostram os construtores e métodos fornecidos pela classe HashMap em Java.
Construtores
Protótipo de Construtor | Descrição | |
---|---|---|
Ponha tudo | void putAll (mapa do mapa) | Insere elementos de 'mapa' especificados no HashMap. |
HashMap () | Construtor padrão. | |
HashMap (mapa m) | Cria um novo HashMap a partir do objeto de mapa m fornecido. | |
HashMap (capacidade interna) | Cria um novo HashMap com a capacidade inicial fornecida pelo argumento ‘capacidade’. | |
HashMap (capacidade interna, float loadFactor) | Cria um novo HashMap usando os valores de capacidade e loadFactor fornecidos pelo construtor. |
Métodos
Método | Protótipo de Método | Descrição |
---|---|---|
Claro | void clear () | Limpa todos os mapeamentos no HashMap |
está vazia | boolean isEmpty () | Verifica se o HashMap está vazio. Retorna verdadeiro se sim. |
clone | Clone de objeto () | Retorna uma cópia superficial sem clonar os mapeamentos de chaves e valores no HashMap. |
entrySet | Definir entrySet () | Retorna mapeamentos no HashMap como uma coleção |
conjunto de chaves | Definir keySet () | Retorna um conjunto de chaves no HashMap. |
por | V put (chave do objeto, valor do objeto) | Insere uma entrada de valor-chave no HashMap. |
putIfAbsent | V putIfAbsent (chave K, valor V) | Insere um determinado par de valores-chave no HashMap se ainda não estiver presente. |
retirar | V remover (chave do objeto) | Exclua uma entrada do HashMap para a chave fornecida. |
retirar | boolean remove (chave do objeto, valor do objeto) | Exclui o par de valores-chave fornecido do HashMap. |
calcular | V compute (chave K, BiFunction remappingFunction) | Calcula o mapeamento usando a ‘função de remapeamento’ para a chave fornecida e seu valor atual ou valor nulo. |
Método | Protótipo de Método | Descrição |
computeIfAbsent | V computeIfAbsent (tecla K, função mapeamentoFunção) | Calcula o mapeamento usando ‘mappingFunction’ e insere pares chave-valor se ainda não estiver presente ou for nulo. |
computeIfPresent | V computeIfPresent (chave K, BiFunction remappingFunction) | Calcula um novo mapeamento usando ‘remappingFunction’ dada a chave se a chave já estiver presente e não for nula. |
containsValue | boolean containsValue (valor do objeto) | Verifica se o valor fornecido existe no HashMap e retorna verdadeiro se sim. |
containsKey | boolean containsKey (chave do objeto) | Verifica se a chave fornecida está presente no HashMap e retorna verdadeiro se sim. |
é igual a | boolean equals (objeto o) | Compara determinado objeto com o HashMap. |
para cada | void forEach (ação BiConsumer) | Executa a 'ação' fornecida para cada uma das entradas no HashMap. |
obter | V get (chave do objeto) | Retorna o objeto que contém a chave fornecida com o valor associado. |
getOrDefault | V getOrDefault (chave do objeto, V defaultValue) | Retorna o valor para o qual a chave fornecida é mapeada. Se não mapeado, retorna o valor padrão. |
está vazia | boolean isEmpty () | Verifica se o HashMap está vazio. |
vai | V unir (chave K, valor V, função remapeamento BiFunction) | Verifica se a chave fornecida é nula ou não está associada ao valor e a associa a um valor não nulo usando remappingFunction. |
substituir | V substituir (chave K, valor V) | Substitui o valor fornecido pela chave especificada. |
substituir | boolean replace (chave K, V oldValue, V newValue) | Substitui o valor antigo da chave fornecida pelo novo valor |
substitua tudo | void replaceAll (função BiFunction) | Executa a função fornecida e substitui todos os valores no HashMap pelo resultado da função. |
valores | Valores de coleção () | Retorna a coleção de valores presentes no HashMap. |
Tamanho | tamanho interno () | Retorna o tamanho do número de entradas no HashMap. |
Implementação de Hashmap
A seguir, implementaremos a maioria dessas funções em um programa Java para entender melhor seu funcionamento.
O seguinte programa Java mostra uma implementação de HashMap em Java. Observe que usamos a maioria dos métodos que discutimos acima.
import java.util.*; public class Main { public static void main(String args[]) { HashMap hash_map = new HashMap(); hash_map.put(12, 'Leo'); hash_map.put(2, 'Seville'); hash_map.put(7, 'Lacy'); hash_map.put(49, 'Lily'); hash_map.put(3, 'Dillon'); System.out.println('HashMap contents:'); System.out.println(' KEY VALUE'); //display HashMap contents Set setIter = hash_map.entrySet(); Iterator map_iterator = setIter.iterator(); while(map_iterator.hasNext()) { Map.Entry map_entry = (Map.Entry)map_iterator.next(); System.out.println(' '+ map_entry.getKey() + ' ' + map_entry.getValue()); } //get value for the given key String var= hash_map.get(2); System.out.println('Value at index 2 is: '+var); //delete value given the key hash_map.remove(3); System.out.println('Hashmap after removal:'); System.out.println(' KEY VALUE'); Set iter_set = hash_map.entrySet(); Iterator iterator = iter_set.iterator(); while(iterator.hasNext()) { Map.Entry mentry = (Map.Entry)iterator.next(); System.out.println(' '+mentry.getKey() + ' ' + mentry.getValue() ); } } }
Resultado:
Conteúdo do HashMap:
VALOR CHAVE
49 Lily
2 Sevilha
3 dillon
7 Lacy
12 Leo
O valor no índice 2 é: Sevilha
Hashmap após remoção:
VALOR CHAVE
49 Lily
2 Sevilha
7 Lacy
12 Leo
Classificar HashMap em Java
Em Java, o HashMap não preserva a ordem. Portanto, precisamos classificar os elementos no HashMap. Podemos classificar os elementos no HashMap com base em chaves ou valores. Nesta seção, discutiremos as duas abordagens de classificação.
Classificar HashMap por chaves
import java.util.*; public class Main { public static void main(String[] args) { //create and initialize a HashMap HashMap colors_map = new HashMap(); colors_map.put(9, 'Magenta'); colors_map.put(11, 'Yellow'); colors_map.put(7, 'Cyan'); colors_map.put(23, 'Brown'); colors_map.put(5, 'Blue'); colors_map.put(3, 'Green'); colors_map.put(1, 'Red'); //print the unsorted HashMap by getting a set and using iterator System.out.println('Unsorted HashMap:'); Set set = colors_map.entrySet(); Iterator iterator = set.iterator(); while(iterator.hasNext()) { Map.Entry me = (Map.Entry)iterator.next(); System.out.print(me.getKey() + ': '); System.out.println(me.getValue()); } //create a treemap from given HashMap so that the keys are sorted Map map = new TreeMap(colors_map); System.out.println('HashMap Sorted on keys:'); //print the sorted HashMap Set set2 = map.entrySet(); Iterator iterator2 = set2.iterator(); while(iterator2.hasNext()) { Map.Entry me2 = (Map.Entry)iterator2.next(); System.out.print(me2.getKey() + ': '); System.out.println(me2.getValue()); } } }
Resultado:
HashMap não classificado:
1: rede
3: verde
5: azul
7: ciano
23: marrom
9: Magenta
11: amarelo
HashMap classificado nas chaves:
1: rede
3: verde
5: azul
7: ciano
9: Magenta
11: amarelo
23: marrom
empresas que pagam você para testar seus produtos
No programa acima, vemos que uma vez que o hashmap é definido e preenchido com valores, criamos um mapa de árvore a partir desse hashmap. Conforme o hashmap é convertido em um mapa de árvore, suas chaves são classificadas automaticamente. Assim, quando exibimos este mapa de árvore, obtemos o mapa classificado em chaves.
Classificar HashMap por valores
Para classificar um HashMap de acordo com os valores, primeiro convertemos o hashmap em um LinkedList. Em seguida, usamos o método Collections.sort junto com o comparador para classificar a lista. Essa lista é então convertida de volta para HashMap. O HashMap classificado é então impresso.
import java.util.*; public class Main { public static void main(String[] args) { //Create and initialize the HashMap HashMap colors_map = new HashMap(); colors_map.put(5, 'B'); colors_map.put(11, 'O'); colors_map.put(3, 'I'); colors_map.put(13, 'R'); colors_map.put(7, 'G'); colors_map.put(1, 'V'); colors_map.put(9, 'Y'); //print the HashMap using iterator after converting to set System.out.println('Unsorted HashMap:'); Set set = colors_map.entrySet(); Iterator iterator = set.iterator(); while(iterator.hasNext()) { Map.Entry map_entry = (Map.Entry)iterator.next(); System.out.print(map_entry.getKey() + ': '); System.out.println(map_entry.getValue()); } //call sortByValues method that returns a sorted Map. Map c_map = sortByValues(colors_map); System.out.println('HashMap sorted on values:'); //print the sorted HashMap Set set2 = c_map.entrySet(); Iterator iterator2 = set2.iterator(); while(iterator2.hasNext()) { Map.Entry map_entry2 = (Map.Entry)iterator2.next(); System.out.print(map_entry2.getKey() + ': '); System.out.println(map_entry2.getValue()); } } private static HashMap sortByValues(HashMap hash_map) { //create a LinkedList from HashMap List list = new LinkedList(hash_map.entrySet()); // use Collections.sort method with Comparator to sort the list Collections.sort(list, new Comparator() { public int compare(Object o1, Object o2) { return ((Comparable) ((Map.Entry) (o1)).getValue()) .compareTo(((Map.Entry) (o2)).getValue()); } }); //create a HashMap from linkedlist which preserves the order HashMap sortedHashMap = new LinkedHashMap(); for (Iterator it = list.iterator(); it.hasNext();) { Map.Entry entry = (Map.Entry) it.next(); sortedHashMap.put(entry.getKey(), entry.getValue()); } return sortedHashMap; } }
Resultado:
HashMap não classificado:
1: V
3: eu
5: B
7: G
9: e
11: O
13: R
HashMap classificado em valores:
5: B
7: G
3: eu
11: O
13: R
1: V
9: e
HashMap simultâneo em Java
No HashMap normal, não poderemos modificar os elementos em tempo de execução ou enquanto a iteração estiver sendo realizada.
A implementação de um mapa concorrente é mostrada abaixo:
import java.util.*; import java.util.concurrent.ConcurrentHashMap; public class Main { public static void main(String[] args) { //declare and initialize ConcurrentHashMap Map cCMap = new ConcurrentHashMap(); cCMap.put('1', '10'); cCMap.put('2', '10'); cCMap.put('3', '10'); cCMap.put('4', '10'); cCMap.put('5', '10'); cCMap.put('6', '10'); //print the initial ConcurrentHashMap System.out.println('Initial ConcurrentHashMap: '+cCMap); //define the iterator over the keys of ConcurrentHashMap Iterator it = cCMap.keySet().iterator(); //change one of the keys using iterator while(it.hasNext()){ String key = it.next(); if(key.equals('3')) cCMap.put(key+'c_map', 'c_map'); } //print the changed ConcurrentHashMap System.out.println('
ConcurrentHashMap after iterator: '+cCMap); } }
Resultado:
ConcurrentHashMap inicial: {1 = 10, 2 = 10, 3 = 10, 4 = 10, 5 = 10, 6 = 10}
ConcurrentHashMap após o iterador: {1 = 10, 2 = 10, 3 = 10, 4 = 10, 5 = 10, 6 = 10, 3c_map = c_map}
Observe que, se tivéssemos realizado a mesma operação com HashMap, ele teria gerado ConcurrentModificationException.
Mapa Java Vs HashMap
Vamos tabularizar algumas das diferenças entre Map e HashMap em Java.
Mapa | HashMap |
---|---|
É uma interface abstrata. | É uma implementação da interface Map. |
A interface precisa ser implementada por outras classes para que sua funcionalidade esteja disponível. | É uma classe concreta e os objetos de classe podem ser criados para obter a funcionalidade. |
A implementação da interface do mapa como TreeMap não permite valores nulos. | Permite valores nulos e chaves. |
TreeMap não permite valores duplicados. | Ele pode ter valores duplicados. |
Uma ordem natural de objetos é mantida. | Nenhuma ordem de entrada é mantida no HashMap. |
perguntas frequentes
P # 1) Por que o HashMap é usado em Java?
Responda: HashMap, sendo a coleção de pares de valores-chave, auxilia na pesquisa de dados com base apenas na chave. Além disso, ao usar técnicas de hashing, ele fornece uma pesquisa eficiente de dados.
Q # 2)Como você cria um mapa hash?
Responda: Um HashMap pode ser criado instanciando a classe ‘HashMap’ do pacote java.util. Um hashMap com chaves do tipo inteiro e valores do tipo string pode ser criado da seguinte maneira:
HashMap myMap= new HashMap();
Q # 3)O HashMap é ordenado em Java?
Responda: Não, o HashMap não é ordenado em Java. Ele não é usado em Java para esse propósito, mas é usado para armazenar elementos em pares de chave-valor.
Q # 4)O HashMap é seguro para threads?
Responda: NÃO, o hashMap não é seguro para thread em Java.
Q # 5)Qual é o HashMap ou o ConcurrentHashMap mais rápido?
Responda: HashMap é mais rápido que ConcurrentHashMap. O motivo é que o HashMap normalmente opera em apenas um thread, portanto, seu desempenho é bom. O HashMap simultâneo, entretanto, como o nome sugere, é simultâneo e pode funcionar simultaneamente em vários threads.
Conclusão
Neste tutorial, entendemos o funcionamento do HashMap junto com outra variação do HashMap chamada ConcurrentHashMap. Vimos construtores, métodos e exemplos de HashMap. Também discutimos ConcurrentHashMap junto com seu exemplo.
Em nossos próximos tutoriais, aprenderemos mais sobre coleções Java.
=> Verifique aqui para ver A-Z dos tutoriais de treinamento de Java aqui.
Leitura recomendada
- LinkedHashMap em Java - Exemplo e implementação de LinkedHashMap
- Tutorial JAVA para iniciantes: mais de 100 tutoriais práticos em vídeo Java
- TreeMap em Java - Tutorial com exemplos de TreeMap em Java
- O que é Java Vector | Tutorial da classe Java Vector com exemplos
- Java String contains () Tutorial de método com exemplos
- Como classificar uma matriz em Java - Tutorial com exemplos
- Jagged Array In Java - Tutorial com exemplos
- Tutorial da classe Java Scanner com exemplos