Java Language
मैप्स

परिचय

टिप्पणियों

एक तत्व जोड़ें

1. इसके अलावा

Map<Integer, String> map = new HashMap<>();
map.put(1, "First element."); 
System.out.println(map.get(1));

आउटपुट: First element.

2. अवहेलना

Map<Integer, String> map = new HashMap<>();
map.put(1, "First element.");
map.put(1, "New element.");
System.out.println(map.get(1));

आउटपुट: New element.

HashMap एक उदाहरण के रूप में प्रयोग किया जाता है। Map इंटरफ़ेस को लागू करने वाले अन्य कार्यान्वयन भी इस्तेमाल किए जा सकते हैं।

कई आइटम जोड़ें

हम V put(K key,V value) उपयोग कर सकते हैं:

इस मानचित्र में निर्दिष्ट कुंजी (वैकल्पिक संचालन) के साथ निर्दिष्ट मूल्य को जोड़ता है। यदि मानचित्र में पहले कुंजी के लिए मैपिंग शामिल है, तो पुराने मान को निर्दिष्ट मान से बदल दिया जाता है।

String currentVal;
Map<Integer, String> map = new TreeMap<>();
currentVal = map.put(1, "First element.");
System.out.println(currentVal);// Will print null
currentVal = map.put(2, "Second element.");
System.out.println(currentVal); // Will print null yet again    
currentVal = map.put(2, "This will replace 'Second element'");
System.out.println(currentVal); // will print Second element.
System.out.println(map.size()); // Will print 2 as key having
// value 2 was replaced.

Map<Integer, String> map2 = new HashMap<>();
map2.put(2, "Element 2");
map2.put(3, "Element 3");

map.putAll(map2);

System.out.println(map.size());  

आउटपुट:

3

कई मदों को जोड़ने के लिए आप इस तरह के एक आंतरिक वर्गों का उपयोग कर सकते हैं:

Map<Integer, String> map = new HashMap<>() {{
    // This is now an anonymous inner class with an unnamed instance constructor
    put(5, "high");
    put(4, "low");
    put(1, "too slow");
}};

ध्यान रखें कि एक अनाम आंतरिक वर्ग बनाना हमेशा कुशल नहीं होता है और जब संभव हो तो मेमोरी लीक हो सकती है, इसके बजाय एक इनिशलाइज़र ब्लॉक का उपयोग करें:

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

static {
    // Now no inner classes are created so we can avoid memory leaks
    put(5, "high");
    put(4, "low");
    put(1, "too slow");
}

ऊपर दिया गया उदाहरण मानचित्र को स्थिर बनाता है। यह भी के सभी आवृत्तियां को हटाकर एक गैर स्थिर संदर्भ में इस्तेमाल किया जा सकता static ।

इसके अलावा, अधिकांश कार्यान्वयन putAll समर्थन putAll , जो इस तरह से एक नक्शे में सभी प्रविष्टियों को जोड़ सकते हैं:

another.putAll(one);

जावा 8 से मानचित्र के डिफ़ॉल्ट तरीकों का उपयोग करना

मानचित्र इंटरफ़ेस में जावा 8 में शुरू की गई डिफ़ॉल्ट विधियों का उपयोग करने के उदाहरण

1. GetOrDefault का उपयोग करना

कुंजी में मैप किया गया मान लौटाता है, या यदि कुंजी मौजूद नहीं है, तो डिफ़ॉल्ट मान लौटाता है

Map<Integer, String> map = new HashMap<>();
map.put(1, "First element");
map.get(1);                                 // => First element
map.get(2);                                 // => null
map.getOrDefault(2, "Default element");     // => Default element

2. ForEach का उपयोग करना

प्रत्येक मानचित्र प्रविष्टि पर 'कार्रवाई' में निर्दिष्ट ऑपरेशन करने की अनुमति देता है

  Map<Integer, String> map = new HashMap<Integer, String>();
  map.put(1, "one");
  map.put(2, "two");
  map.put(3, "three");
  map.forEach((key, value) -> System.out.println("Key: "+key+ " :: Value: "+value));

   // Key: 1 :: Value: one
   // Key: 2 :: Value: two
   // Key: 3 :: Value: three

3. प्रतिस्थापन का उपयोग करना

नए-मूल्य से बदल देगा केवल अगर कुंजी मौजूद है

 Map<String, Integer> map = new HashMap<String, Integer>();
 map.put("john", 20);
 map.put("paul", 30);
 map.put("peter", 40);
 map.replaceAll((key,value)->value+10);   //{john=30, paul=40, peter=50}

4. PutIfAbsent का उपयोग करना

कुंजी-मान जोड़ी को मानचित्र में जोड़ा जाता है, यदि कुंजी मौजूद नहीं है या नल के लिए मैप की गई है

    Map<String, Integer> map = new HashMap<String, Integer>();
    map.put("john", 20);
    map.put("paul", 30);
    map.put("peter", 40);
    map.putIfAbsent("kelly", 50);     //{john=20, paul=30, peter=40, kelly=50}

5. हटाने का उपयोग करना

   कुंजी तभी निकालता है जब उसका दिया गया मान जुड़ा हो

    Map<String, Integer> map = new HashMap<String, Integer>();
    map.put("john", 20);
    map.put("paul", 30);
    map.put("peter", 40);
    map.remove("peter",40); //{john=30, paul=40}
   

6. प्रतिस्थापित का उपयोग करना

   यदि कुंजी मौजूद है, तो मान को नए-मान से बदल दिया जाता है। यदि कुंजी मौजूद नहीं है, तो कुछ भी नहीं करता है।

Map<String, Integer> map = new HashMap<String, Integer>();
map.put("john", 20);
map.put("paul", 30);
map.put("peter", 40);
map.replace("peter",50); //{john=20, paul=30, peter=50}
map.replace("jack",60); //{john=20, paul=30, peter=50}

7. ComputeIfAbsent का उपयोग करना

यह विधि मानचित्र में एक प्रविष्टि जोड़ती है। कुंजी फ़ंक्शन में निर्दिष्ट है और मान मैपिंग फ़ंक्शन के अनुप्रयोग का परिणाम है

    Map<String, Integer> map = new HashMap<String, Integer>();
    map.put("john", 20);
    map.put("paul", 30);
    map.put("peter", 40);
    map.computeIfAbsent("kelly", k->map.get("john")+10); //{john=20, paul=30, peter=40, kelly=30}
    map.computeIfAbsent("peter", k->map.get("john")+10); //{john=20, paul=30, peter=40, kelly=30} //peter already present

8. ComputeIfPresent का उपयोग करना

यह विधि एक प्रविष्टि जोड़ता है या मानचित्र में मौजूदा प्रविष्टि को संशोधित करता है। कुछ भी नहीं है अगर उस कुंजी के साथ एक प्रविष्टि मौजूद नहीं है

    Map<String, Integer> map = new HashMap<String, Integer>();
    map.put("john", 20);
    map.put("paul", 30);
    map.put("peter", 40);
    map.computeIfPresent("kelly", (k,v)->v+10); //{john=20, paul=30, peter=40} //kelly not present
    map.computeIfPresent("peter", (k,v)->v+10); //{john=20, paul=30, peter=50} // peter present, so increase the value 

9. गणना का उपयोग करना

यह विधि नए गणना किए गए मान द्वारा कुंजी के मूल्य को बदल देती है

    Map<String, Integer> map = new HashMap<String, Integer>();
    map.put("john", 20);
    map.put("paul", 30);
    map.put("peter", 40);
    map.compute("peter", (k,v)->v+50); //{john=20, paul=30, peter=90} //Increase the value 

10. मर्ज का उपयोग करना

कुंजी-मान युग्म को मानचित्र में जोड़ता है, यदि कुंजी मौजूद नहीं है या कुंजी के लिए मान शून्य है, तो नए गणना किए गए मान के साथ मान को बदल देता है, यदि कुंजी मौजूद है, तो कुंजी को मानचित्र से हटा दिया जाता है, यदि नया मूल्य गणना शून्य है

    Map<String, Integer> map = new HashMap<String, Integer>();
    map.put("john", 20);
    map.put("paul", 30);
    map.put("peter", 40);
    
    //Adds the key-value pair to the map, if key is not present or value for the key is null
    map.merge("kelly", 50 , (k,v)->map.get("john")+10); // {john=20, paul=30, peter=40, kelly=50}
    
    //Replaces the value with the newly computed value, if the key is present
    map.merge("peter", 50 , (k,v)->map.get("john")+10); //{john=20, paul=30, peter=30, kelly=50}
   
    //Key is removed from the map , if new value computed is null
    map.merge("peter", 30 , (k,v)->map.get("nancy")); //{john=20, paul=30, kelly=50}

नक्शा साफ़ करें

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

map.put(1, "First element.");
map.put(2, "Second element.");
map.put(3, "Third element.");

map.clear();

System.out.println(map.size());   // => 0

एक मानचित्र की सामग्री के माध्यम से Iterating

मानचित्र ऐसे तरीके प्रदान करते हैं जो आपको नक्शे के कुंजी, मान या कुंजी-मूल्य जोड़े को संग्रह के रूप में एक्सेस करने देते हैं। आप इन संग्रहों के माध्यम से पुनरावृति कर सकते हैं। उदाहरण के लिए निम्नलिखित नक्शे को देखते हुए:

Map<String, Integer> repMap = new HashMap<>();
repMap.put("Jon Skeet", 927_654);
repMap.put("BalusC", 708_826);
repMap.put("Darin Dimitrov", 715_567);

मानचित्र कुंजियों के माध्यम से परिवर्तन:

for (String key : repMap.keySet()) {
    System.out.println(key);
}

प्रिंटों:

डारिन दिमित्रोव
जॉन स्कीट
BalusC

keySet() Set रूप में मानचित्र की कुंजी प्रदान करता है। Set का उपयोग किया जाता है क्योंकि कुंजी में डुप्लिकेट मान नहीं हो सकते। सेट के माध्यम से फेरबदल करने से बदले में प्रत्येक कुंजी मिलती है। HashMaps का आदेश नहीं दिया गया है, इसलिए इस उदाहरण में कुंजियाँ किसी भी क्रम में वापस आ सकती हैं।

मानचित्र मूल्यों के माध्यम से परिवर्तन:

for (Integer value : repMap.values()) {
    System.out.println(value);
}

प्रिंटों:

715,567
927,654
708,826

values() मानचित्र के मानों को एक Collection रूप में लौटाता है। संग्रह के माध्यम से Iterating बदले में प्रत्येक मूल्य प्राप्त करता है। फिर से, मूल्यों को किसी भी क्रम में वापस किया जा सकता है।

कुंजियों और मूल्यों को एक साथ जोड़ना

for (Map.Entry<String, Integer> entry : repMap.entrySet()) {
    System.out.printf("%s = %d\n", entry.getKey(), entry.getValue());
}

प्रिंटों:

डारिन दिमित्रोव = 715567
जॉन स्कीट = 927654
बालुस = 708826

entrySet() Map.Entry ऑब्जेक्ट का संग्रह Map.Entry है। Map.Entry प्रत्येक प्रविष्टि के लिए कुंजी और मान तक पहुँच देता है।

मानचित्रों को मिलाना, जोड़ना और बनाना

एक नक्शे के प्रत्येक सदस्य को दूसरे में डालने के लिए putAll का उपयोग करें। मानचित्र में पहले से मौजूद कुंजी में उनके संबंधित मान ओवरराइट किए गए होंगे।

Map<String, Integer> numbers = new HashMap<>();
numbers.put("One", 1)
numbers.put("Three", 3)
Map<String, Integer> other_numbers = new HashMap<>();
other_numbers.put("Two", 2)
other_numbers.put("Three", 4)

numbers.putAll(other_numbers)

यह numbers में निम्नलिखित मानचित्रण की पैदावार करता है:

"One" -> 1
"Two" -> 2
"Three" -> 4 //old value 3 was overwritten by new value 4

यदि आप उन्हें अधिलेखित करने के बजाय मूल्यों को संयोजित करना चाहते हैं, तो आप Java 8 में जोड़े गए Map.merge उपयोग कर सकते हैं, जो डुप्लिकेट कुंजियों के लिए मूल्यों को मर्ज करने के लिए उपयोगकर्ता द्वारा प्रदान की गई BiFunction का उपयोग करता है। merge व्यक्तिगत कुंजियों और मूल्यों पर संचालित होता है, इसलिए आपको एक लूप या Map.forEach का उपयोग करने की आवश्यकता होगी। यहां हम डुप्लिकेट कुंजियों के लिए स्ट्रिंग्स को बदलते हैं:

for (Map.Entry<String, Integer> e : other_numbers.entrySet())
    numbers.merge(e.getKey(), e.getValue(), Integer::sum);
//or instead of the above loop
other_numbers.forEach((k, v) -> numbers.merge(k, v, Integer::sum));

यदि आप बाधा को लागू करना चाहते हैं तो कोई डुप्लिकेट चाबियाँ नहीं हैं, तो आप एक मर्ज फ़ंक्शन का उपयोग कर सकते हैं जो एक AssertionError :

mapA.forEach((k, v) ->
    mapB.merge(k, v, (v1, v2) ->
        {throw new AssertionError("duplicate values for key: "+k);}));

नक्शा <एक्स, वाई> और नक्शा <एक्स, जेड> पाने के लिए नक्शा <वाई, जेड>

यदि आप दो मैपिंग रचना करना चाहते हैं, तो आप इसे निम्नानुसार कर सकते हैं

    Map<String, Integer> map1 = new HashMap<String, Integer>();
    map1.put("key1", 1);
    map1.put("key2", 2);
    map1.put("key3", 3);
    
    Map<Integer, Double> map2 = new HashMap<Integer, Double>();
    map2.put(1, 1.0);
    map2.put(2, 2.0);
    map2.put(3, 3.0);

    Map<String, Double> map3 = new new HashMap<String, Double>();
    map1.forEach((key,value)->map3.put(key,map2.get(value)));

इससे निम्न मानचित्रण प्राप्त होता है

    "key1" -> 1.0
    "key2" -> 2.0
    "key3" -> 3.0

जाँच करें कि क्या कुंजी मौजूद है

Map<String, String> num = new HashMap<>();
num.put("one", "first");

if (num.containsKey("one")) {
    System.out.println(num.get("one")); // => first
}

मानचित्र में शून्य मान हो सकते हैं

नक्शों के लिए, किसी को "मूल्य वाले" के साथ "एक कुंजी युक्त" को भ्रमित करने के लिए कैरिफुल नहीं होना चाहिए। उदाहरण के लिए, HashMap में अशक्त हो सकता है जिसका अर्थ है कि निम्नलिखित पूरी तरह से सामान्य व्यवहार है:

Map<String, String> map = new HashMap<>();
map.put("one", null);
if (map.containsKey("one")) {
    System.out.println("This prints !"); // This line is reached 
}
if (map.get("one") != null) {
    System.out.println("This is never reached !"); // This line is never reached 
}

औपचारिक रूप से, कोई गारंटी नहीं है कि map.contains(key) <=> map.get(key)!=null

Iterating मानचित्र प्रविष्टियाँ कुशलता से

यह खंड दस अद्वितीय उदाहरण कार्यान्वयन के लिए कोड और बेंचमार्क प्रदान करता है जो Map<Integer, Integer> की प्रविष्टियों पर पुनरावृति करता है और Integer मानों का योग उत्पन्न करता है। सभी उदाहरणों में Θ(n) की एक एल्गोरिथम जटिलता है, हालांकि, बेंचमार्क अभी भी अंतर्दृष्टि प्रदान करने के लिए उपयोगी हैं, जिस पर कार्यान्वयन "वास्तविक दुनिया" वातावरण में अधिक कुशल हैं।

1. Map.Entry साथ Iterator का उपयोग करके कार्यान्वयन

    Iterator<Map.Entry<Integer, Integer>> it = map.entrySet().iterator();
    while (it.hasNext()) {
        Map.Entry<Integer, Integer> pair = it.next();
        sum += pair.getKey() + pair.getValue();
    }

2. Map.Entry for साथ उपयोग के for कार्यान्वयन

    for (Map.Entry<Integer, Integer> pair : map.entrySet()) {
        sum += pair.getKey() + pair.getValue();
    }

3. Map.forEach (Java 8+) का उपयोग करके कार्यान्वयन

    map.forEach((k, v) -> sum[0] += k + v);

4. के for Map.keySet का उपयोग करके कार्यान्वयन

    for (Integer key : map.keySet()) {
        sum += key + map.get(key);
    }

5. Iterator साथ Map.keySet का उपयोग करके कार्यान्वयन

    Iterator<Integer> it = map.keySet().iterator();
    while (it.hasNext()) {
        Integer key = it.next();
        sum += key + map.get(key);
    }

6. Iterator और Map.Entry साथ उपयोग के for कार्यान्वयन

    for (Iterator<Map.Entry<Integer, Integer>> entries = 
             map.entrySet().iterator(); entries.hasNext(); ) {
        Map.Entry<Integer, Integer> entry = entries.next();
        sum += entry.getKey() + entry.getValue();
    }

7. Stream.forEach (Java 8+) का उपयोग करके कार्यान्वयन

    map.entrySet().stream().forEach(e -> sum += e.getKey() + e.getValue());

8. Stream.forEach साथ Stream.parallel का उपयोग करके कार्यान्वयन (जावा 8+)

    map.entrySet()
       .stream()
       .parallel()
       .forEach(e -> sum += e.getKey() + e.getValue());

9. अपाचे संग्रह से IterableMap का उपयोग कर कार्यान्वयन

    MapIterator<Integer, Integer> mit = iterableMap.mapIterator();
    while (mit.hasNext()) {
        sum += mit.next() + it.getValue();
    }

10. ग्रहण संग्रह से MutableMap का उपयोग कर कार्यान्वयन

     mutableMap.forEachKeyValue((key, value) -> {
         sum += key + value;
     });

प्रदर्शन टेस्ट ( जीथब पर उपलब्ध कोड )
टेस्ट पर्यावरण: विंडोज 8.1 64-बिट, इंटेल i7-4790 3.60GHz, 16 जीबी

1. 10 परीक्षणों का औसत प्रदर्शन (100 तत्व) सर्वश्रेष्ठ: 308 s 21 ns / op

   Benchmark                           Score     Error  Units
   test3_UsingForEachAndJava8            308  ±     21  ns/op
   test10_UsingEclipseMutableMap         309  ±      9  ns/op
   test1_UsingWhileAndMapEntry           380  ±     14  ns/op
   test6_UsingForAndIterator             387  ±     16  ns/op
   test2_UsingForEachAndMapEntry         391  ±     23  ns/op
   test7_UsingJava8StreamAPI             510  ±     14  ns/op
   test9_UsingApacheIterableMap          524  ±      8  ns/op
   test4_UsingKeySetAndForEach           816  ±     26  ns/op
   test5_UsingKeySetAndIterator          863  ±     25  ns/op
   test8_UsingJava8StreamAPIParallel    5552  ±    185  ns/op
   

2. 10 परीक्षणों (10000 तत्वों) का सर्वश्रेष्ठ प्रदर्शन: 37.606 μ 0.790 μs / op

   Benchmark                           Score     Error  Units
   test10_UsingEclipseMutableMap       37606  ±    790  ns/op
   test3_UsingForEachAndJava8          50368  ±    887  ns/op
   test6_UsingForAndIterator           50332  ±    507  ns/op
   test2_UsingForEachAndMapEntry       51406  ±   1032  ns/op
   test1_UsingWhileAndMapEntry         52538  ±   2431  ns/op
   test7_UsingJava8StreamAPI           54464  ±    712  ns/op
   test4_UsingKeySetAndForEach         79016  ±  25345  ns/op
   test5_UsingKeySetAndIterator        91105  ±  10220  ns/op
   test8_UsingJava8StreamAPIParallel  112511  ±    365  ns/op
   test9_UsingApacheIterableMap       125714  ±   1935  ns/op
   

3. 10 परीक्षणों का औसत प्रदर्शन (100000 तत्व) सर्वश्रेष्ठ: 1184.767 .9 332.968 μs / op

   Benchmark                            Score       Error  Units
   test1_UsingWhileAndMapEntry       1184.767  ±  332.968  μs/op
   test10_UsingEclipseMutableMap     1191.735  ±  304.273  μs/op
   test2_UsingForEachAndMapEntry     1205.815  ±  366.043  μs/op
   test6_UsingForAndIterator         1206.873  ±  367.272  μs/op
   test8_UsingJava8StreamAPIParallel 1485.895  ±  233.143  μs/op
   test5_UsingKeySetAndIterator      1540.281  ±  357.497  μs/op
   test4_UsingKeySetAndForEach       1593.342  ±  294.417  μs/op
   test3_UsingForEachAndJava8        1666.296  ±  126.443  μs/op
   test7_UsingJava8StreamAPI         1706.676  ±  436.867  μs/op
   test9_UsingApacheIterableMap      3289.866  ± 1445.564  μs/op
   

4. मानचित्र के आकार के प्रति प्रतिक्रिया भिन्नता की तुलना

       x: Size of Map
    f(x): Benchmark Score (μs/op)

                 100      600     1100     1600     2100
        ---------------------------------------------------
        10  |   0.333    1.631    2.752    5.937    8.024
         3  |   0.309    1.971    4.147    8.147   10.473
         6  |   0.372    2.190    4.470    8.322   10.531
         1  |   0.405    2.237    4.616    8.645   10.707
Tests    2  |   0.376    2.267    4.809    8.403   10.910
 f(x)    7  |   0.473    2.448    5.668    9.790   12.125
         9  |   0.565    2.830    5.952    13.22   16.965
         4  |   0.808    5.012    8.813    13.939  17.407
         5  |   0.81     5.104    8.533    14.064  17.422
         8  |   5.173   12.499   17.351    24.671  30.403

कुंजी के रूप में कस्टम ऑब्जेक्ट का उपयोग करें

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

साधारण मामले में आपके पास कुछ ऐसा होगा:

class MyKey {
    private String name;
    MyKey(String name) {
        this.name = name;
    }

    @Override
    public boolean equals(Object obj) {            
        if(obj instanceof MyKey) {
            return this.name.equals(((MyKey)obj).name);
        }
        return false;
    }
    
    @Override
    public int hashCode() {
        return this.name.hashCode();
    }
}

hashCode तय करेगा कि किस हैश की बाल्टी hashCode है और equals तय करेगी कि उस हैश बाल्टी के अंदर कौन सी वस्तु है।

इन विधि के बिना, आपकी वस्तु का संदर्भ उपर्युक्त तुलना के लिए उपयोग किया जाएगा जो तब तक काम नहीं करेगा जब तक आप हर बार उसी वस्तु संदर्भ का उपयोग न करें।

हाशपैप का उपयोग

हैशपैप मैप इंटरफेस का एक कार्यान्वयन है जो डेटा-कुंजी जोड़े में डेटा स्टोर करने के लिए एक डेटा संरचना प्रदान करता है।

1. हाशपा की घोषणा

Map<KeyType, ValueType> myMap = new HashMap<KeyType, ValueType>();

KeyType और ValueType जावा में मान्य प्रकार होने चाहिए, जैसे - स्ट्रिंग, इंटेगर, फ्लोट या कोई भी कस्टम वर्ग जैसे कर्मचारी, छात्र आदि।

उदाहरण के लिए: Map<String,Integer> myMap = new HashMap<String,Integer>();

2. हाशप में मान डालना।

हाशप में मूल्य डालने के लिए, हमें कुंजी और मान को मापदंडों के रूप में पास करके हाशपॉइंट ऑब्जेक्ट पर put विधि को कॉल करना होगा।

myMap.put("key1", 1);
myMap.put("key2", 2);

यदि आप पुट विधि को कुंजी के साथ कहते हैं जो पहले से ही मानचित्र में मौजूद है, तो विधि उसके मान को ओवरराइड कर देगी और पुराने मान को लौटा देगी।

3. HashMap से मान प्राप्त करना।

हाशपैप से मूल्य get करने के लिए आपको कुंजी के रूप में पैरामीटर के रूप में पास करके, विधि get करना होगा।

myMap.get("key1");    //return 1 (class Integer)

यदि आप किसी कुंजी को पास करते हैं जो कि HashMap में मौजूद नहीं है, तो यह विधि null हो जाएगी

4. जांच करें कि कुंजी मानचित्र में है या नहीं।

myMap.containsKey(varKey);

5. जाँच करें कि मान मानचित्र में है या नहीं।

myMap.containsValue(varValue);

उपरोक्त विधियाँ सही या गलत होने पर boolean मान boolean यदि कुंजी, मान मानचित्र में मौजूद है या नहीं।

मानचित्र बनाना और आरंभ करना

परिचय

Maps कुंजी / मूल्य जोड़े को संग्रहीत करते हैं, जहां प्रत्येक कुंजी का एक संबद्ध मूल्य होता है। किसी विशेष कुंजी को देखते हुए, नक्शा संबंधित मूल्य को बहुत तेज़ी से देख सकता है।

Maps , जिसे सहयोगी सरणी के रूप में भी जाना जाता है, एक ऑब्जेक्ट है जो डेटा को कुंजी और मान के रूप में संग्रहीत करता है। जावा में, मानचित्र इंटरफ़ेस का उपयोग करके मानचित्रों का प्रतिनिधित्व किया जाता है जो संग्रह इंटरफ़ेस का विस्तार नहीं है।

• तरीका 1: -

   /*J2SE < 5.0*/
   Map map = new HashMap();
   map.put("name", "A");
   map.put("address", "Malviya-Nagar");
   map.put("city", "Jaipur");
   System.out.println(map);
  

• तरीका 2: -

   /*J2SE 5.0+ style (use of generics):*/
   Map<String, Object> map = new HashMap<>();
   map.put("name", "A");
   map.put("address", "Malviya-Nagar");
   map.put("city", "Jaipur");
   System.out.println(map);
  

• रास्ता 3: -

    Map<String, Object> map = new HashMap<String, Object>(){{
        put("name", "A");
        put("address", "Malviya-Nagar");
        put("city", "Jaipur");
    }};
    System.out.println(map);
  

• तरीका 4: -

    Map<String, Object> map = new TreeMap<String, Object>();
        map.put("name", "A");
        map.put("address", "Malviya-Nagar");
        map.put("city", "Jaipur");
    System.out.println(map);
  

• रास्ता 5: -

    //Java 8
    final Map<String, String> map =
        Arrays.stream(new String[][] {
            { "name", "A" }, 
            { "address", "Malviya-Nagar" }, 
            { "city", "jaipur" },
        }).collect(Collectors.toMap(m -> m[0], m -> m[1]));
    System.out.println(map);
  

• रास्ता 6: -

    //This way for initial a map in outside the function
    final static Map<String, String> map;
    static
    {
        map = new HashMap<String, String>();
        map.put("a", "b");
        map.put("c", "d");
    }
  

• मार्ग 7: - एक अपरिवर्तनीय एकल कुंजी-मूल्य मानचित्र बनाना।

      //Immutable single key-value map
      Map<String, String> singletonMap = Collections.singletonMap("key", "value");
  

  कृपया ध्यान दें, कि इस तरह के मानचित्र को संशोधित करना असंभव है ।

  मानचित्र को संशोधित करने के लिए किसी भी अटेम्प्ट के परिणामस्वरूप UnsupportedOperationException को फेंक दिया जाएगा।

      //Immutable single key-value pair
      Map<String, String> singletonMap = Collections.singletonMap("key", "value");
      singletonMap.put("newKey", "newValue"); //will throw UnsupportedOperationException
      singletonMap.putAll(new HashMap<>()); //will throw UnsupportedOperationException
      singletonMap.remove("key"); //will throw UnsupportedOperationException
      singletonMap.replace("key", "value", "newValue"); //will throw UnsupportedOperationException
      //and etc