Java HashMap
Java HashMap
Neste tutorial, aprenderemos sobre a classe Java HashMap e suas diversas operações com a ajuda de exemplos.
O HashMap A classe da estrutura de coleções Java fornece a funcionalidade da estrutura de dados da tabela de hash.
Ele armazena elementos em chave/valor pares. Aqui, chaves são identificadores exclusivos usados para associar cada valor em um mapa.
O HashMap A classe implementa a interface Map.
Criar um HashMap
Para criar um mapa de hash, devemos importar o java.util.HashMap pacote primeiro. Depois de importar o pacote, veja como podemos criar hashmaps em Java.
// hashMap creation with 8 capacity and 0.6 load factor
HashMap<K, V> numbers = new HashMap<>();
No código acima, criamos um hashmap chamado numbers . Aqui, K representa o tipo de chave e V representa o tipo de valores. Por exemplo,
HashMap<String, Integer> numbers = new HashMap<>();
Aqui, o tipo de chaves é String e o tipo de valores é Integer .
Exemplo 1:Criar HashMap em Java
import java.util.HashMap;
class Main {
public static void main(String[] args) {
// create a hashmap
HashMap<String, Integer> languages = new HashMap<>();
// add elements to hashmap
languages.put("Java", 8);
languages.put("JavaScript", 1);
languages.put("Python", 3);
System.out.println("HashMap: " + languages);
}
}
Saída
HashMap: {Java=8, JavaScript=1, Python=3}
No exemplo acima, criamos um HashMap chamados idiomas .
Aqui, usamos o put() método para adicionar elementos ao hashmap. Aprenderemos mais sobre o put() método mais adiante neste tutorial.
Operações básicas no Java HashMap
O HashMap A classe fornece vários métodos para realizar diferentes operações em hashmaps. Veremos algumas operações de arraylist comumente usadas neste tutorial:
1. Adicionar elementos a um HashMap
Para adicionar um único elemento ao hashmap, usamos o put() método do HashMap classe. Por exemplo,
import java.util.HashMap;
class Main {
public static void main(String[] args) {
// create a hashmap
HashMap<String, Integer> numbers = new HashMap<>();
System.out.println("Initial HashMap: " + numbers);
// put() method to add elements
numbers.put("One", 1);
numbers.put("Two", 2);
numbers.put("Three", 3);
System.out.println("HashMap after put(): " + numbers);
}
}
Saída
Initial HashMap: {}
HashMap after put(): {One=1, Two=2, Three=3}
No exemplo acima, criamos um HashMap chamados números . Aqui, usamos o put() método para adicionar elementos aos números.
Observe a afirmação,
numbers.put("One", 1);
Aqui, estamos passando o String valor Um como a chave e Integer valor 1 como o valor para put() método.
Leituras recomendadas
2. Acessar Elementos do HashMap
Podemos usar o get() método para acessar o valor do hashmap. Por exemplo,
import java.util.HashMap;
class Main {
public static void main(String[] args) {
HashMap<Integer, String> languages = new HashMap<>();
languages.put(1, "Java");
languages.put(2, "Python");
languages.put(3, "JavaScript");
System.out.println("HashMap: " + languages);
// get() method to get value
String value = languages.get(1);
System.out.println("Value at index 1: " + value);
}
}
Saída
HashMap: {1=Java, 2=Python, 3=JavaScript}
Value at index 1: Java
No exemplo acima, observe a expressão,
languages.get(1);
Aqui, o get() método pega a chave como seu argumento e retorna o valor correspondente associado à chave.
Também podemos acessar as chaves , valores e chave/valor pares do hashmap como visualizações definidas usando keySet() , values() e entrySet() métodos respectivamente. Por exemplo,
import java.util.HashMap;
class Main {
public static void main(String[] args) {
HashMap<Integer, String> languages = new HashMap<>();
languages.put(1, "Java");
languages.put(2, "Python");
languages.put(3, "JavaScript");
System.out.println("HashMap: " + languages);
// return set view of keys
// using keySet()
System.out.println("Keys: " + languages.keySet());
// return set view of values
// using values()
System.out.println("Values: " + languages.values());
// return set view of key/value pairs
// using entrySet()
System.out.println("Key/Value mappings: " + languages.entrySet());
}
}
Saída
HashMap: {1=Java, 2=Python, 3=JavaScript}
Keys: [1, 2, 3]
Values: [Java, Python, JavaScript]
Key/Value mappings: [1=Java, 2=Python, 3=JavaScript]
No exemplo acima, criamos um hashmap chamado languages . Aqui, estamos acessando as chaves , valores e chave/valor mapeamentos do hashmap.
Leituras recomendadas
3. Alterar valor do HashMap
Podemos usar o replace() método para alterar o valor associado a uma chave em um hashmap. Por exemplo,
import java.util.HashMap;
class Main {
public static void main(String[] args) {
HashMap<Integer, String> languages = new HashMap<>();
languages.put(1, "Java");
languages.put(2, "Python");
languages.put(3, "JavaScript");
System.out.println("Original HashMap: " + languages);
// change element with key 2
languages.replace(2, "C++");
System.out.println("HashMap using replace(): " + languages);
}
}
Saída
Original HashMap: {1=Java, 2=Python, 3=JavaScript}
HashMap using replace(): {1=Java, 2=C++, 3=JavaScript}
No exemplo acima, criamos um hashmap chamado languages . Observe a expressão,
languages.replace(2, "C++");
Aqui, estamos alterando o valor referido pela chave 2 com o novo valor C++ .
O HashMap também fornece algumas variações do replace() método. Para saber mais, acesse
4. Remover elementos do HashMap
Para remover elementos de um hashmap, podemos usar o método remove(). Por exemplo,
import java.util.HashMap;
class Main {
public static void main(String[] args) {
HashMap<Integer, String> languages = new HashMap<>();
languages.put(1, "Java");
languages.put(2, "Python");
languages.put(3, "JavaScript");
System.out.println("HashMap: " + languages);
// remove element associated with key 2
String value = languages.remove(2);
System.out.println("Removed value: " + value);
System.out.println("Updated HashMap: " + languages);
}
}
Saída
HashMap: {1=Java, 2=Python, 3=JavaScript}
Removed value: Python
Updated HashMap: {1=Java, 3=JavaScript}
Aqui, o remove() método pega a chave como seu parâmetro. Em seguida, ele retorna o valor associado à chave e remove a entrada .
Também podemos remover a entrada apenas sob certas condições. Por exemplo,
remove(2, "C++");
Aqui, o remove() O método remove apenas a entrada se a chave 2 está associado ao valor C++ . Desde 2 não está associado a C++ , ele não remove a entrada.
Para saber mais, visite Java HashMap remove().
Outros métodos de HashMap
Método Descrição limpar() remove todos os mapeamentos do HashMap computar() computa um novo valor para a chave especificada computarSeAusente() computa o valor se um mapeamento para a chave não estiver presente computarIfPresent() computa um valor para mapeamento se a chave estiver presente mesclar() mescla o mapeamento especificado ao HashMap clone() faz a cópia do HashMap contémKey() verifica se a chave especificada está presente no Hashmap contémValue() verifica se Hashmap contém o valor especificadotamanho() retorna o número de itens em HashMap está vazio() verifica se o Hashmap está vazio
Iterar por meio de um HashMap
Para percorrer cada entrada do hashmap, podemos usar Java for-each loop. Podemos iterar por meio de somente chaves , somente valores e mapeamento de chave/valor . Por exemplo,
import java.util.HashMap;
import java.util.Map.Entry;
class Main {
public static void main(String[] args) {
// create a HashMap
HashMap<Integer, String> languages = new HashMap<>();
languages.put(1, "Java");
languages.put(2, "Python");
languages.put(3, "JavaScript");
System.out.println("HashMap: " + languages);
// iterate through keys only
System.out.print("Keys: ");
for (Integer key : languages.keySet()) {
System.out.print(key);
System.out.print(", ");
}
// iterate through values only
System.out.print("\nValues: ");
for (String value : languages.values()) {
System.out.print(value);
System.out.print(", ");
}
// iterate through key/value entries
System.out.print("\nEntries: ");
for (Entry<Integer, String> entry : languages.entrySet()) {
System.out.print(entry);
System.out.print(", ");
}
}
}
Saída
HashMap: {1=Java, 2=Python, 3=JavaScript}
Keys: 1, 2, 3,
Values: Java, Python, JavaScript,
Entries: 1=Java, 2=Python, 3=JavaScript,
Observe que usamos o Map.Entry no exemplo acima. É a classe aninhada do Map interface que retorna uma visão (elementos) do mapa.
Primeiro precisamos importar o java.util.Map.Entry pacote para usar esta classe.
Essa classe aninhada retorna uma visualização (elementos) do mapa.
Criando HashMap de outros mapas
Em Java, também podemos criar um hashmap a partir de outros mapas. Por exemplo,
import java.util.HashMap;
import java.util.TreeMap;
class Main {
public static void main(String[] args) {
// create a treemap
TreeMap<String, Integer> evenNumbers = new TreeMap<>();
evenNumbers.put("Two", 2);
evenNumbers.put("Four", 4);
System.out.println("TreeMap: " + evenNumbers);
// create hashmap from the treemap
HashMap<String, Integer> numbers = new HashMap<>(evenNumbers);
numbers.put("Three", 3);
System.out.println("HashMap: " + numbers);
}
}
Saída
TreeMap: {Four=4, Two=2}
HashMap: {Two=2, Three=3, Four=4}
No exemplo acima, criamos um TreeMap chamado evenNumbers . Observe a expressão,
numbers = new HashMap<>(evenNumbers)
Aqui, estamos criando um HashMap números nomeados usando o TreeMap . Para saber mais sobre treemap, visite Java TreeMap.
Observação :Ao criar um mapa de hash, podemos incluir parâmetros opcionais:capacidade e fator de carga . Por exemplo,
HashMap<K, V> numbers = new HashMap<>(8, 0.6f);
Aqui,
Se os parâmetros opcionais não forem usados, a capacidade padrão será 16 e o fator de carga padrão será 0,75 .
Java