ஹாஷ்மேப் சேகரிப்பை அறிமுகப்படுத்துகிறோம்

1. முக்கிய மதிப்பு ஜோடிகளின் தொகுப்பு.

ஜாவாவில், மற்றொரு சுவாரஸ்யமான தொகுப்பு (பரந்த அளவில் பேசினால்) Map. சில நேரங்களில் இந்த தரவு அமைப்பு அகராதி என்றும் அழைக்கப்படுகிறது.

இது சேகரிப்பைப் போன்றது Set, ஆனால் இது தனிமங்களின் தொகுப்பைக் காட்டிலும் "ஜோடி" தனிமங்களின் தொகுப்பைச் சேமிக்கிறது, ஒவ்வொரு ஜோடியும் Mapஇரண்டு கூறுகளைக் கொண்டுள்ளது: ஒரு "விசை" மற்றும் "மதிப்பு".

உங்கள் திட்டமானது ஊழியர்களின் பெயர்கள் மற்றும் அவர்களின் சம்பளம் அல்லது உங்கள் சக பணியாளர்களின் பெயர்கள் மற்றும் அவர்களின் வயது ஆகியவற்றைச் சேமிக்க வேண்டும் என்று வைத்துக்கொள்வோம். பின்னர் உங்களுக்கு இது போன்ற ஒரு அட்டவணை தேவைப்படும்:

ஒவ்வொரு வரிசையிலும் இரண்டு மதிப்புகள் உள்ளன. பெயரை ஜோடியின் திறவுகோல் என்றும் , வயதை ஜோடியின் மதிப்பு என்றும் குறிப்பிடுவோம் .

இந்த ஜோடிகளின் முழு தொகுப்பும் எங்கள் வரைபடம் ( Map).

ஒரு ஜோடியின் சாவி தவிர வேறு எதுவும் இருக்கலாம் null. விசைகள் தனிப்பட்டதாக இருக்க வேண்டும்: ஒரு வரைபடத்தில் ஒரே மாதிரியான இரண்டு விசைகள் இருக்கக்கூடாது.

2. HashMapவர்க்கம்

வகுப்பு HashMapமிகவும் பிரபலமான சேகரிப்பு வகையாகும் Map. ஒருபுறம், இது HashSet ஐப் போலவே உள்ளது மற்றும் அதன் அனைத்து முறைகளையும் கொண்டுள்ளது. மறுபுறம், இது ஒரு பட்டியல் ( ArrayList) போன்றது, இது வார்த்தைகளை (அல்லது வேறு எதையும்) அதன் குறியீடுகளாகப் பயன்படுத்தலாம்.

HashMapஇது போன்ற ஒரு அறிக்கையைப் பயன்படுத்தி நீங்கள் உருவாக்கலாம் :

HashMap<KeyType, ValueType> name = new HashMap<KeyType, ValueType>();

KeyTypeசேமிக்கப்பட்ட ஜோடிகளில் உள்ள விசைகளின் வகை எங்கே , மற்றும் ValueTypeசேகரிப்பில் சேமிக்கப்பட்ட ஜோடிகளில் உள்ள மதிப்புகளின் வகை HashMap.

வகுப்பில் HashMapஇது போன்ற முறைகள் உள்ளன:

void put(KeyType key, ValueType value)

ValueType get(KeyType key)

boolean containsKey(KeyType key)

boolean containsValue(ValueType value)

ValueType remove(KeyType key)

void clear()

int size()

Set<KeyType> keySet()

Collection<ValueType> values()

Set<Map.Entry<KeyType, ValueType>> entrySet()

a இல் கூறுகளைச் சேர்த்தல்HashMap

முறையைப் பயன்படுத்தி கூறுகள் ஜோடிகளாக வரைபடத்தில் சேர்க்கப்படுகின்றன put(). விசை முதல் வாதமாக அனுப்பப்படுகிறது, மேலும் மதிப்பு இரண்டாவது வாதமாக அனுப்பப்படுகிறது.

HashMap<String, Integer> map = new HashMap<String, Integer>();
map.put("Elon", 21);
map.put("Jeff", 22);
map.put("Bill", 48);
map.put("Warren", null);

விசை-மதிப்பு ஜோடியைச் சேர்க்கும்போது, ​​விசை சேகரிப்பில் ஏற்கனவே இருந்தால், பழைய மதிப்பு புதிய மதிப்பால் மாற்றப்படும்.

இந்த நடத்தை HashMapஒரு வரிசை அல்லது பட்டியலை உருவாக்குகிறது, அதன் குறியீடுகள் Stringஎண்களுக்கு பதிலாக வார்த்தைகள் ( ) ஆகும்.

3. a இன் துணைக்குழுக்கள் HashMap: விசைகளின் தொகுப்பு

HashMapதிரையில் உள்ள அனைத்து உள்ளீடுகளையும் காட்ட விரும்புகிறோம் என்று வைத்துக்கொள்வோம் . இதை எப்படி செய்வது? இதைச் செய்ய, இல் உள்ள அனைத்து உள்ளீடுகளையும் எவ்வாறு கடந்து செல்வது என்பதை நாம் தெரிந்து கொள்ள வேண்டும் HashMap. இதை பல வழிகளில் செய்யலாம்.

விசைகளின் மேல் லூப் செய்வதே எளிதான வழி

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

HashMap<String, Integer> map = new HashMap<String, Integer>();
map.put("Elon", 21);
map.put("Jeff", 22);
map.put("Bill", 48);
map.put("Warren", null);

for (String key: map.keySet())
{
   Integer value = map.get(key);
   System.out.println(key + " --> " + value);
}

முறை keySet()விசைகளின் தொகுப்பை வழங்குகிறது. இந்த தொகுப்பை நீங்கள் இரண்டு வழிகளில் பயன்படுத்தலாம்:

for (String key: map.keySet())
{
   Integer value = map.get(key);
   System.out.println(key + " --> " + value);
}

Set<String> keys = map.keySet();

for (String key: keys)
{
   Integer value = map.get(key);
   System.out.println(key + " --> " + value);
}

4. முக்கிய-மதிப்பு ஜோடிகளின் மீது லூப்பிங்

Mapமிகவும் சிக்கலான வழியும் உள்ளது: நீங்கள் ஒரு முக்கிய-மதிப்பு ஜோடிகளின் தொகுப்பாக மாற்றலாம் , பின்னர் நாம் ஏற்கனவே கற்றுக்கொண்டது போல, தொகுப்பின் கூறுகளின் மீது லூப் செய்யலாம்.

சேகரிப்பில் HashMapஒரு முக்கிய மதிப்பு ஜோடியை சேமிக்கும் உதவி வகுப்பு உள்ளது. தோராயமாக இது போல் தெரிகிறது:

class Entry<KeyType, ValueType>
{
   private KeyType key;
   private ValueType value;

   public KeyType getKey()
   {
      return this.key;
   }

   public ValueType getValue()
   {
      return this.value;
   }
}

entrySet()ஒரு பொருளின் மீது முறையை அழைப்பதன் விளைவாக இருக்கும் :HashMap<KeyType, ValueType>Set<Entry<KeyType, ValueType>>

Set<Entry<KeyType, ValueType>> name = map.entrySet();

Setஇங்கே நாம் ஒரு வகை அளவுருவுடன் பொதுவான வகுப்பைக் கொண்டுள்ளோம் , இது Entryஇரண்டு வகை அளவுருக்கள் கொண்ட பொதுவான வகை ( ) ஆகும்.

ஒரு தொடக்கக்காரர் இதைப் பற்றி குழப்பமடைவது மிகவும் எளிதானது. ஆனால் நீங்கள் அதை கண்டுபிடித்தவுடன், நீங்கள் குறியீட்டை எழுதலாம்:

HashMap<String, Integer> map = new HashMap<String, Integer>();
map.put("Elon", 21);
map.put("Jeff", 22);
map.put("Bill", 48);
map.put("Warren", null);

Set<Map.Entry<String, Integer>> entries = map.entrySet();
for(Map.Entry<String, Integer> pair: entries)
{
   String key = pair.getKey();
   Integer value = pair.getValue();
   System.out.println(key + " --> " + value);
}

இந்த குறியீட்டை சிறிது எளிமைப்படுத்தலாம்:

முதலில், நீங்கள் ஒரு தனி மாறியை உருவாக்குவதைத் தவிர்க்கலாம் மற்றும் அதற்குப் பதிலாக நேரடியாக லூப்பில் உள்ள முறையை entriesஅழைக்கலாம் :entrySet()for

for(Map.Entry<String, Integer> pair: map.entrySet())
{
   String key = pair.getKey();
   Integer value = pair.getValue();
   System.out.println(key + " --> " + value);
}

இரண்டாவதாக, விசை-மதிப்பு ஜோடியின்var வகையை தானாகவே ஊகிக்க, சமீபத்தில் அறிமுகப்படுத்தப்பட்ட ஆபரேட்டரைப் பயன்படுத்தலாம் :

for(var pair: map.entrySet())
{
   String key = pair.getKey();
   Integer value = pair.getValue();
   System.out.println(key + " --> " + value);
}

மோசமாக இல்லை, இல்லையா?

5. ஒப்பீடு ArrayListமற்றும்HashMap

சரங்களை (அல்லது பிற வகைகளை) குறியீட்டுகளாக (விசைகள்) பயன்படுத்த அனுமதிக்கும் ஒரு HashMapவலுவாக ஒத்திருக்கிறது .ArrayList

Integerநீங்கள் a இல் உள்ள விசைகளைப் பயன்படுத்தினால் HashMap, அது ஒரு ஐப் போலவே இருக்கும் ArrayList. ஒப்பிடுவோம்:

ArrayList<String> list = new ArrayList<String>();

list.add("Greetings");
list.add("Hello");

String s = list.get(0);
list.set(0, s + "!");

for (String item: list)
{
   System.out.println(item);
}

HashMap<Integer, String> map = new HashMap<Integer, String>();

map.put(0, "Greetings");
map.put(1, "Hello");

String s = map.get(0);
map.put(0, s + "!");

for (String item: map.values())
{
   System.out.println(item);
}