HashMap Java

In questo tutorial, impareremo attraverso esempi la classe HashMap di Java e i suoi metodi.

La classe HashMap della Java Collection Framework fornisceInterfaccia MapImplementazione della tabella hash.

Creazione di una HashMap

Per creare una HashMap, dobbiamo prima importare il pacchetto java.util.HashMap. Dopo aver importato il pacchetto, possiamo utilizzare Java per creare una tabella hash.

// Creazione di una HashMap con una capacità di 8 e un fattore di carico 0.6
HashMap<Key, Value> numbers = new HashMap<>(8, 0.6f);

在上面的代码中，我们创建了一个名为numbers的HashMap。

这里，

• Key - 用于关联map中每个元素（值）的唯一标识符

• Value - 与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);
　　　　}
}

Risultato di output

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

HashMap的方法

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

将元素插入HashMap

• put() - 将指定的键/值映射插入到map中

• putAll() - 将指定map的所有条目插入此map

• putIfAbsent() - 如果map中不存在指定的键，则将指定的键/值映射插入到map中

Ad esempio:

import java.util.HashMap;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//创建偶数HashMap
　　　　　　　　HashMap<String, Integer> evenNumbers = new HashMap<>();
　　　　　　　　// Utilizzo di put()
　　　　　　　　evenNumbers.put("Two", 2);
　　　　　　　　evenNumbers.put("Four", 4);
　　　　　　　　// Utilizzo di putIfAbsent()
　　　　　　　　evenNumbers.putIfAbsent("Six", 6);
　　　　　　　　System.out.println("HashMap di numeri pari: " + evenNumbers);
　　　　　　　　// Creazione di HashMap di numbers
　　　　　　　　HashMap<String, Integer> numbers = new HashMap<>();
　　　　　　　　numbers.put("One", 1);
　　　　　　　　// Utilizzo di putAll()
　　　　　　　　numbers.putAll(evenNumbers);
　　　　　　　　System.out.println("HashMap di numbers: " + numbers);
　　　　}
}

Risultato di output

HashMap di numeri pari: {Six=6, Four=4, Two=2}
HashMap di numbers: {Six=6, One=1, Four=4, Two=2}

Accesso agli elementi HashMap

1. Utilizzo di entrySet(), keySet() e values()

• entrySet() - Restituisce un insieme di tutte le mappature chiave/valore della mappa

• keySet() - Restituisce l'insieme di tutte le chiavi della mappa

• values() - Restituisce l'insieme di tutti i valori della mappa

Ad esempio:

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: \t" + numbers);
　　　　　　　　// Utilizzo di entrySet()
　　　　　　　　System.out.println("Mappatura Chiave/Valore: " + numbers.entrySet());
　　　　　　　　// Utilizzo di keySet()
　　　　　　　　System.out.println("Chiavi: " + numbers.keySet());
　　　　　　　　// Utilizzo di values()
　　　　　　　　System.out.println("Valori: " + numbers.values());
　　　　}
}

Risultato di output

HashMap: {One=1, Two=2, Three=3}
Mappatura Chiave/Valore: [One=1, Two=2, Three=3]
Chiavi: [One, Two, Three]
Valori: [1, 2, 3]

2. Utilizzo di get() e getOrDefault()

• get() - Restituisce il valore associato alla chiave specificata. Se non viene trovata la chiave, viene restituito null.

• getOrDefault() - Restituisce il valore associato alla chiave specificata. Se non viene trovata la chiave, viene restituito il valore predefinito.

Ad esempio:

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: \t" + numbers);
　　　　　　　　// 使用 get()
　　　　　　　　int value1 = numbers.get("Three");
　　　　　　　　System.out.println("Restituisci il numero: " + value1);
　　　　　　　　// Utilizzare getOrDefault()
　　　　　　　　int value2 = numbers.getOrDefault("Five", 5);
　　　　　　　　System.out.println("Restituisci il numero: " + value2);
　　　　}
}

Risultato di output

HashMap: {One=1, Two=2, Three=3}
Restituisci il numero: 3
Restituisci il numero: 5

Elimina l'elemento

• remove(key) - Restituisce e elimina l'elemento associato alla chiave specificata

• remove(key, value) - Elimina l'elemento dalla mappatura solo se la chiave specificata è mappata al valore specificato e restituisce un valore booleano

Ad esempio:

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: \t" + numbers);
　　　　　　　　// Metodo di eliminazione con un parametro
　　　　　　　　int value = numbers.remove("Two");
　　　　　　　　System.out.println("Elimina il valore: " + value);
　　　　　　　　// Metodo di eliminazione con due parametri
　　　　　　　　boolean result = numbers.remove("Three", 3);
　　　　　　　　System.out.println("L'elemento 3 è stato eliminato? " + result);
　　　　　　　　System.out.println("HashMap aggiornato: " + numbers);
　　　　}
}

Risultato di output

HashMap: {One=1, Two=2, Three=3}
Elimina il valore: 2
L'elemento 3 è stato eliminato? True
HashMap aggiornato: {One=1}

Sostituisci l'elemento

• replace(key, value) - Sostituisci il valore associato alla chiave key con value

• replace(key, old, new) - Sostituisci il valore associato alla chiave specificata solo se il valore old è già associato alla chiave key

• replaceAll(function) - Sostituisci ogni valore della mappatura con il risultato della funzione specificata

Ad esempio:

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 originale: " + numbers);
　　　　　　　　// Utilizzare replace()
　　　　　　　　numbers.replace("Second", 22);
　　　　　　　　numbers.replace("Third", 3, 33);
　　　　　　　　System.out.println("Utilizzare replace per sostituire i valori di HashMap: " + numbers);
　　　　　　　　// Utilizzare replaceAll()
　　　　　　　　numbers.replaceAll((key, oldValue) -> oldValue + 2)
　　　　　　　　System.out.println("Utilizzare replaceAll per sostituire i valori di HashMap: " + numbers);
　　　　}
}

Risultato di output

HashMap originale: {Second=2, Third=3, First=1}
Usa replace per sostituire i valori di HashMap: {Second=22, Third=33, First=1}
Usa replace per sostituire i valori di HashMap: {Second=24, Third=35, First=3}

Nell'esempio sopra, presta attenzione alla seguente istruzione

numbers.replaceAll((key, oldValue) -> oldValue + 2)

In questo caso, il metodo accede a tutte le voci della mappa. Poi, sostituisce tutti i valori conlambda表达式Il nuovo valore fornito.

Ricalcola il valore

1. Utilizza il metodo compute()

• compute() - Calcola un nuovo valore utilizzando la funzione specificata. Poi, associa il valore calcolato alla chiave specificata.

• computeIfAbsent() - Se la chiave specificata non è mappata a qualsiasi valore, questo metodo calcola un nuovo valore utilizzando la funzione specificata. Poi, l'associa alla chiave.

• computeIfPresent() - Se la chiave specificata è già mappata a qualsiasi valore, questo metodo calcola un nuovo valore utilizzando la funzione specificata. Poi, l'associa alla chiave.

Ad esempio:

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： " + numbers);
　　　　　　　　// Utilizza compute()
　　　　　　　　numbers.compute("First", (key, oldValue) -> oldValue + 2)
　　　　　　　　numbers.compute("Second", (key, oldValue) -> oldValue + 1)
　　　　　　　　System.out.println("HashMap utilizza compute(): " + numbers)
　　　　　　　　// Utilizza computeIfAbsent()
　　　　　　　　numbers.computeIfAbsent("Three", key -> 5)
　　　　　　　　System.out.println("HashMap utilizza computeIfAbsent(): " + numbers)
　　　　　　　　// Utilizza computeIfPresent()
　　　　　　　　numbers.computeIfPresent("Second", (key, oldValue) -> oldValue * 2)
　　　　　　　　System.out.println("HashMap utilizza computeIfPresent(): " + numbers)
　　　　}
}

Risultato di output

原始HashMap： {Second=2, First=1}
HashMap utilizza compute(): {Second=3, First=3}
HashMap 使用 computeIfAbsent(): {Second=3 First=3, Three=5}
HashMap 使用 computeIfPresent(): {Second=6, First=3, three=5}

在上面的示例中，我们使用的compute()方法重新计算了映射的值。

在这里，我们使用lambda表达式作为方法参数来重新计算值。

2.使用merge()方法

如果指定的键尚未关联，则merge()方法将指定的值与指定的键关联。

但是，如果指定的键已经与一个值关联，它将把新的指定值与现有的旧值合并。例如

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： " + numbers);
　　　　　　　　// 使用 merge() 方法
　　　　　　　　numbers.merge("First", 4, (oldValue, newValue) -> oldValue + newValue);
　　　　　　　　System.out.println("新的HashMap： " + numbers);
　　　　}
}

Risultato di output

原始HashMap： {Second=2, First=1}
新的HashMap： {Second=2, First=5}

在上面的示例中，merge()方法采用3个参数：key，newValue和一个lambda表达式（用于计算新的合并值）。

HashMap的其他方法

遍历HashMap

在中HashMap，我们可以

• 遍历其 键

• 遍历其 值

• 遍历其 键/值

1.使用forEach循环

import java.util.HashMap;
import java.util.Map.Entry;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　//创建HashMap
　　　　　　　　HashMap<String, Integer> numbers = new HashMap<>();
　　　　　　　　numbers.put("One", 1);
　　　　　　　　numbers.put("Two", 2);
　　　　　　　　numbers.put("Three", 3);
　　　　　　　　System.out.println("HashMap: \t" + numbers);
　　　　　　　　//访问键/值（key/value）对
　　　　　　　　System.out.print("Progetto: ");
　　　　　　　　for(Entry<String, Integer> entry: numbers.entrySet()) {
　　　　　　　　　　　　System.out.print(entry);
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　　　　　// Accesso chiave
　　　　　　　　System.out.print("\nTutti gli chiavi: \t");
　　　　　　　　for(String key: numbers.keySet()) {
　　　　　　　　　　　　System.out.print(key);
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　　　　　// Accesso valore
　　　　　　　　System.out.print("\nTutti i valori: ");
　　　　　　　　for(Integer value: numbers.values()) {
　　　　　　　　　　　　System.out.print(value);
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Risultato di output

HashMap: {One=1, Two=2, Three=3}
Tutti gli elementi: One=1, Two=2, Three=3
Tutti gli elementi: One, Two, Three,
Tutti i valori: 1, 2, ,3,

Nell'esempio sopra, nota che abbiamo importato il pacchetto java.util.Map.Entry. Qui Map.Entry è una classe annidata dell'interfaccia Map.

Questa classe interna restituisce la vista del map (elementi).

2. Utilizzo del metodo iterator()

Puoi anche utilizzare il metodo iterator() per iterare l'HashMap. Per utilizzare questo metodo, dobbiamo importare il pacchetto java.util.Iterator.

import java.util.HashMap;
import java.util.Iterator;
import java.util.Map.Entry;
class Main {
　　　　public static void main(String[] args) {
　　　　　　　　// Creazione HashMap
　　　　　　　　HashMap<String, Integer> numbers = new HashMap<>();
　　　　　　　　numbers.put("One", 1);
　　　　　　　　numbers.put("Two", 2);
　　　　　　　　numbers.put("Three", 3);
　　　　　　　　System.out.println("HashMap: \t" + numbers);
　　　　　　　　// Creazione dell'oggetto Iterator
　　　　　　　　Iterator<Entry<String, Integer>> iterate1 = numbers.entrySet().iterator();
　　　　　　　　// Accesso coppia Chiave/Valore
　　　　　　　　System.out.print("Tutti gli elementi: \t");
　　　　　　　　while(iterate1.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate1.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　　　　　// Accesso chiave
　　　　　　　　Iterator<String> iterate2 = numbers.keySet().iterator();
　　　　　　　　System.out.print("\nTutti gli chiavi: \t");
　　　　　　　　while(iterate2.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate2.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　　　　　// Accedi al value
　　　　　　　　Iterator<Integer> iterate3 = numbers.values().iterator();
　　　　　　　　　System.out.print("\nTutti i valori: ");
　　　　　　　　while(iterate3.hasNext()) {
　　　　　　　　　　　　System.out.print(iterate3.next());
　　　　　　　　　　　　System.out.print(", ");
　　　　　　　　}
　　　　}
}

Risultato di output

HashMap: {One=1, Two=2, Three=3}
Tutti gli elementi: One=1, Two=2, Three=3
Tutti gli elementi: One, Two, Three,
Tutti i valori: 1, 2, 3,

Nel programma sopra, nota che abbiamo importato il pacchetto java.util.Map.Entry. Map.Entry è una classe interna dell'interfaccia Map.

Questa classe interna restituisce la vista del map (elementi).