HashMap సేకరణను పరిచయం చేస్తున్నాము

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