HashMap de Java

En este tutorial, aprenderemos a través de ejemplos la clase HashMap de Java y sus métodos.

La clase HashMap de la estructura de colecciones de Java proporcionaInterfaz Mapimplementación de la tabla de hash.

Crear un HashMap

Para crear un HashMap, primero debemos importar el paquete java.util.HashMap. Después de importar el paquete, podemos usar Java para crear una tabla de hash.

//Crear con8de capacidad y 0.6HashMap de factor de carga
HashMap<Key, Value> numbers = new HashMap<>();8, 0.6f);

En el código anterior, creamos un HashMap llamado numbers.

Aquí,

• Key -Identificador único utilizado para asociar cada elemento (valor) en el map

• Valor -El elemento asociado con la clave en el 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

这是我们如何创建包含其他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 salida

HashMap1:　{Four=4,　Two=2}
HashMap2:　{Two=2,　Three=3, Four=4}

HashMap的方法

本HashMap类提供各种方法，使我们能够在map上进行各种操作。

将元素插入HashMap

• 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: ", "xe7xacacx7bxe7xacacx7d");　+　numbers);
　　　　}
}

Resultados de salida

even number HashMap: {Six=6, Four=4,　Two=2}
numbers' HashMap: {Six=6, One=1, Four=4,　Two=2}

access HashMap elements

1.using entrySet(), keySet() and values()

• entrySet() -return a set of all keys/map of value mappings

• keySet() -return the set of all keys in the map

• values() -return the set of all values in the 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);
　　　　　　　　//　using entrySet()
　　　　　　　　System.out.println("Key/Value mapping:　+　numbers.entrySet());
　　　　　　　　//　using keySet()
　　　　　　　　System.out.println("Keys: ", "xe7xacacx7bxe7xacacx7d");　+　numbers.keySet());
　　　　　　　　//　using values()
　　　　　　　　System.out.println("Values: ", "xe7xacacx7bxe7xacacx7d");　+　numbers.values());
　　　　}
}

Resultados de salida

HashMap:　{One=1,　Two=2,　Three=3}
Key/Value mapping: [One=1,　Two=2,　Three=3]
Keys: [One, Two, Three]
Values: [1,　2,　3]

2.using get() and getOrDefault()

• get() - return the value associated with the specified key. If the key is not found, return null.

• getOrDefault() - return the value associated with the specified key. If the key is not found, return the specified default value.

例如，

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);
　　　　　　　　//　using get()
　　　　　　　　int value1　= numbers.get("Three");
　　　　　　　　System.out.println("return number: ", "xe7xacacx7bxe7xacacx7d");　+　value1);
　　　　　　　　//　using getOrDefault()
　　　　　　　　int value2　= numbers.getOrDefault("Five",　5);
　　　　　　　　System.out.println("return number: ", "xe7xacacx7bxe7xacacx7d");　+　value2);
　　　　}
}

Resultados de salida

HashMap:　{One=1,　Two=2,　Three=3}
return number:　3
return number:　5

delete element

• remove(key)　 - return and remove the item associated with the specified key from the map

• remove(key, value)　 - xe4xb8xbbxe8xa6x81xe6x98xafxe5x9cxa8xe6x8cx87xe5xaex9axe9x94xaexe5x8cx96xe5x88xb0xe6x8cx87xe5xaex9axe5xb0x8fxe5x80xbcxe5x88x97xe6x96xb9xe6xb3x95xe4xb8xadxe5x88xa0xe9x99xa4xe9xa1xb9xe7x9bxa0

例如，

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);
　　　　　　　　//xe5xb0x91xe5xb1x9exe6xadxa5xe7x9ax84xe5x88xa0xe9x99xa4xe6xb3x95
　　　　　　　　int value = numbers.remove("Two");
　　　　　　　　System.out.println("xe5x88xa0xe9x99xa4xe5xb0x8fxe5x80xbc: ", "xe7xacacx7bxe7xacacx7d");　+　value);
　　　　　　　　//xe6x9cx89xe4xb8xa4xe5xb1x9exe6xadxa5xe7x9ax84xe5x88xa0xe9x99xa4xe6x96xb9xe6xb3x95
　　　　　　　　boolean result = numbers.remove("Three",　3);
　　　　　　　　System.out.println("xe6x9cxaaxe5x85xa5", "xe7xacacx7bxe7xacacx7d");3被删除了吗? "　+　result);
　　　　　　　　System.out.println("更新后的HashMap: ")　+　numbers);
　　　　}
}

Resultados de salida

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 salida

原始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的所有条目。然后，它将所有值替换为Expresión 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);
　　　　　　　　//　Usando computeIfAbsent()
　　　　　　　　numbers.computeIfAbsent("Three", key　->　5);
　　　　　　　　System.out.println("HashMap usando computeIfAbsent(): ",　+　numbers);
　　　　　　　　//　Usando computeIfPresent()
　　　　　　　　numbers.computeIfPresent("Second", (key, oldValue)　-> oldValue　*　2);
　　　　　　　　System.out.println("HashMap usando computeIfPresent(): ",　+　numbers);
　　　　}
}

Resultados de salida

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}

En el ejemplo anterior, usamos el método compute() para recalcular el valor del mapeo.

Aquí, usamosExpresión lambdacomo parámetro de método para recalcular el valor.

2. Usando el método merge()

Si la clave especificada no está asociada, el método merge() asociará el valor especificado con la clave especificada.

Pero, si la clave especificada ya está asociada con un valor, se combinará el nuevo valor especificado con el valor antiguo existente. Por ejemplo

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);
　　　　　　　　//　Usando el método merge()
　　　　　　　　numbers.merge("First",　4, (oldValue, newValue)　-> oldValue　+　newValue);
　　　　　　　　System.out.println("Nuevo HashMap: ",　+　numbers);
　　　　}
}

Resultados de salida

HashMap original: {Second=2, First=1}
Nuevo HashMap: {Second=2, First=5}

En el ejemplo anterior, el método merge() utiliza3con un parámetro:key,newValuey una expresión lambda (usada para calcular el nuevo valor combinado).

Otros métodos de HashMap

Explorar el HashMap

En el HashMap, podemos

• Explorar su clave

• Explorar su valor

• Explorar su clave/valor

1.Uso del ciclo foreach

import java.util.HashMap;
import java.util.Map.Entry;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Crear HashMap
　　　　　　　　HashMap<String, Integer> numbers = new HashMap<>();
　　　　　　　　numbers.put("One",　1);
　　　　　　　　numbers.put("Two",　2);
　　　　　　　　numbers.put("Three",　3);
　　　　　　　　System.out.println("HashMap: ");　+　numbers);
　　　　　　　　//Acceder a la clave/valor (clave/par de valor
　　　　　　　　System.out.print("Elemento: ");
　　　　　　　　for(Entry<String, Integer> entry: numbers.entrySet()) {
　　　　　　　　　　　　System.out.print(entry);
　　　　　　　　　　　　System.out.print(",　");
　　　　　　　　}
　　　　　　　　//Acceder a la clave
　　　　　　　　System.out.print("\nTodos los claves:　");
　　　　　　　　for(String key: numbers.keySet()) {
　　　　　　　　　　　　System.out.print(key);
　　　　　　　　　　　　System.out.print(",　");
　　　　　　　　}
　　　　　　　　//Acceder a　value
　　　　　　　　System.out.print("\nTodos los valores:　");
　　　　　　　　for(Integer value: numbers.values()) {
　　　　　　　　　　　　System.out.print(value);
　　　　　　　　　　　　System.out.print(",　");
　　　　　　　　}
　　　　}
}

Resultados de salida

HashMap:　{One=1,　Two=2,　Three=3}
Todos los elementos:　One=1,　Two=2,　Three=3
Todos los claves:　One,　Two,　Three,
Todos los valores:　1,　2, ,3,

En el programa anterior, note que ya hemos importado el paquete java.util.Map.Entry. Aquí Map.Entry es una clase anidada de la interfaz Map.

Esta clase anidada devuelve la vista del mapa (elementos).

2.Uso del método iterator()

También se puede usar el método iterator() para iterar el HashMap. Para usar este método, debemos importar el paquete java.util.Iterator.

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map.Entry;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//Crear HashMap
　　　　　　　　HashMap<String, Integer> numbers = new HashMap<>();
　　　　　　　　numbers.put("One",　1);
　　　　　　　　numbers.put("Two",　2);
　　　　　　　　numbers.put("Three",　3);
　　　　　　　　System.out.println("HashMap: ");　+　numbers);
　　　　　　　　//Crear el objeto Iterator
　　　　　　　　Iterator<Entry<String, Integer>> iterate1　= numbers.entrySet().iterator();
　　　　　　　　//　Acceder a la clave/Par de valor
　　　　　　　　System.out.print("Todas las entradas: ");
　　　　　　　　while(iterate1.hasNext())　{
　　　　　　　　　　　　System.out.print(iterate1.next());
　　　　　　　　　　　　System.out.print(",　");
　　　　　　　　}
　　　　　　　　//　Acceder a la clave
　　　　　　　　Iterator<String> iterate2　=　numbers.keySet().iterator();
　　　　　　　　System.out.print("\nTodos los claves:　");
　　　　　　　　while(iterate2.hasNext())　{
　　　　　　　　　　　　System.out.print(iterate2.next());
　　　　　　　　　　　　System.out.print(",　");
　　　　　　　　}
　　　　　　　　//　Acceder a　value
　　　　　　　　Iterator<Integer>　iterate3　=　numbers.values().iterator();
　　　　　　　　　System.out.print("\nTodos los valores:　");
　　　　　　　　while(iterate3.hasNext())　{
　　　　　　　　　　　　System.out.print(iterate3.next());
　　　　　　　　　　　　System.out.print(",　");
　　　　　　　　}
　　　　}
}

Resultados de salida

HashMap:　{One=1,　Two=2,　Three=3}
Todos los elementos:　One=1,　Two=2,　Three=3
Todos los claves:　One,　Two,　Three,
Todos los valores:　1,　2,　3,

En el programa anterior, note que hemos importado el paquete java.util.Map.Entry. Aquí Map.Entry es una clase anidada de la interfaz Map.

Esta clase anidada devuelve la vista del mapa (elementos).