हैश मैप संग्रह का परिचय

1. की-वैल्यू पेयर का एक सेट।

जावा में, एक और दिलचस्प संग्रह (मोटे तौर पर बोलना) है Map। कभी-कभी इस डेटा संरचना को शब्दकोश भी कहा जाता है।

यह Setसंग्रह के समान है, लेकिन यह तत्वों के सेट के बजाय तत्वों के "जोड़े" का एक सेट संग्रहीत करता है, प्रत्येक जोड़ी में Mapदो तत्व होते हैं: एक "कुंजी" और एक "मान"।

मान लीजिए कि आप चाहते हैं कि आपका कार्यक्रम कर्मचारियों के नाम और उनके वेतन, या आपके सहकर्मियों के नाम और उनकी उम्र को संग्रहित करे। तो आपको इस तरह की एक टेबल की आवश्यकता होगी:

प्रत्येक पंक्ति में कुछ मान होते हैं। हम नाम को जोड़ी की कुंजी के रूप में , और उम्र को जोड़ी के मान के रूप में संदर्भित करेंगे ।

इन जोड़ियों का पूरा सेट हमारा नक्शा ( Map) है।

एक जोड़ी की कुंजी को छोड़कर कुछ भी हो सकता है null। कुंजियाँ अद्वितीय होनी चाहिए: एक मानचित्र में दो समान कुंजियाँ नहीं हो सकतीं।

2. HashMapवर्ग

वर्ग HashMapसबसे लोकप्रिय प्रकार का Mapसंग्रह है। एक ओर, यह हैशसेट के समान है और इसके सभी तरीके हैं। दूसरी ओर, यह एक सूची ( 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()

ए में तत्वों को जोड़ना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. की-वैल्यू पेयर पर लूपिंग

एक अधिक जटिल तरीका भी है: आप a को की-वैल्यू पेयर के सेट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जो स्ट्रिंग्स (या अन्य प्रकार) को इंडेक्स (कुंजी) के रूप में उपयोग करने की अनुमति देता है।

यदि आप Integerfor कुंजियों का उपयोग a में करते हैं HashMap, तो यह a के समान और भी अधिक हो जाता है 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);
}