हॅशमॅप संग्रह सादर करत आहे

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()

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. की-व्हॅल्यू जोड्यांवर लूपिंग

एक अधिक क्लिष्ट मार्ग देखील आहे: तुम्ही 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

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