मैप में

मैप के बारे में

Map एक डेटा स्ट्रक्चर है जिसमें की-वैल्यू जोड़े रखे जाते हैं। यह अन्य प्रोग्रामिंग भाषाओं की डिक्शनरी जैसा होता है। Map इंटरफेस वे ऑपरेशन परिभाषित करता है जो आप एक Map के साथ कर सकते हैं।

HashMap

Java में Map के कई अलग-अलग इम्प्लीमेंटेशन हैं। HashMap इनमें से एक आम इम्प्लीमेंटेशन है।

// Make an instance
Map<String, Integer> fruitPrices = new HashMap<>();

HashMap में एक कॉपी कंस्ट्रक्टर भी होता है।

// Make a copy of a map
Map<String, Integer> copy = new HashMap<>(fruitPrices);

put की मदद से Map में एंट्री जोड़िए।

fruitPrices.put("apple", 100);
fruitPrices.put("pear", 80);
// => { "apple" => 100, "pear" => 80 }

हर की के साथ सिर्फ एक ही वैल्यू जोड़ी जा सकती है। एक ही की के साथ put कॉल करने पर उस की से जुड़ी वैल्यू अपडेट हो जाती है।

fruitPrices.put("pear", 40);
// => { "apple" => 100, "pear" => 40 }

किसी की से जुड़ी वैल्यू पाने के लिए get का इस्तेमाल कीजिए।

fruitPrices.get("apple"); // => 100

यह देखने के लिए कि Map में कोई खास की है या नहीं, containsKey का इस्तेमाल कीजिए।

fruitPrices.containsKey("apple");   // => true
fruitPrices.containsKey("orange");  // => false

remove से एंट्री हटाइए।

fruitPrices.put("plum", 90);  // Add plum to map
fruitPrices.remove("plum");   // Removes plum from map

size मेथड एंट्री की संख्या लौटाता है।

fruitPrices.size();  // Returns 2

Map की सारी की और सारी वैल्यू पाने के लिए आप keySet या values मेथड इस्तेमाल कर सकते हैं। ये क्रमशः एक Set और एक Collection लौटाते हैं।

fruitPrices.keySet();  // Returns "apple" and "pear" in a set
fruitPrices.values();  // Returns 100 and 80, in a Collection

HashMap hashCode और equals का उपयोग करता है

HashMap यह तय करने के लिए कि किसी वैल्यू को कहाँ रखना है और किसी की से जुड़ी वैल्यू कैसे निकालनी है, ऑब्जेक्ट के hashCode और equals मेथड का उपयोग करता है। इसलिए यह ज़रूरी है कि इनके रिटर्न वैल्यू रखने और निकालने के बीच न बदलें। अगर वे बदल जाएँ, तो HashMap शायद उस वैल्यू को ढूँढ न पाए।

उदाहरण के लिए, मान लीजिए हमारे पास यह क्लास है, जिसे Map में की के रूप में इस्तेमाल किया जाएगा:

public class Stock {
    private String name;

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public int hashCode() {
        return Objects.hash(name);
    }

    @Override
    public boolean equals(Object obj) {
        if (obj == this) {
            return true;
        }
        if (Objects.equals(Stock.class, obj.getClass()) && obj instanceof Stock other) {
            return Objects.equals(name, other.name);
        }
        return false;
    }
}

hashCode और equals name फील्ड पर निर्भर करते हैं, और इस फील्ड को setName से बदला जा सकता है। hashCode बदलने से चौंकाने वाले नतीजे मिल सकते हैं:

Stock stock = new Stock();
stock.setName("Beanies");

Map<Stock, Integer> stockCount = new HashMap<>();
stockCount.put(stock, 80);

stockCount.get(stock); // Returns 80

Stock other = new Stock();
other.setName("Beanies");

stockCount.get(other); // Returns 80 because "other" and "stock" are equal

stock.setName("Choccies");
stockCount.get(stock); // Returns null because hashCode value has changed

stockCount.get(other);  // Also returns null because "other" and "stock" are not equal

stock.setName("Beanies");
stockCount.get(stock); // HashCode restored, so returns 80 again

stockCount.get(other); // Also returns 80 again because "other" and "stock" are back to equal

Map.of और Map.copyOf

Map बनाने का एक और आम तरीका Map.of या Map.ofEntries का इस्तेमाल करना है।

// Using Map.of
Map<String, Integer> temperatures = Map.of("Mon", 30, "Tue", 28, "Wed", 32);

// or using Map.ofEntries
Map<String, Integer> temperatures2 = Map.ofEntries(
    Map.entry("Mon", 30),
    Map.entry("Tue", 28),
    Map.entry("Wed", 32)
);

HashMap के उलट, ये Map को शुरुआत में ही भर देते हैं और बन जाने के बाद केवल पढ़ने योग्य हो जाते हैं। Map.copyOf Map की एक केवल पढ़ने योग्य प्रति बनाता है।

Map<String, Integer> readOnlyFruitPrices = Map.copyOf(fruitPrices);

put, remove या clear जैसे मेथड कॉल करने पर एक UnsupportedOperationException मिलता है।