Come aggiornare il valore di una chiave esistente in HashMap

Sai che c'è sempre una chiave e un valore in HashMap o in qualsiasi altra mappa . La chiave è chiamata chiave per un motivo perché si ottiene l'accesso ai valori tramite la chiave. La chiave è univoca, ma il valore non lo è. Quindi non puoi ottenere una chiave per valore perché i valori possono essere duplicati. In questo articolo scopriremo come aggiornare il valore di una chiave esistente in HashMap in Java. Ricordiamo la sintassi Java. HashMap in Java è dichiarato nel modo seguente:

 HashMap<Key, Value> name

Facciamo un esempio. Diciamo che abbiamo quattro amici e specialmente per loro abbiamo creato e compilato una HashMap con i loro nomi. Le loro chiavi sono numeri interi.

Map<Integer, String> names = new HashMap<Integer, String>();
       names.put(1, "Stan");
       names.put(2, "Kyle");
       names.put(3, "Kenny");
       names.put(4, "Cartman");

Nota: puoi creare e compilare la tua mappa in diversi modi. Ad esempio, utilizzando il blocco di inizializzazione. Ecco qui:

Map<Integer, String> names = new HashMap<Integer, String>() {
           {
               put(1, "Stan");
               put(2, "Kyle");
               put(3, "Kenny");
               put(4, "Cartman");
           }
       };

O usando un metodo e un costruttore HashMap con l'altro argomento map . Questo metodo è disponibile dalla versione 9 e successive.

Map<Integer, String> names = new HashMap<>(Map.of(1, "Stan", 2, "Kyle", 3, "Kenny", 4, "Cartman"));

Come abbiamo detto prima, nella nostra HashMap le chiavi sono numeri interi, e i valori contengono delle stringhe, nel nostro caso nomi di caratteri. Bene, diciamo che è successo qualcosa di brutto a Kenny (quei lettori che conoscono la serie di cartoni animati di South Park, sanno per certo che a Kenny è successo qualcosa di brutto abbastanza spesso). Quindi, quando succede, dobbiamo rimuovere Kenny da questa azienda (la nostra HashMap ) e sostituirlo con un altro amico, diciamo, di nome Butters. Questo è molto facile da fare perché è un'operazione di aggiornamento del valore. Il nostro ragazzo Kenny ha una chiave == 3 . Dobbiamo cambiare il valore per la chiave 3, dove si trova Kenny. Possiamo usare il metodo put() per fare questo:

names.put(3, "Butters");

In questo caso, se visualizziamo la nostra mappa sullo schermo, il risultato sarà il seguente:

{1=Stan, 2=Kyle, 3=Butters, 4=Cartman}

E se a Kenny va tutto bene e vogliamo tenerlo in compagnia, ma abbiamo un motivo per aggiornare la sua chiave? Dì, non è più il numero tre, ma il numero cinque. Inseriamo di nuovo Kenny nella nostra mappa con il tasto 5 e stampiamo il risultato. Possiamo usare bene il metodo put . Ecco il codice completo per questo esempio:

import java.util.HashMap;

public class HashMapUpdKey {
   public static void main(String[] args) {
       Map<Integer, String> names = new HashMap<>(Map.of(1, "Stan", 2, "Kyle", 3, "Kenny", 4, "Cartman"));
       names.put(5, "Kenny");
       System.out.println(names);
   }
}

Probabilmente hai già indovinato quale sarà il risultato:

{1=Stan, 2=Kyle, 3=Kenny, 4=Cartman, 5=Kenny}

È per questo che ci aspettavamo? Ora Kenny ha due chiavi nella nostra HashMap . Bene, in senso stretto, questi sono due Kenny diversi, qualunque cosa intendiamo, poiché il nostro oggetto è determinato in modo univoco dalla chiave. È come il passaporto di una persona, dovrebbe essere unico. Quindi non puoi semplicemente rinominare o aggiornare la chiave hashmap una volta aggiunta direttamente. Questa operazione semplicemente non è disponibile. Tuttavia, puoi fare una manovra ingannevole: inserire una nuova voce con la nuova chiave ed eliminare quella vecchia. Questo può essere fatto usando il metodo di rimozione HashMap . remove() non solo rimuove l'associazione ma restituisce anche il valore cancellato (se era presente prima). Completiamo il nostro esempio con questa operazione:

//easy replacement example
import java.util.HashMap;

public class HashMapUpdKey {
   public static void main(String[] args) {
      Map<Integer, String> names = new HashMap<>(Map.of(1, "Stan", 2, "Kyle", 3, "Kenny", 4, "Cartman"));
           
       names.put(5, "Kenny"); //Adding “new” Kenny 
       System.out.println(names.remove(3)); //Update value of the key: Removing “old” Kenny and print out deleted value

       System.out.println(names);
   }
}

Ora abbiamo finalmente ciò di cui avevamo bisogno, aggiornata la chiave con cui possiamo trovare Kenny. Ecco l'output: Naturalmente, possiamo eseguire le operazioni di rimozione del "vecchio" Kenny e aggiungerne uno nuovo in qualsiasi ordine. Sono essenzialmente indipendenti. Oppure accorcia il tuo codice usando solo una riga:

names.put(5, names.remove(3));

Il risultato sarà sicuramente lo stesso. Quindi, l'unico modo corretto per modificare una chiave in Java HashMap è eliminare la voce e inserire lo stesso valore con una nuova chiave. Puoi farlo in un modo diverso, ma sarà quasi la stessa storia sull'aggiunta e la rimozione di un elemento.