java - एक हैश मैप के माध्यम से Iterate




loops hashmap (5)

संभावित डुप्लिकेट:
'मानचित्र' में प्रत्येक प्रविष्टि को कुशलता से कैसे सक्रिय किया जाए?

HashMap में आइटम्स को फिर से चलाने का सबसे अच्छा तरीका क्या है?


आप Map में प्रविष्टियों के माध्यम से कई तरीकों से पुन: प्रयास कर सकते हैं। प्रत्येक कुंजी और मूल्य इस तरह प्राप्त करें:

Map<?,?> map = new HashMap<Object, Object>();
for(Entry<?, ?> e: map.entrySet()){
    System.out.println("Key " + e.getKey());
    System.out.println("Value " + e.getValue());
}

या आप कुंजी की सूची प्राप्त कर सकते हैं

Collection<?> keys = map.keySet();
for(Object key: keys){
    System.out.println("Key " + key);
    System.out.println("Value " + map.get(key));
}

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

Collection<?> values = map.values();

निर्भर करता है। यदि आप जानते हैं कि आपको प्रत्येक प्रविष्टि की कुंजी और मूल्य दोनों की आवश्यकता होगी, तो entrySet माध्यम से entrySet । यदि आपको केवल मूल्यों की आवश्यकता है, तो values() विधि है। और यदि आपको केवल चाबियाँ चाहिए, तो keyset() उपयोग करें।

एक बुरा अभ्यास सभी चाबियों के माध्यम से फिर से शुरू करना होगा, और फिर लूप के भीतर, हमेशा मूल्य प्राप्त करने के लिए map.get(key) करें। यदि आप ऐसा कर रहे हैं, तो मैंने लिखा पहला विकल्प आपके लिए है।


संदर्भ में निकाला गया जावा में एक मानचित्र पर कैसे Iterate :

जावा में एक Map पर पुनरावृत्त करने के कई तरीके हैं। आइए सबसे आम तरीकों पर जाएं और उनके फायदे और नुकसान की समीक्षा करें। चूंकि जावा में सभी मानचित्र मानचित्र इंटरफ़ेस को लागू करते हैं, इसलिए निम्न तकनीक किसी भी मानचित्र कार्यान्वयन ( LinkedHashMap मैप, LinkedHashMap , LinkedHashMap , LinkedHashMap इत्यादि) के लिए काम करेगी।

विधि # 1 : फॉर-प्रत्येक लूप का उपयोग करके प्रविष्टियों पर इटरेट करना।

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

Map<Integer, Integer> map = new HashMap<Integer, Integer>();
for (Map.Entry<Integer, Integer> entry : map.entrySet()) {
    System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
}

ध्यान दें कि फॉर-प्रत्येक लूप जावा 5 में पेश किया गया था, इसलिए यह विधि केवल भाषा के नए संस्करणों में काम कर रही है। इसके अलावा एक फॉर-प्रत्येक लूप NullPointerException को फेंक देगा यदि आप शून्य पर एक मानचित्र पर फिर से प्रयास करने का प्रयास करते हैं, तो पुनरावृत्ति से पहले आपको हमेशा शून्य संदर्भों की जांच करनी चाहिए।

विधि # 2 : फॉर-प्रत्येक लूप का उपयोग करके कुंजी या मानों पर इटरेट करना।

यदि आपको मानचित्र से केवल चाबियाँ या मानों की आवश्यकता है, तो आप एंट्रीसेट के बजाय कीसेट या मानों पर फिर से सक्रिय हो सकते हैं।

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

// Iterating over keys only
for (Integer key : map.keySet()) {
    System.out.println("Key = " + key);
}

// Iterating over values only
for (Integer value : map.values()) {
    System.out.println("Value = " + value);
}

यह विधि entrySet पुनरावृत्ति (लगभग 10% तेज) पर थोड़ा सा प्रदर्शन लाभ देती है और यह अधिक साफ है।

विधि # 3 : इटरेटर का उपयोग कर Iterating।

जेनरिक का उपयोग करना:

Map<Integer, Integer> map = new HashMap<Integer, Integer>();
Iterator<Map.Entry<Integer, Integer>> entries = map.entrySet().iterator();
while (entries.hasNext()) {
    Map.Entry<Integer, Integer> entry = entries.next();
    System.out.println("Key = " + entry.getKey() + ", Value = " + entry.getValue());
}

जेनरिक के बिना:

Map map = new HashMap();
Iterator entries = map.entrySet().iterator();
while (entries.hasNext()) {
    Map.Entry entry = (Map.Entry) entries.next();
    Integer key = (Integer)entry.getKey();
    Integer value = (Integer)entry.getValue();
    System.out.println("Key = " + key + ", Value = " + value);
}

आप keySet या मानों पर फिर से keySet लिए एक ही तकनीक का उपयोग कर सकते हैं।

यह विधि अनावश्यक लग सकती है, लेकिन इसके अपने फायदे हैं। सबसे पहले, जावा के पुराने संस्करणों में एक मानचित्र पर फिर से शुरू करने का यही एकमात्र तरीका है। दूसरी महत्वपूर्ण विशेषता यह है कि यह एकमात्र तरीका है जो आपको iterator.remove() कॉल करके पुनरावृत्ति के दौरान मानचित्र से प्रविष्टियों को हटाने की अनुमति देता है। यदि आप इसके लिए प्रत्येक पुनरावृत्ति के दौरान ऐसा करने का प्रयास करते हैं तो आपको Javadoc अनुसार "अप्रत्याशित परिणाम" मिलेंगे।

एक प्रदर्शन बिंदु से यह विधि एक-प्रत्येक पुनरावृत्ति के बराबर है।

विधि # 4 : चाबियों पर इटरेट करना और मूल्यों (अक्षम) की खोज करना।

Map<Integer, Integer> map = new HashMap<Integer, Integer>();
for (Integer key : map.keySet()) {
    Integer value = map.get(key);
    System.out.println("Key = " + key + ", Value = " + value);
}

यह विधि # 1 के लिए क्लीनर विकल्प की तरह दिख सकता है, लेकिन व्यवहार में यह बहुत धीमी और अक्षम है क्योंकि कुंजी द्वारा मूल्य प्राप्त करने में समय लग सकता है (विभिन्न मानचित्र कार्यान्वयन में यह विधि विधि # 1 की तुलना में 20% -200% धीमी है )। यदि आपके पास FindBugs इंस्टॉल है, तो यह इसका पता लगाएगा और आपको अक्षम पुनरावृत्ति के बारे में चेतावनी देगा। इस विधि से बचा जाना चाहिए।

निष्कर्ष:

यदि आपको मानचित्र से केवल कुंजी या मान की आवश्यकता है, तो विधि # 2 का उपयोग करें। यदि आप जावा के पुराने संस्करण (5 से कम) या पुनरावृत्ति के दौरान प्रविष्टियों को हटाने की योजना बना रहे हैं, तो आपको विधि # 3 का उपयोग करना होगा। अन्यथा विधि # 1 का उपयोग करें।


होशियार:

for (String key : hashMap.keySet()) {
    System.out.println("Key: " + key + ", Value: " + map.get(key));
}

for (Map.Entry<String, String> item : params.entrySet()) {
    String key = item.getKey();
    String value = item.getValue();
}




iteration