Java HashMap merge ()

Il metodo Java HashMap merge () inserisce la mappatura chiave / valore specificata nella hashmap se la chiave specificata non è già presente.

Se la chiave specificata è già associata a un valore, il metodo sostituisce il vecchio valore con il risultato della funzione specificata.

La sintassi del merge()metodo è:

 hashmap.merge(key, value, remappingFunction)

In questo caso, hashmap è un oggetto della HashMapclasse.

parametri merge ()

Il merge()metodo richiede 3 parametri:

  • chiave - chiave a cui associare il valore specificato
  • valore - valore da associare alla chiave, se la chiave è già associata a qualsiasi valore
  • remappingFunction - risultato da associare alla chiave se la chiave è già associata a un valore

merge () Valore restituito

  • restituisce il nuovo valore associato alla chiave
  • restituisce nullse nessun valore è associato alla chiave

Nota : se si ottiene remappingFunction null, la mappatura per la chiave specificata viene rimossa.

Esempio 1: HashMap merge () per inserire una nuova voce

 import java.util.HashMap; class Main ( public static void main(String() args) ( // create an HashMap HashMap prices = new HashMap(); // insert entries to the 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("Price of Shirt: " + returnedValue); // print updated HashMap System.out.println("Updated HashMap: " + prices); ) )

Produzione

 HashMap: (Pantaloni = 150, Borsa = 300, Scarpe = 200) Prezzo della camicia: 100 HashMap aggiornata: (Pantaloni = 150, Camicia = 100, Borsa = 300, Scarpe = 200)

Nell'esempio sopra, abbiamo creato una hashmap denominata prezzi. Notare l'espressione,

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

Qui abbiamo usato l'espressione lambda, (oldValue, newValue) -> oldValue + newValue)come funzione di rimappatura. Per ulteriori informazioni sull'espressione lambda, visita Java Lambda Expressions.

Poiché la chiave Shirt non è presente nei prezzi, il merge()metodo inserisce la mappatura Shirt=100. Inoltre, il risultato della funzione di rimappatura viene ignorato.

Esempio 2: HashMap merge () per inserire una voce con chiave duplicata

 import java.util.HashMap; class Main ( public static void main(String() args) ( // create an HashMap HashMap countries = new HashMap(); // insert entries to the HashMap countries.put("Washington", "America"); countries.put("Canberra", "Australia"); countries.put("Madrid", "Spain"); System.out.println("HashMap: " + countries); // merge mapping for key Washington String returnedValue = countries.merge("Washington", "USA", (oldValue, newValue) -> oldValue + "/" + newValue); System.out.println("Washington: " + returnedValue); // print updated HashMap System.out.println("Updated HashMap: " + countries); ) )

Produzione

 HashMap: (Madrid = Spagna, Canberra = Australia, Washington = America) Washington: America / USA HashMap aggiornata: (Madrid = Spagna, Canberra = Australia, Washington = America / USA),

Nell'esempio sopra, abbiamo creato una hashmap denominata paesi. Notare l'espressione,

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

Qui abbiamo usato l'espressione lambda, (oldValue, newValue) -> oldValue + "/" + newValue)come funzione di rimappatura.

Poiché la chiave Washington è già presente nei paesi, il vecchio valore viene sostituito dal valore restituito dalla funzione di rimappatura. Quindi, la mappatura per Washington include il valore America / USA.

Esempio 3: HashMap merge () per unire due HashMap

 import java.util.HashMap; class Main ( public static void main(String() args) ( // create an HashMap HashMap prices1 = new HashMap(); // insert entries to the HashMap prices1.put("Pant", 230); prices1.put("Shoes", 350); System.out.println("HashMap 1: " + prices1); // create another hashmap HashMap prices2 = new HashMap(); //insert entries to the HashMap prices2.put("Shirt", 150); prices2.put("Shoes", 320); System.out.println("HashMap 2: " + prices2); // forEach() access each entries of prices2 // merge() inserts each entry from prices2 to prices1 prices2.forEach((key, value) -> prices1.merge(key, value, (oldValue, newValue) -> ( // return the smaller value if (oldValue < newValue) ( return oldValue; ) else ( return newValue; ) ))); System.out.println("Merged HashMap: " + prices1); ) )

Produzione

 HashMap 1: (Pant = 230, Shoes = 350) HashMap 2: (Shirt = 150, Shoes = 320) Merged HashMap: (Pant = 230, Shirt = 150, Shoes = 320)

Nell'esempio precedente, abbiamo creato due hashmap denominate price1 e prices2. Notare il codice,

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

Qui, il metodo HashMap forEach () accede a ciascuna voce dei prezzi hashmap2 e la unisce ai prezzi hashmap1. Abbiamo usato due espressioni lambda:

  • (chiave, valore) -> prices.merge (…) - Accede a ciascuna voce di prices1 e la passa al merge()metodo.
  • (oldValue, newValue) -> (…) - È una funzione di rimappatura. Confronta due valori e restituisce il valore più piccolo.

Poiché la chiave Shoes è presente in entrambe le hashmap, il valore di Shoes viene sostituito dal risultato della funzione di rimappatura.

Java HashMap merge () vs. metti tutto

Possiamo anche usare il putAll()metodo per unire due hashmap. Tuttavia, se una chiave è presente in entrambe le hashmap, il vecchio valore viene sostituito dal nuovo valore.

A differenza di merge(), il putAll()metodo non fornisce la funzione di rimappatura. Pertanto, non possiamo decidere quale valore memorizzare per le chiavi duplicate.

Per saperne di più sul putAll()metodo, visita Java HashMap putAll ().

Articoli interessanti...