Hoe de waarde van een bestaande sleutel in HashMap bij te werken

U weet dat er altijd een sleutel en een waarde is in HashMap of een andere kaart . Sleutel wordt niet voor niets een sleutel genoemd omdat u toegang krijgt tot waarden door de sleutel. De sleutel is uniek, maar de waarde niet. U kunt dus geen sleutel op waarde krijgen omdat waarden kunnen worden gedupliceerd. In dit artikel gaan we ontdekken hoe we de waarde van een bestaande sleutel in HashMap in Java kunnen bijwerken. Laten we de Java-syntaxis onthouden. HashMap in Java wordt op de volgende manier gedeclareerd:

 HashMap<Key, Value> name

Laten we een voorbeeld nemen. Stel, we hebben vier vrienden en speciaal voor hen hebben we een HashMap gemaakt en ingevuld met hun namen. Hun sleutels zijn gehele getallen.

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

Let op: je kunt je kaart op verschillende manieren maken en invullen . Bijvoorbeeld met behulp van het initialisatieblok. Hier is het:

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

Of gebruik van een methode en een HashMap-constructor met het andere kaartargument . Deze methode is beschikbaar vanaf versie 9 en later.

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

Zoals we al eerder zeiden, zijn in onze HashMap- sleutels gehele getallen en bevatten de waarden enkele tekenreeksen, in ons geval namen van tekens. Nou, laten we zeggen dat er iets ergs met Kenny is gebeurd (de lezers die de tekenfilmserie South Park kennen, weten zeker dat er vrij vaak iets ergs met Kenny is gebeurd). Dus als het gebeurt, moeten we Kenny uit dit bedrijf (onze HashMap ) verwijderen en hem vervangen door een andere vriend, bijvoorbeeld Butters. Dit is heel gemakkelijk omdat het een bewerking is om de waarde bij te werken. Onze Kenny jongen heeft een sleutel == 3 . We moeten de waarde voor toets 3 wijzigen, waar Kenny zich bevindt. We kunnen de methode put() gebruiken om dit te doen:

names.put(3, "Butters");

Als we in dit geval onze kaart op het scherm weergeven, is het resultaat als volgt:

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

Wat als alles in orde is met Kenny en we hem in het gezelschap willen houden, maar we een reden hebben om zijn sleutel bij te werken? Stel, hij is niet meer nummer drie, maar nummer vijf. Laten we Kenny gewoon weer op onze kaart zetten met toets 5 en het resultaat printen. We kunnen de put- methode goed gebruiken . Hier is de volledige code voor dit voorbeeld:

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);
   }
}

Je raadt waarschijnlijk al wat het resultaat zal zijn:

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

Is dit waarvoor we werden verwacht? Nu heeft Kenny twee sleutels in onze HashMap . Strikt genomen zijn dit twee verschillende Kenny's, wat we ook bedoelen, aangezien ons doel op unieke wijze wordt bepaald door de sleutel. Het is als het paspoort van een persoon, het moet uniek zijn. U kunt de hashmap-sleutel dus niet zomaar hernoemen of bijwerken nadat deze rechtstreeks is toegevoegd. Deze bewerking is gewoon niet beschikbaar. U kunt echter een misleidende manoeuvre maken: voeg een nieuwe invoer in met de nieuwe sleutel en verwijder de oude. Dit kan worden gedaan met behulp van de HashMap- verwijdermethode . remove() verwijdert niet alleen de associatie, maar retourneert ook de verwijderde waarde (als die er eerder was). Laten we ons voorbeeld aanvullen met deze bewerking:

//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);
   }
}

Nu hebben we eindelijk wat we nodig hadden, de sleutel bijgewerkt waarmee we Kenny kunnen vinden. Hier is de uitvoer: Natuurlijk kunnen we de bewerkingen uitvoeren van het verwijderen van de "oude" Kenny en het toevoegen van een nieuwe in willekeurige volgorde. Ze zijn in wezen onafhankelijk. Of verkort uw code met slechts één regel:

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

Het resultaat zal zeker hetzelfde zijn. Dus de enige juiste manier om een ​​sleutel in Java HashMap te wijzigen , is door de invoer te verwijderen en dezelfde waarde in te voegen met een nieuwe sleutel. Je kunt het op een andere manier doen, maar het zal bijna hetzelfde verhaal zijn over het toevoegen en verwijderen van een element.