English | 简体中文 | 繁體中文 | Русский язык | Français | Español | Português | Deutsch | 日本語 | 한국어 | Italiano | بالعربية
Neste tutorial, vamos aprender com exemplos a classe HashMap do Java e seus métodos.
A classe HashMap do Java Collection Framework forneceInterface Mapimplementação de tabela de hashing.
Para criar um HashMap, devemos primeiro importar o pacote java.util.HashMap. Após a importação do pacote, podemos usar Java para criar uma tabela de hashing.
//Criar com8com uma capacidade e 0.6HashMap de fator de carga HashMap<Key, Value> numbers = new HashMap<>(8, 0.6f);
No código acima, criamos um HashMap chamado numbers.
Aqui,
Chave -Identificador único utilizado para associar cada elemento (valor) do map
Value -Elemento associado à chave no map
请注意 new HashMap<>(8,0.6) 部分。这里，第一个参数是capacity，第二个参数是loadFactor。
capacity - HashMap的容量为8。意味着，它可以存储8个条目。
loadFactor - hashmap的负载因子为0.6。这意味着，每当哈希表被填满60%时，条目就会被移动到一个新哈希表，其大小是原始哈希表的两倍。
默认容量和负载因子
创建哈希表而不定义其容量和负载因子是允许的。例如，
//具有默认容量和负载因子的HashMap HashMap<Key, Value> numbers1 = new HashMap<>();
默认，
HashMap的容量将为 16
负载因子将为 0.75
这是我们如何创建包含其他map的所有元素的HashMap的方法。
import java.util.HashMap;
class Main {
public static void main(String[] args) {
//创建偶数的hashmap
HashMap<String, Integer> evenNumbers = new HashMap<>();
evenNumbers.put("Two", 2);
evenNumbers.put("Four", 4);
System.out.println("HashMap1: " + evenNumbers);
//从其他hashmap创建一个hashmap
HashMap<String, Integer> numbers = new HashMap<>(evenNumbers);
numbers.put("Three", 3);
System.out.println("HashMap2: " + numbers);
}
}Resultados de saída
HashMap1: {Four=4, Two=2}
HashMap2: {Two=2, Three=3, Four=4}本HashMap类提供各种方法，使我们能够在map上进行各种操作。
put() - 将指定的键/值映射插入到map中
putAll() - 将指定map的所有条目插入此map
putIfAbsent() - 如果map中不存在指定的键，则将指定的键/值映射插入到map中
例如，
import java.util.HashMap;
class Main {
public static void main(String[] args) {
//创建偶数HashMap
HashMap<String, Integer> evenNumbers = new HashMap<>();
// 使用 put()
evenNumbers.put("Two", 2);
evenNumbers.put("Four", 4);
// 使用 putIfAbsent()
evenNumbers.putIfAbsent("Six", 6);
System.out.println("偶数HashMap: " + evenNumbers);
//Creating HashMap of numbers
HashMap<String, Integer> numbers = new HashMap<>();
numbers.put("One", 1);
// 使用 putAll()
numbers.putAll(evenNumbers);
System.out.println("numbers的HashMap: " + numbers);
}
}Resultados de saída
HashMap de números pares: {Six=6, Four=4, Two=2}
HashMap numbers: {Six=6, One=1, Four=4, Two=2}1.Usando entrySet(), keySet() e values()
entrySet() -Retorna um conjunto de todas as chaves/Mapa de mapeamento de valores
keySet() -Retorna a coleção de todas as chaves do map
values() -Retorna a coleção de todos os valores do map
例如，
import java.util.HashMap;
class Main {
public static void main(String[] args) {
HashMap<String, Integer> numbers = new HashMap<>();
numbers.put("One", 1);
numbers.put("Two", 2);
numbers.put("Three", 3);
System.out.println("HashMap: "); + numbers);
// Usando entrySet()
System.out.println("Chave",/Mapeamento de valores: ", + numbers.entrySet());
// Usando keySet()
System.out.println("Chaves: ", + numbers.keySet());
// Usando values()
System.out.println("Valores: ", + numbers.values());
}
}Resultados de saída
HashMap: {One=1, Two=2, Three=3}
Chave/Mapeamento de valores: [One=1, Two=2, Three=3]
Chaves: [One, Two, Three]
Valores: [1, 2, 3]2.Usando get() e getOrDefault()
get() - Retorna o valor associado à chave especificada. Se a chave não for encontrada, retorna null.
getOrDefault() - Retorna o valor associado à chave especificada. Se a chave não for encontrada, retorna o valor padrão especificado.
例如，
import java.util.HashMap;
class Main {
public static void main(String[] args) {
HashMap<String, Integer> numbers = new HashMap<>();
numbers.put("One", 1);
numbers.put("Two", 2);
numbers.put("Three", 3);
System.out.println("HashMap: "); + numbers);
// Usando get()
int value1 = numbers.get("Three");
System.out.println("Número retornado: ", + value1);
// Usando getOrDefault()
int value2 = numbers.getOrDefault("Five", 5);
System.out.println("Número retornado: ", + value2);
}
}Resultados de saída
HashMap: {One=1, Two=2, Three=3}
Retorna números: 3
Retorna números: 5remove(key) - Retorna e exclui do mapeamento o item associado à chave especificada
remove(key, value) - A exclusão do item ocorre apenas quando a chave mapeada para o valor específico existe e retorna um valor booleano
例如，
import java.util.HashMap;
class Main {
public static void main(String[] args) {
HashMap<String, Integer> numbers = new HashMap<>();
numbers.put("One", 1);
numbers.put("Two", 2);
numbers.put("Three", 3);
System.out.println("HashMap: "); + numbers);
//Método de exclusão com um parâmetro
int value = numbers.remove("Two");
System.out.println("Valor excluído: ", + value);
//Método de exclusão com dois parâmetros
3);
System.out.println("Entrada", "第2段": "boolean result = numbers.remove("Three",3被删除了吗? " + result);
System.out.println("更新后的HashMap: ") + numbers);
}
}Resultados de saída
HashMap: {One=1, Two=2, Three=3}
删除值: 2
条目3被删除了吗? True
更新后的HashMap: {One=1}replace(key, value) - 将key的值替换为value
replace(key, old, new) - 仅当old值已与指定键key关联时，才用new值替换old值
replaceAll(function) - 用指定函数的结果替换映射的每个值
例如，
import java.util.HashMap;
class Main {
public static void main(String[] args) {
HashMap<String, Integer> numbers = new HashMap<>();
numbers.put("First", 1);
numbers.put("Second", 2);
numbers.put("Third", 3);
System.out.println("原始HashMap: ") + numbers);
// 使用 replace()
numbers.replace("Second", 22);
numbers.replace("Third", 3, 33);
System.out.println("使用replace替换HashMap的值: ") + numbers);
// 使用 replaceAll()
numbers.replaceAll((key, oldValue) -> oldValue + 2);
System.out.println("使用replaceAll替换HashMap的值: ") + numbers);
}
}Resultados de saída
原始HashMap: {Second=2, Third=3, First=1}
使用replace替换HashMap的值: {Second=22, Third=33, First=1}
使用replaceAll替换HashMap的值: {Second=24, Third=35, First=3}在上述程序中，注意语句
numbers.replaceAll((key, oldValue) -> oldValue + 2);
在此，该方法访问map的所有条目。然后，它将所有值替换为expressão lambda提供的新值。
1.使用compute()方法
compute() - 使用指定的函数计算新值。然后将计算值与指定的键相关联。
computeIfAbsent() - 如果指定的键没有映射到任何值，该方法将使用指定的函数计算一个新值。然后将新值与键关联。
computeIfPresent() -如果指定的键已经映射到任何值，此方法将使用指定的函数计算一个新值。然后将新值与键关联。
例如，
import java.util.HashMap;
class Main {
public static void main(String[] args) {
HashMap<String, Integer> numbers = new HashMap<>();
numbers.put("First", 1);
numbers.put("Second", 2);
System.out.println("HashMap original: ", + numbers);
// 使用 compute()
numbers.compute("First", (key, oldValue) -> oldValue + 2);
numbers.compute("Second", (key, oldValue) -> oldValue + 1);
System.out.println("HashMap 使用 compute(): ") + numbers);
// Usar computeIfAbsent()
numbers.computeIfAbsent("Three", key -> 5);
System.out.println("HashMap usando computeIfAbsent(): ", + numbers);
// Usar computeIfPresent()
numbers.computeIfPresent("Second", (key, oldValue) -> oldValue * 2);
System.out.println("HashMap usando computeIfPresent(): ", + numbers);
}
}Resultados de saída
HashMap original: {Second=2, First=1}
HashMap usando compute(): {Second=3, First=3}
HashMap usando computeIfAbsent(): {Second=3 First=3, Three=5}
HashMap usando computeIfPresent(): {Second=6, First=3, three=5}No exemplo acima, usamos o método compute() para recalcular o valor do mapeamento.
Aqui, usamosexpressão lambdacomo parâmetro do método para recalcular o valor.
2. Usar o método merge()
Se a chave especificada não estiver associada, o método merge() associará o valor especificado à chave especificada.
Mas, se a chave especificada já estiver associada a um valor, ela combinará o novo valor especificado com o valor antigo existente. Por exemplo
import java.util.HashMap;
class Main {
public static void main(String[] args) {
HashMap<String, Integer> numbers = new HashMap<>();
numbers.put("First", 1);
numbers.put("Second", 2);
System.out.println("HashMap original: ", + numbers);
// Usar o método merge()
numbers.merge("First", 4, (oldValue, newValue) -> oldValue + newValue);
System.out.println("Novo HashMap: ", + numbers);
}
}Resultados de saída
HashMap original: {Second=2, First=1}
Novo HashMap: {Second=2, First=5}No exemplo acima, o método merge() utiliza3um parâmetro:key,newValuee uma expressão lambda (usada para calcular o novo valor combinado).
| Métodos de HashMap | Descrição |
|---|---|
| clear() | Remover todos os itens do mapeamento |
| containsKey() | Verificar se o mapeamento contém a chave especificada e retornar um valor booleano |
| containsValue() | Verificar se o mapeamento contém o valor especificado e retornar um valor booleano |
| size() | retornar o tamanho do mapa |
| isEmpty() | verificar se o mapa está vazio e retornar um valor booleano |
dentro do HashMap, podemos
percorrer seus chave
percorrer seus valor
percorrer seus chave/valor
1usando loop forEach
import java.util.HashMap;
import java.util.Map.Entry;
class Main {
public static void main(String[] args) {
//criar HashMap
HashMap<String, Integer> numbers = new HashMap<>();
numbers.put("One", 1);
numbers.put("Two", 2);
numbers.put("Three", 3);
System.out.println("HashMap: "); + numbers);
//acessar chave/valor (key/par de valor
System.out.print("Item: ");
for(Entry<String, Integer> entry: numbers.entrySet()) {
System.out.print(entry);
System.out.print(", ");
}
//acessar key
System.out.print("\nTodos os chaves: ");
for(String key: numbers.keySet()) {
System.out.print(key);
System.out.print(", ");
}
//Acessar value
System.out.print("\nTodos os valores: ");
for(Integer value: numbers.values()) {
System.out.print(value);
System.out.print(", ");
}
}
}Resultados de saída
HashMap: {One=1, Two=2, Three=3}
Todos os itens: One=1, Two=2, Three=3
Todos os chaves: One, Two, Three,
Todos os valores: 1, 2, ,3,No programa acima, note que já importamos o pacote java.util.Map.Entry. Aqui Map.Entry é uma classe aninhada da interface Map.
Esta classe aninhada retorna a visão do map (elementos).
2usando o método iterator()
Também podemos usar o método iterator() para iterar o HashMap. Para usar este método, devemos importar o pacote java.util.Iterator.
import java.util.HashMap;
import java.util.Iterator;
import java.util.Map.Entry;
class Main {
public static void main(String[] args) {
//criar HashMap
HashMap<String, Integer> numbers = new HashMap<>();
numbers.put("One", 1);
numbers.put("Two", 2);
numbers.put("Three", 3);
System.out.println("HashMap: "); + numbers);
//criar objeto Iterator
Iterator<Entry<String, Integer>> iterate1 = numbers.entrySet().iterator();
// acessar Key/par de valor
System.out.print("Todas as entradas: ");
while(iterate1.hasNext()) {
System.out.print(iterate1.next());
System.out.print(", ");
}
// acessar key
Iterator<String> iterate2 = numbers.keySet().iterator();
System.out.print("\nTodos os chaves: ");
while(iterate2.hasNext()) {
System.out.print(iterate2.next());
System.out.print(", ");
}
// Acessar value
Iterator<Integer> iterate3 = numbers.values().iterator();
System.out.print("\nTodos os valores: ");
while(iterate3.hasNext()) {
System.out.print(iterate3.next());
System.out.print(", ");
}
}
}Resultados de saída
HashMap: {One=1, Two=2, Three=3}
Todos os itens: One=1, Two=2, Three=3
Todos os chaves: One, Two, Three,
Todos os valores: 1, 2, 3,No programa acima, note que já importamos o pacote java.util.Map.Entry. Aqui Map.Entry é uma classe aninhada da interface Map.
Esta classe aninhada retorna a visão do map (elementos).