Utilizzo e esempio di Java HashMap merge()

Metodi Java HashMap

Se la chiave specificata non esiste, il metodo merge() di Java HashMap inserirà la mappatura chiave/valore specificata nel mappamento hash.

Ma se la chiave specificata è già associata a un valore, il metodo sostituirà il vecchio valore con il risultato della funzione specificata.

La sintassi del metodo merge() è:

hashmap.merge(key, value, remappingFunction)

parametri di merge()

Il metodo merge() di hashmap utilizza 3 parametri:

• key - Specificare il valore associato alla chiave
  

• value - Se key è già associato a qualsiasi valore, è necessario associare il valore associato a key

• remappingFunction - Se la chiave è già associata a un valore, il risultato è associato alla chiave.

valore di merge()

• Restituisce il nuovo valore associato alla chiave (key)

• Se non esiste un valore associato alla chiave (key), restituisce null
  

AttenzioneSe il risultato della remappingFunction è null, la mappa mapperà la chiave specificata.

Esempio 1: HashMap merge() inserire un nuovo elemento

import java.util.HashMap;
class Main {}}
　　public static void main(String[] args) {
　　　　//Crea una HashMap
　　　　HashMap<String, Integer> prices = new HashMap<>();
　　　　//Inserisce una voce nella HashMap
　　　　prices.put("Shoes", 200);
　　　　prices.put("Bag", 300);
　　　　prices.put("Pant", 150);
　　　　System.out.println("HashMap: " + prices);
　　　　int returnedValue = prices.merge("Shirt", 100, (oldValue, newValue) -> oldValue + newValue);
　　　　System.out.println("Prezzo della camicia: " + returnedValue);
　　　　// Stampa HashMap aggiornata
　　　　System.out.println("HashMap aggiornata: " + prices);
　　}
}

Risultato di output

HashMap: {Pant=150, Bag=300, Shoes=200}
Prezzo della camicia: 100
HashMap aggiornata: {Pant=150, Shirt=100, Bag=300, Shoes=200}

Nell'esempio sopra, abbiamo creato una mappa hash chiamata prices. Notare l'espressione

prices.merge("Shirt", 100, (oldValue, newValue) -> oldValue + newValue)

In questo caso, abbiamo utilizzato l'espressione lambda (oldValue, newValue) -> oldValue + newValue) come funzione remappingFunction. Per ulteriori informazioni sull'espressione lambda, visitareEspressioni Lambda Java.

Poiché la chiave Shirt non esiste in prices, il metodo merge() inserirà Shirt=100 nella mappa. E il risultato della remappingFunction sarà ignorato.

Esempio 2: HashMap merge() inserire un elemento con chiave duplicata

import java.util.HashMap;
class Main {}}
　　public static void main(String[] args) {
　　　　// Creare HashMap
　　　　HashMap<String, String> countries = new HashMap<>();
　　　　// Inserisci elementi nel HashMap
　　　　countries.put("Washington", "America");
　　　　countries.put("Canberra", "Australia");
　　　　countries.put("Madrid", "Spain");
　　　　System.out.println("HashMap: " + countries);
　　　　// Mappatura di merge per la chiave Washington
　　　　String returnedValue = countries.merge("Washington", "USA", (oldValue, newValue) -> oldValue + "/" + newValue);
　　　　System.out.println("Washington: " + returnedValue);
　　　　// Stampa HashMap aggiornato
　　　　System.out.println("HashMap aggiornato: " + countries);
　　}
}

Risultato di output

HashMap: {Madrid=Spain, Canberra=Australia, Washington=America}
Washington: America/USA
HashMap aggiornato: {Madrid=Spain, Canberra=Australia, Washington=America/USA},

Nell'esempio sopra, abbiamo creato una mappa hash chiamata countries. Notare l'espressione

countries.merge("Washington", "USA", (oldValue, newValue) -> oldValue + "/" + newValue)

In questo caso, abbiamo utilizzato l'espressione lambda (oldValue, newValue) -> oldValue + "/" + newValue) come remappingFunction.

Poiché la chiave Washington esiste già in countries, il vecchio valore sarà sostituito dal valore restituito da remappingFunction. Pertanto, la mappatura di Washington include il valore America/USA.

Esempio 3: merge() di HashMap unisce due HashMap

import java.util.HashMap;
class Main {}}
　　public static void main(String[] args) {
　　　　//Crea una HashMap
　　　　HashMap<String, Integer> prices1 = new HashMap<>();
　　　　//Inserisce una voce nella HashMap
　　　　prices1.put("Pant", 230);
　　　　prices1.put("Shoes", 350);
　　　　System.out.println("HashMap 1: " + prices1);
　　　　//Crea un'altra hashmap
　　　　HashMap<String, Integer> prices2 = new HashMap<>();
　　　　//Inserisce una voce nella HashMap
　　　　prices2.put("Shirt", 150);
　　　　prices2.put("Shoes", 320);
　　　　System.out.println("HashMap 2: " + prices2);
　　　　//forEach() accede a ogni voce di prices2
　　　　//merge() inserisce ogni voce da prices2 in prices1
　　　　prices2.forEach((key, value) -> prices1.merge(key, value, (oldValue, newValue) -> {
　　　　　　
　　　　　　//Restituisce il valore più piccolo
　　　　　　if (oldValue < newValue) {
　　　　　　　　return oldValue;
　　　　　　}
　　　　　　else {
　　　　　　　　return newValue;
　　　　　　}
　　　　});
　　　　System.out.println("HashMap unito: " + prices1);
　　}
}

Risultato di output

HashMap 1: {Pant=230, Shoes=350}
HashMap 2: {Shirt=150, Shoes=320}
HashMap unito: {Pant=230, Shirt=150, Shoes=320}

Nel seguente esempio, abbiamo creato due mappe hash chiamate prices1 e prices2. Notare il codice:

　　　　prices2.forEach((key, value) -> prices1.merge(key, value, (oldValue, newValue) -> {
　　　　　　if (oldValue < newValue) {
　　　　　　　　return oldValue;
　　　　　　}
　　　　　　else {
　　　　　　　　return newValue;
　　　　　　}
　　　　});

Qui,HashMap forEach()Metodo che accede a ogni voce della hash table prices2 e la unisce alla hash table prices1. Abbiamo utilizzato due espressioni lambda:

• (key, value) -> prices.merge(...) - Accede a ogni voce di prices1 e la passinga al metodo merge().

• (oldValue, newValue) -> {...}　 - Questa è una funzione di rimappatura (remappingFunction). Confronta due valori e restituisce il valore più piccolo.

Poiché la chiave Shoes esiste in entrambe le mappe hash, il valore di Shoes viene sostituito dal risultato della funzione di rimappatura (remappingFunction).

Java HashMap merge() e putAll()

Possiamo anche utilizzare il metodo putAll() per combinare due mappe hash. Ma se entrambe le mappe hash contengono la chiave, il valore vecchio sarà sostituito dal valore nuovo

Diversamente da merge(), il metodo putAll() non offre la funzione di rimappatura. Pertanto, non possiamo determinare il valore da memorizzare per le chiavi ripetute.

Per ulteriori informazioni sulla metodo putAll(), visitareJava HashMap putAll().

Metodi Java HashMap