ஹாஷ்மேப்: இது என்ன வகையான வரைபடம்?

வணக்கம்! இந்த பாடத்தில், Java HashMap இல் ஒரு நெருக்கமான மதிப்பாய்வை எடுப்போம் . முன்னதாக, தனிமங்கள் தாங்களாகவே சேமிக்கப்படும் தரவு கட்டமைப்புகளைப் படித்தோம். ஒரு வரிசை அல்லது ஒரு வரிசைப்பட்டியல் / லிங்க்ட்லிஸ்ட் , நாங்கள் சில கூறுகளை சேமித்து வைக்கிறோம். ஆனால் நம் பணி கொஞ்சம் மாறினால் என்ன செய்வது? பின்வரும் பணியை கற்பனை செய்து பாருங்கள்: ஒவ்வொரு நபரின் பெயரையும் பாஸ்போர்ட் எண்ணையும் சேமிக்கும் 100 நபர்களின் பட்டியலை உருவாக்கவும். கொள்கையளவில், இது மிகவும் கடினம் அல்ல. எடுத்துக்காட்டாக, நீங்கள் இரண்டையும் ஒரு சரத்தில் நிரப்பலாம், பின்னர் இந்த சரங்களின் பட்டியலை உருவாக்கலாம்: "Amelia Aguilar, 4211 717171". ஆனால் இந்த தீர்வு இரண்டு குறைபாடுகளைக் கொண்டுள்ளது. முதலில், பாஸ்போர்ட் எண் மூலம் தேடும் திறன் நமக்கு தேவைப்படலாம். இந்த தகவல் சேமிப்பக வடிவமைப்பில் இது சிக்கலாக இருக்கும். இரண்டாவதாக, ஒரே பாஸ்போர்ட் எண்ணுடன் இரண்டு வெவ்வேறு நபர்களை உருவாக்குவதை எதுவும் தடுக்காது. இது எங்கள் தீர்வின் மிகக் கடுமையான குறைபாடு. இதை ஒருபோதும் அனுமதிக்கக்கூடாது: ஒரே பாஸ்போர்ட் எண் இரண்டு பேரிடமும் இல்லை. ஒரு புதிய தரவு அமைப்பு எங்கள் உதவிக்கு வருகிறது: வரைபடம். இது "துணை வரிசை" என்றும் அழைக்கப்படுகிறது, ஆனால் இந்த சொல் எப்போதாவது பயன்படுத்தப்படுகிறது. பொதுவாக, இது "அகராதி" அல்லது "வரைபடம்" என்று அழைக்கப்படுகிறது. :) நாம் முன்பு கருதிய தரவு கட்டமைப்புகளை விட இது எவ்வாறு அடிப்படையில் வேறுபட்டது? எல்லாவற்றிற்கும் மேலாக, வரைபடத்தில் உள்ள தரவு முக்கிய மதிப்பு ஜோடிகளாக சேமிக்கப்படுகிறது. எதுவும் விசைகள் மற்றும் மதிப்புகளாக செயல்படலாம்: எண்கள், சரங்கள் அல்லது பிற வகுப்புகளின் பொருள்கள். இன்று நாம் வரைபட வகுப்பின் மிகவும் பொதுவான செயலாக்கத்தைப் படிப்போம் : Java HashMap .

ஜாவாவில் ஹாஷ்மேப் பற்றி நாம் தெரிந்து கொள்ள வேண்டியது என்ன?

உருவாக்குவது மிகவும் எளிதானது:

public static void main(String[] args) {
   HashMap<Integer, String> passportsAndNames = new HashMap<>();
}

தனிமங்களை "number-string" ஜோடிகளாக சேமிக்கும் அகராதியை இங்கே உருவாக்குகிறோம். எண் விசையாகவும், சரம் மதிப்பாகவும் செயல்படும். மேலும் முக்கிய வகை (முழு எண்) மற்றும் மதிப்பு வகை (சரம்) ஆகியவற்றைக் குறிப்பிடுகிறோம். ஏன்? முதலில், ஹாஷ்மேப் விசை எப்போதும் தனித்துவமானது. பாஸ்போர்ட் எண்ணை முக்கியமாகப் பயன்படுத்தி, நகல்களைத் தவிர்க்கலாம் என்பதால், இது நமக்குப் பொருத்தமாக இருக்கிறது. மதிப்பு முழுப் பெயருடன் ஒரு சரமாக இருக்கும் (வெவ்வேறு நபர்கள் ஒரே பெயரைக் கொண்டிருக்கலாம்; அது பற்றி நாம் கவலைப்பட ஒன்றுமில்லை). HashMap இல் ஒரு புதிய ஜோடியைச் சேர்ப்பது இதுபோல் தெரிகிறது:

public class Main {

   public static void main(String[] args) {
       HashMap<Integer, String> passportsAndNames = new HashMap<>();

       passportsAndNames.put (212133, "Bridget Logan");
       passportsAndNames.put (162348, "Ivan the Great");
       passportsAndNames.put(8082771, "Donald John Trump");
       System.out.println(passportsAndNames);
   }
}

இதற்கு புட்() என்ற முறையைப் பயன்படுத்துகிறோம் . கூடுதலாக, HashMap toString() முறையை மேலெழுதுகிறது , எனவே இது கன்சோலில் காட்டப்படும். வெளியீடு இப்படி இருக்கும்: {212133=பிரிட்ஜெட் லோகன், 8082771=டொனால்ட் ஜான் டிரம்ப், 162348=இவான் தி கிரேட்} இப்போது விசைகள் உண்மையிலேயே தனித்துவமானதா என்பதைச் சரிபார்ப்போம்? வரைபடத்தில் ஏற்கனவே பயன்படுத்தப்பட்ட விசையுடன் புதிய உறுப்பைச் சேர்க்க முயற்சிப்போம் :

public static void main(String[] args) {
   HashMap<Integer, String> passportsAndNames = new HashMap<>();

   passportsAndNames.put (212133, "Bridget Logan");
   passportsAndNames.put (162348, "Ivan the Great");
   passportsAndNames.put(8082771, "Donald John Trump");
   passportsAndNames.put(162348, "Albert Kent");// This key has already been used
   System.out.println(passportsAndNames);
}

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

public static void main(String[] args) {
   HashMap<Integer, String> passportsAndNames = new HashMap<>();

   passportsAndNames.put (212133, "Bridget Logan");
   passportsAndNames.put (162348, "Ivan the Great");
   passportsAndNames.put(8082771, "Donald John Trump");

   String lidiaName = passportsAndNames.get(212133);
   System.out.println(lidiaName);

   passportsAndNames.remove(162348);
   System.out.println(passportsAndNames);
}

ஒரு மதிப்பைப் பெற அல்லது அகராதியிலிருந்து ஒரு ஜோடியை அகற்ற, நாம் get() க்கு அனுப்ப வேண்டும் மற்றும் மதிப்புடன் தொடர்புடைய தனிப்பட்ட விசையை அகற்ற வேண்டும் . வரிசைகள் மற்றும் பட்டியல்களைப் போலன்றி, ஜாவாவில் உள்ள ஹாஷ்மேப்பில் எண் குறியீடுகள் இல்லை: மதிப்புகள் விசையைப் பயன்படுத்தி அணுகப்படும். கன்சோல் வெளியீடு: பிரிட்ஜெட் லோகன் {212133= பிரிட்ஜெட் லோகன், 8082771=டொனால்ட் ஜான் டிரம்ப்} ArrayList மற்றும் LinkedList வகுப்புகள் பட்டியலில் ஏதேனும் குறிப்பிட்ட உறுப்பு உள்ளதா என்பதைச் சரிபார்க்கலாம். Java HashMap இதைச் செய்ய உதவுகிறது. மேலும் என்னவென்றால், இந்த ஜோடியின் இரு உறுப்பினர்களுக்கும் நாம் இதைச் செய்யலாம்: இதுவே இதில் உள்ளடங்கிய கீ() (ஒரு விசையை சரிபார்க்கிறது) மற்றும் உள்ளடக்கிய மதிப்பு()(மதிப்புக்கான காசோலைகள்) முறைகள்.

public static void main(String[] args) {
   HashMap<Integer, String> passportsAndNames = new HashMap<>();

   passportsAndNames.put (212133, "Bridget Logan");
   passportsAndNames.put (162348, "Ivan the Great");
   passportsAndNames.put(8082771, "Donald John Trump");

   System.out.println(passportsAndNames.containsKey(11111));
   System.out.println(passportsAndNames.containsValue("Donald John Trump"));
}

வெளியீடு: தவறான உண்மை ஜாவாவில் உள்ள ஹாஷ்மேப்பின் மற்றொரு வசதியான அம்சம் என்னவென்றால், நீங்கள் அனைத்து விசைகள் மற்றும் அனைத்து மதிப்புகளின் தனித்தனி பட்டியல்களைப் பெறலாம். இது keySet() மற்றும் values() முறைகள் மூலம் நிறைவேற்றப்படுகிறது :

public class Main {

   public static void main(String[] args) {
       HashMap<Integer, String> passportsAndNames = new HashMap<>();

       passportsAndNames.put (212133, "Bridget Logan");
       passportsAndNames.put (162348, "Ivan the Great");
       passportsAndNames.put(8082771, "Donald John Trump");

       Set keys = passportsAndNames.keySet();
       System.out.println("Keys: " + keys);

       ArrayList<String> values = new ArrayList<>(passportsAndNames.values());
       System.out.println("Values: " + values);
   }
}

விசைகள் ஒரு தொகுப்பில் பிரித்தெடுக்கப்படுகின்றன , அதை நாங்கள் இதுவரை மறைக்கவில்லை. இது மீண்டும் மீண்டும் கூறுகளைக் கொண்டிருக்க முடியாது என்பது சிறப்பு. இப்போது முக்கிய விஷயம் என்னவென்றால், அனைத்து விசைகளின் பட்டியலையும் ஹாஷ்மேப்பில் இருந்து ஒரு தனி சேகரிப்பில் மீட்டெடுக்க முடியும் என்பதை நினைவில் கொள்ள வேண்டும். எடுத்துக்காட்டில், மதிப்புகளை ஒரு சாதாரண வரிசைப்பட்டியலில் சேமித்தோம் . கன்சோல் வெளியீடு: விசைகள்: [212133, 8082771, 162348] மதிப்புகள்: [பிரிட்ஜெட் லோகன், டொனால்ட் ஜான் டிரம்ப், இவான் தி கிரேட்] அளவு () மற்றும் தெளிவான() முறைகள் நாம் விவாதித்த முந்தைய கட்டமைப்புகளைப் போலவே செயல்படுகின்றன: முதலாவது தற்போது அகராதியில் உள்ள உறுப்புகளின் எண்ணிக்கையை வழங்குகிறது, இரண்டாவது அனைத்து உறுப்புகளையும் நீக்குகிறது.

public static void main(String[] args) {
   HashMap<Integer, String> passportsAndNames = new HashMap<>();

   passportsAndNames.put (212133, "Bridget Logan");
   passportsAndNames.put (162348, "Ivan the Great");
   passportsAndNames.put(8082771, "Donald John Trump");

   System.out.println(passportsAndNames.size());
   passportsAndNames.clear();
   System.out.println(passportsAndNames);
}

வெளியீடு: 3 {} எங்கள் HashMap இல் குறைந்தபட்சம் ஒரு உறுப்பு உள்ளதா என்பதைச் சரிபார்க்க , நாம் isEmpty() முறையைப் பயன்படுத்தலாம் :

public static void main(String[] args) {
   HashMap<Integer, String> passportsAndNames = new HashMap<>();

   passportsAndNames.put (212133, "Bridget Logan");
   passportsAndNames.put (162348, "Ivan the Great");
   passportsAndNames.put(8082771, "Donald John Trump");

   if (!passportsAndNames.isEmpty()) {

       System.out.println(passportsAndNames);
   }
}

வெளியீடு: {212133=பிரிட்ஜெட் லோகன், 8082771=டொனால்ட் ஜான் டிரம்ப், 162348=இவான் தி கிரேட்} இப்போது பூர்வாங்க சோதனைக்குப் பிறகு மட்டுமே கன்சோலுக்கு அவுட்புட் செய்வோம். :) மற்றொரு சுவாரஸ்யமான விஷயம் என்னவென்றால், இரண்டு வரைபடங்களை ஒன்றாக இணைக்க முடியும். இது putAll() முறையைப் பயன்படுத்தி நிறைவேற்றப்பட்டது. நாங்கள் அதை முதல் ஹாஷ்மேப்பில் அழைக்கிறோம் , இரண்டாவதாக ஒரு வாதமாக அனுப்புகிறோம், இரண்டாவது கூறுகள் முதலில் சேர்க்கப்படும்:

public static void main(String[] args) {
   HashMap<Integer, String> passportsAndNames = new HashMap<>();
   HashMap<Integer, String> passportsAndNames2 = new HashMap<>();

   passportsAndNames.put (212133, "Bridget Logan");
   passportsAndNames.put (162348, "Ivan the Great");
   passportsAndNames.put(8082771, "Donald John Trump");

   passportsAndNames2.put(917352, "Clifford Patrick");
   passportsAndNames2.put(925648, "Mitchell Salgado");

   passportsAndNames.putAll(passportsAndNames2);
   System.out.println(passportsAndNames);
}

வெளியீடு: {917352=Clifford Patrick, 212133=Bridget Logan, 8082771=Donald John Trump, 925648=Mitchell Salgado, 162348=Ivan the Great} பாஸ்போர்ட்டில் உள்ள அனைத்து ஜோடிகளும் AndNames2 பாஸ்போர்ட்டுகளுக்கு நகலெடுக்கப்பட்டது . இப்போது மிகவும் சிக்கலான உதாரணத்தைக் கவனியுங்கள். குறிப்பாக, ஒரு லூப்பில் ஒரு ஹாஷ்மேப் மூலம் மீண்டும் மீண்டும்.

for (Map.Entry<Integer, String> entry: passportsAndNames.entrySet()) {
   System.out.println(entry);
}

Map.Entry வகுப்பு என்பது அகராதியின் உள்ளே இருக்கும் முக்கிய மதிப்பு ஜோடியைக் குறிக்கிறது. entrySet () முறையானது எங்கள் HashMap இல் உள்ள அனைத்து ஜோடிகளின் பட்டியலை வழங்குகிறது . எங்கள் வரைபடம் இந்த Map.Entry ஜோடிகளைக் கொண்டிருப்பதால் , தனித்தனி விசைகள் அல்லது மதிப்புகள் அல்ல. வெளியீடு: 212133=பிரிட்ஜெட் லோகன் 8082771=டொனால்ட் ஜான் டிரம்ப் 162348=இவான் தி கிரேட் மேலும், ஹாஷ்மேப்பிற்கான அதிகாரப்பூர்வ ஆரக்கிள் ஆவணங்களைப் படிக்க மறக்காதீர்கள் .