कुंजी का उपयोग करके HashMap मान अपडेट करने के लिए Java प्रोग्राम

इस लेख में, हम समझेंगे कि कुंजी का उपयोग करके HashMap का मान कैसे अपडेट करें। Java HashMap Java के Map इंटरफेस की हैश टेबल आधारित कार्यान्वयन है। यह कुंजी-मान जोड़े का संग्रह है।

नीचे इसका प्रदर्शन है:

मान लीजिए हमारा इनपुट है:

इनपुट HashMap: {Java=1, Scala=2, Python=3}

वांछित आउटपुट होगा:

अपडेटेड मान के साथ HashMap: {Java=1, Scala=12, Python=3}

एल्गोरिदम

चरण 1 - शुरू
चरण 2 - घोषित करें
चरण 3 - मान परिभाषित करें
चरण 4 - मानों का एक HashMap बनाएं और 'put' मेथड का उपयोग करके इसमें एलिमेंट्स इनिशियलाइज़ करें
चरण 5 - कंसोल पर HashMap प्रदर्शित करें
चरण 6 - विशिष्ट मान प्राप्त करने के लिए, 'get' मेथड का उपयोग करके कुंजी का उपयोग करके HashMap एक्सेस करें
चरण 7 - प्राप्त मान में निश्चित मान जोड़ें
चरण 8 - कंसोल पर अपडेटेड मान प्रदर्शित करें
चरण 9 - रुकें

उदाहरण 1

यहाँ, हम सभी ऑपरेशन्स को 'main' फंक्शन के तहत बांधते हैं।

import java.util.HashMap;

public class Demo {
    public static void main(String[] args) {
        System.out.println("आवश्यक पैकेज आयात किए गए हैं");
        HashMap input_map = new HashMap<>();
        input_map.put("Java", 1);
        input_map.put("Scala", 2);
        input_map.put("Python", 3);
        System.out.println("HashMap परिभाषित है: " + input_map);
        
        int value = input_map.get("Scala");
        value = value + 10;
        input_map.put("Scala", value);
        
        System.out.println("\nअपडेटेड मान के साथ HashMap है: " + input_map);
    }
}

आउटपुट

आवश्यक पैकेज आयात किए गए हैं
HashMap परिभाषित है: {Java=1, Scala=2, Python=3}
अपडेटेड मान के साथ HashMap है: {Java=1, Scala=12, Python=3}

उदाहरण 2

यहाँ, हम ऑपरेशन्स को फंक्शन्स में एनकैप्सुलेट करते हैं जो ऑब्जेक्ट-ओरिएंटेड प्रोग्रामिंग प्रदर्शित करते हैं।

import java.util.HashMap;

class Demo {
    static void update(HashMap input_map, String update_string) {
        int value = input_map.get(update_string);
        value = value + 10;
        input_map.put("Scala", value);
        System.out.println("\nअपडेटेड मान के साथ HashMap है: " + input_map);
    }
    
    public static void main(String[] args) {
        System.out.println("आवश्यक पैकेज आयात किए गए हैं");
        HashMap input_map = new HashMap<>();
        input_map.put("Java", 1);
        input_map.put("Scala", 2);
        input_map.put("Python", 3);
        System.out.println("HashMap परिभाषित है: " + input_map);
        
        String update_string = "Scala";
        update(input_map, update_string);
    }
}

आउटपुट

आवश्यक पैकेज आयात किए गए हैं
HashMap परिभाषित है: {Java=1, Scala=2, Python=3}
अपडेटेड मान के साथ HashMap है: {Java=1, Scala=12, Python=3}

बेहतर दृष्टिकोण: compute/merge मेथड्स (Java 8+)

// compute - मान की गणना करने के लिए फंक्शन स्वीकार करता है
input_map.compute("Scala", (k, v) -> v == null ? 10 : v + 10);

// merge - यदि कुंजी अनुपस्थित है तो मान सेट करता है, अन्यथा मर्ज फंक्शन लागू करता है
input_map.merge("Scala", 10, (oldVal, newVal) -> oldVal + newVal);

// replace - केवल तभी रिप्लेस करता है जब कुंजी मौजूद हो
input_map.replace("Scala", input_map.get("Scala") + 10);

महत्वपूर्ण विचार

• Null चेक: get() null लौटा सकता है, NullPointerException से बचें
• एटॉमिक ऑपरेशन्स: ConcurrentHashMap के लिए compute/merge एटॉमिक हैं
• अपरिवर्तनीयता: स्ट्रिंग कुंजियाँ अपरिवर्तनीय हैं, सुरक्षित
• वैकल्पिक: getOrDefault(key, defaultValue) null हैंडलिंग के लिए

सामान्य पैटर्न

// सुरक्षित अपडेट पैटर्न
input_map.computeIfPresent("Scala", (k, v) -> v + 10);

// काउंटर पैटर्न
map.merge(word, 1, Integer::sum);

// कैशिंग पैटर्न
map.computeIfAbsent(key, k -> expensiveComputation(k));