HashMapలో ఇప్పటికే ఉన్న కీ విలువను ఎలా అప్‌డేట్ చేయాలి

HashMap లేదా మరేదైనా మ్యాప్‌లో ఎల్లప్పుడూ కీ మరియు విలువ ఉంటుందని మీకు తెలుసు . కీని ఒక కారణం కోసం కీ అని పిలుస్తారు ఎందుకంటే మీరు కీ ద్వారా విలువలకు ప్రాప్యత పొందుతారు. కీ ప్రత్యేకమైనది, కానీ విలువ కాదు. కాబట్టి మీరు విలువ ద్వారా కీని పొందలేరు ఎందుకంటే విలువలు నకిలీ చేయబడతాయి. ఈ ఆర్టికల్‌లో, జావాలోని హాష్‌మ్యాప్‌లో ఇప్పటికే ఉన్న కీ విలువను ఎలా అప్‌డేట్ చేయాలో మనం కనుగొనబోతున్నాం . జావా సింటాక్స్‌ని గుర్తుంచుకోండి. జావాలో HashMap క్రింది విధంగా ప్రకటించబడింది:

 HashMap<Key, Value> name

ఒక ఉదాహరణ తీసుకుందాం. చెప్పండి, మాకు నలుగురు స్నేహితులు ఉన్నారు మరియు ప్రత్యేకంగా వారి కోసం మేము వారి పేర్లతో HashMapని సృష్టించాము మరియు నింపాము. వారి కీలు పూర్ణాంక సంఖ్యలు.

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

గమనిక: మీరు మీ మ్యాప్‌ను వివిధ మార్గాల్లో సృష్టించవచ్చు మరియు పూరించవచ్చు . ఉదాహరణకు, ప్రారంభ బ్లాక్ ఉపయోగించి. ఇది ఇక్కడ ఉంది:

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

లేదా ఇతర మ్యాప్ ఆర్గ్యుమెంట్‌తో ఒక పద్ధతి మరియు HashMap కన్స్ట్రక్టర్‌ని ఉపయోగించడం . ఈ పద్ధతి వెర్షన్ 9 మరియు తరువాతి నుండి అందుబాటులో ఉంది.

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

మేము ముందే చెప్పినట్లుగా, మా HashMap కీలలో పూర్ణాంకం సంఖ్యలు ఉంటాయి మరియు విలువలు కొన్ని స్ట్రింగ్‌లను కలిగి ఉంటాయి, మన విషయంలో, అక్షరాల పేర్లు. సరే, కెన్నీకి ఏదో చెడు జరిగిందని అనుకుందాం (సౌత్ పార్క్ కార్టూన్ సిరీస్ తెలిసిన పాఠకులకు, కెన్నీకి చాలా తరచుగా చెడు జరిగిందని ఖచ్చితంగా తెలుసు). కనుక ఇది జరిగినప్పుడు మేము కెన్నీని ఈ కంపెనీ (మా హాష్‌మ్యాప్ ) నుండి తీసివేయాలి మరియు అతని స్థానంలో బటర్స్ పేరుతో మరొక స్నేహితుడిని పెట్టాలి. ఇది అప్‌డేట్ వాల్యూ ఆపరేషన్ అయినందున దీన్ని చేయడం చాలా సులభం. మా కెన్నీ అబ్బాయి దగ్గర ఒక కీ == 3 ఉంది . కెన్నీ ఉన్న కీ 3 కోసం మనం విలువను మార్చాలి. దీన్ని చేయడానికి మనం పుట్ () పద్ధతిని ఉపయోగించవచ్చు :

names.put(3, "Butters");

ఈ సందర్భంలో, మేము స్క్రీన్‌పై మా మ్యాప్‌ని ప్రదర్శిస్తే, ఫలితం క్రింది విధంగా ఉంటుంది:

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

కెన్నీతో అంతా బాగానే ఉంటే మరియు మేము అతనిని కంపెనీలో ఉంచాలనుకుంటే, అతని కీని అప్‌డేట్ చేయడానికి మాకు కారణం ఉందా? చెప్పండి, అతను ఇప్పుడు నంబర్ త్రీ కాదు, ఐదవ నంబర్. కీ 5తో కెన్నీని మళ్లీ మన మ్యాప్‌లో ఉంచి, ఫలితాన్ని ప్రింట్ చేద్దాం. మనం పుట్ పద్ధతిని బాగా ఉపయోగించుకోవచ్చు . ఈ ఉదాహరణ కోసం పూర్తి కోడ్ ఇక్కడ ఉంది:

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

ఫలితం ఎలా ఉంటుందో మీరు బహుశా ఇప్పటికే ఊహించి ఉంటారు:

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

మనం ఊహించినది ఇదేనా? ఇప్పుడు కెన్నీకి మా హాష్‌మ్యాప్‌లో రెండు కీలు ఉన్నాయి . బాగా, ఖచ్చితంగా చెప్పాలంటే, ఇవి రెండు వేర్వేరు కెన్నీలు, మన ఉద్దేశ్యం ఏదైనా, ఎందుకంటే మన వస్తువు ప్రత్యేకంగా కీ ద్వారా నిర్ణయించబడుతుంది. ఇది ఒక వ్యక్తి పాస్‌పోర్ట్ లాంటిది, ఇది ప్రత్యేకంగా ఉండాలి. కాబట్టి మీరు హ్యాష్‌మ్యాప్ కీని నేరుగా జోడించిన తర్వాత పేరు మార్చలేరు లేదా నవీకరించలేరు. ఈ ఆపరేషన్ కేవలం అందుబాటులో లేదు. అయితే, మీరు మోసపూరిత యుక్తిని చేయవచ్చు: కొత్త కీతో కొత్త ఎంట్రీని చొప్పించండి మరియు పాతదాన్ని తొలగించండి. ఇది HashMap తొలగింపు పద్ధతిని ఉపయోగించి చేయవచ్చు . remove() అనుబంధాన్ని తీసివేయడమే కాకుండా తొలగించబడిన విలువను కూడా అందిస్తుంది (అది ఇంతకు ముందు ఉంటే). ఈ ఆపరేషన్‌తో మన ఉదాహరణను అనుబంధిద్దాం:

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

ఇప్పుడు మేము చివరకు మనకు అవసరమైనదాన్ని పొందాము, కెన్నీని కనుగొనగలిగే కీని నవీకరించాము. ఇక్కడ అవుట్‌పుట్ ఉంది: వాస్తవానికి, మేము "పాత" కెన్నీని తొలగించి, ఏదైనా క్రమంలో కొత్తదాన్ని జోడించే కార్యకలాపాలను నిర్వహించగలము. వారు తప్పనిసరిగా స్వతంత్రంగా ఉంటారు. లేదా ఒకే ఒక లైన్ ఉపయోగించి మీ కోడ్‌ని తగ్గించండి:

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

ఫలితం ఖచ్చితంగా అలాగే ఉంటుంది. కాబట్టి, జావా హాష్‌మ్యాప్‌లో కీని మార్చడానికి ఏకైక సరైన మార్గం ఎంట్రీని తొలగించి, అదే విలువను కొత్త కీతో చొప్పించడం. మీరు దీన్ని వేరే విధంగా చేయవచ్చు కానీ ఒక మూలకాన్ని జోడించడం మరియు తీసివేయడం గురించి దాదాపు అదే కథనం.