Paano i-update ang halaga ng isang umiiral na key sa HashMap

Alam mo na palaging may susi at halaga sa HashMap o anumang iba pang Map . Ang susi ay tinatawag na susi para sa isang dahilan dahil nakakakuha ka ng access sa mga halaga sa pamamagitan ng susi. Ang susi ay natatangi, ngunit ang halaga ay hindi. Kaya hindi ka makakakuha ng isang susi ayon sa halaga dahil ang mga halaga ay maaaring ma-duplicate. Sa artikulong ito, malalaman natin kung paano i-update ang halaga ng isang umiiral na key sa HashMap sa Java. Tandaan natin ang Java syntax. Ang HashMap sa Java ay ipinahayag sa susunod na paraan:

 HashMap<Key, Value> name

Kumuha tayo ng isang halimbawa. Sabihin nating, mayroon kaming apat na kaibigan at lalo na para sa kanila gumawa kami at nilagyan ng HashMap ng kanilang mga pangalan. Ang kanilang mga susi ay mga integer na numero.

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

Tandaan: maaari kang lumikha at punan ang iyong Mapa sa iba't ibang paraan. Halimbawa, gamit ang initialization block. Heto na:

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

O paggamit ng isang paraan at isang HashMap constructor kasama ang iba pang argumento ng mapa . Available ang paraang ito mula sa bersyon 9 at mas bago.

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

Tulad ng sinabi namin dati, sa aming mga HashMap key ay mga integer na numero, at ang mga halaga ay naglalaman ng ilang mga string, sa aming kaso, mga pangalan ng mga character. Well, sabihin na nating may nangyaring masama kay Kenny (yung mga readers na nakakaalam ng South Park cartoon series, siguradong may nangyaring masama kay Kenny medyo madalas). Kaya kapag nangyari ito, kailangan nating alisin si Kenny sa kumpanyang ito (aming HashMap ), at palitan siya ng isa pang kaibigan, sabihin nating, sa pangalan ng Butters. Ito ay napakadaling gawin dahil ito ay isang pagpapatakbo ng halaga ng pag-update. May susi ang ating Kenny boy == 3 . Kailangan nating baguhin ang halaga para sa key 3, kung saan matatagpuan ang Kenny. Maaari naming gamitin ang put() na pamamaraan upang gawin ito:

names.put(3, "Butters");

Sa kasong ito, kung ipapakita namin ang aming mapa sa screen, ang resulta ay ang mga sumusunod:

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

Paano kung maayos na ang lahat kay Kenny at gusto naming manatili siya sa kumpanya, ngunit mayroon kaming dahilan upang i-update ang kanyang susi? Sabihin, hindi na siya number three, kundi number five. Ilagay na lang natin ulit si Kenny sa ating mapa gamit ang key 5 at i-print ang resulta. Magagamit natin ng maayos ang put method. Narito ang kumpletong code para sa halimbawang ito:

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

Marahil ay nahulaan mo na kung ano ang magiging resulta:

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

Ito ba ang inaasahan natin? Ngayon ay may dalawang susi si Kenny sa aming HashMap . Well, mahigpit na pagsasalita, ito ay dalawang magkaibang Kenny, anuman ang ibig nating sabihin, dahil ang ating bagay ay natatanging tinutukoy ng susi. Parang passport ng isang tao, unique dapat. Kaya hindi mo na lang palitan ang pangalan o i-update ang hashmap key kapag direktang naidagdag. Ang operasyong ito ay hindi magagamit. Gayunpaman, maaari kang gumawa ng mapanlinlang na maniobra: magpasok ng bagong entry gamit ang bagong key at tanggalin ang luma. Magagawa ito gamit ang paraan ng pag-alis ng HashMap . remove() hindi lamang inaalis ang asosasyon ngunit ibinabalik din ang tinanggal na halaga (kung ito ay naroon noon). Dagdagan natin ang ating halimbawa ng operasyong ito:

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

Ngayon ay nakuha na namin ang kailangan namin, na-update ang susi kung saan namin mahahanap si Kenny. Narito ang output: Siyempre, maaari naming isagawa ang mga operasyon ng pag-alis ng "lumang" Kenny at pagdaragdag ng bago sa anumang pagkakasunud-sunod. Sila ay mahalagang independyente. O paikliin ang iyong code gamit lamang ang isang linya:

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

Magiging pareho ang resulta para sigurado. Kaya, ang tanging tamang paraan ng pagpapalit ng key sa Java HashMap ay ang tanggalin ang entry at ipasok ang parehong halaga gamit ang isang bagong key. Magagawa mo ito sa ibang paraan ngunit ito ay halos magkaparehong kuwento tungkol sa pagdaragdag at pag-alis ng isang elemento.