HashMap இல் ஏற்கனவே உள்ள விசையின் மதிப்பை எவ்வாறு புதுப்பிப்பது

HashMap அல்லது வேறு எந்த வரைபடத்திலும் எப்போதும் ஒரு விசையும் மதிப்பும் இருப்பதை நீங்கள் அறிவீர்கள் . விசை ஒரு காரணத்திற்காக விசை என்று அழைக்கப்படுகிறது, ஏனெனில் நீங்கள் விசையின் மூலம் மதிப்புகளை அணுகலாம். முக்கிய தனித்துவமானது, ஆனால் மதிப்பு இல்லை. எனவே மதிப்புகளின் அடிப்படையில் ஒரு விசையை நீங்கள் பெற முடியாது, ஏனெனில் மதிப்புகள் நகலெடுக்கப்படலாம். இந்த கட்டுரையில், ஜாவாவில் உள்ள ஹாஷ்மேப்பில் ஏற்கனவே உள்ள விசையின் மதிப்பை எவ்வாறு புதுப்பிப்பது என்பதைக் கண்டுபிடிக்கப் போகிறோம் . ஜாவா தொடரியல் நினைவில் கொள்வோம். ஜாவாவில் ஹாஷ்மேப் பின்வரும் வழியில் அறிவிக்கப்படுகிறது:

 HashMap<Key, Value> name

ஒரு உதாரணத்தை எடுத்துக் கொள்வோம். சொல்லுங்கள், எங்களிடம் நான்கு நண்பர்கள் உள்ளனர், குறிப்பாக அவர்களுக்காக நாங்கள் அவர்களின் பெயர்களுடன் ஹாஷ்மேப்பை உருவாக்கி நிரப்பினோம். அவர்களின் விசைகள் முழு எண்கள்.

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

அல்லது மற்ற வரைபட வாதத்துடன் ஒரு முறை மற்றும் ஹாஷ்மேப் கட்டமைப்பாளரைப் பயன்படுத்துதல் . இந்த முறை பதிப்பு 9 மற்றும் அதற்குப் பிறகு கிடைக்கும்.

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

நாங்கள் முன்பு கூறியது போல், எங்கள் ஹாஷ்மேப் விசைகளில் முழு எண்கள் உள்ளன, மேலும் மதிப்புகளில் சில சரங்கள் உள்ளன, எங்கள் விஷயத்தில், எழுத்துக்களின் பெயர்கள். சரி, கென்னிக்கு ஏதோ மோசமான விஷயம் நடந்தது என்று வைத்துக் கொள்வோம் (சவுத் பார்க் கார்ட்டூன் தொடரை அறிந்த வாசகர்கள், கென்னிக்கு அடிக்கடி ஏதாவது கெட்டது நடந்திருக்கிறது என்பது உறுதியாகத் தெரியும்). அது நிகழும்போது, ​​கென்னியை இந்த நிறுவனத்திலிருந்து (எங்கள் ஹாஷ்மேப் ) அகற்றிவிட்டு , அவருக்குப் பதிலாக வேறொரு நண்பரை பட்டர்ஸ் என்ற பெயரில் நியமிக்க வேண்டும். இது ஒரு புதுப்பிப்பு மதிப்பு செயல்பாடு என்பதால் இதைச் செய்வது மிகவும் எளிதானது. நம்ம கென்னி பையனிடம் ஒரு சாவி == 3 . கென்னி அமைந்துள்ள கீ 3க்கான மதிப்பை மாற்ற வேண்டும். இதைச் செய்ய, நாம் put() முறையைப் பயன்படுத்தலாம் :

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}

நாம் எதிர்பார்த்தது இதுதானா? இப்போது கென்னிக்கு எங்கள் ஹாஷ்மேப்பில் இரண்டு விசைகள் உள்ளன . சரி, கண்டிப்பாகச் சொன்னால், இவை இரண்டு வெவ்வேறு கென்னிகள், நாம் எதைச் சொன்னாலும், நமது பொருள் தனித்துவமாக விசையால் தீர்மானிக்கப்படுகிறது. இது ஒரு நபரின் பாஸ்போர்ட் போன்றது, அது தனித்துவமாக இருக்க வேண்டும். எனவே ஹாஷ்மேப் விசையை நேரடியாகச் சேர்த்தவுடன் மறுபெயரிடவோ புதுப்பிக்கவோ முடியாது. இந்த செயல்பாடு வெறுமனே கிடைக்கவில்லை. இருப்பினும், நீங்கள் ஒரு ஏமாற்றும் சூழ்ச்சியை செய்யலாம்: புதிய விசையுடன் புதிய உள்ளீட்டைச் செருகவும், பழையதை நீக்கவும். ஹாஷ்மேப் அகற்றும் முறையைப் பயன்படுத்தி இதைச் செய்யலாம் . 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));

முடிவு நிச்சயம் ஒரே மாதிரி இருக்கும். எனவே, ஜாவா ஹாஷ்மேப்பில் ஒரு விசையை மாற்றுவதற்கான ஒரே சரியான வழி, உள்ளீட்டை நீக்கிவிட்டு அதே மதிப்பை புதிய விசையுடன் செருகுவதுதான். நீங்கள் அதை வேறு வழியில் செய்யலாம், ஆனால் ஒரு உறுப்பைச் சேர்ப்பது மற்றும் அகற்றுவது என்பது கிட்டத்தட்ட அதே கதையாக இருக்கும்.