एक और HashMap अंदर एक HashMap भंडारण और प्रदर्शन

Question

दिखाया के रूप में मैं एक और HashMap अंदर एक HashMap बनाई करना चाहिए जिसके नीचे क्रम

यानी पर बाहरी HashMap के प्रमुख के आधार पर आंतरिक HashMap अंदर मूल्य स्टोर कर सकते हैं में सुधार कार्यक्रम के लिए आवश्यक आउटपुट प्रारूप

{ 1 = {11 = "aaa",15 = "bbb"}, 2 = {13 = "ccc", 14 = "ddd"} } 

जहां 1,2 बाहरी हैश मैप के लिए महत्वपूर्ण मान हैं।

इसके नीचे के लिए प्रदान की कोड है वहाँ प्रदर्शन

सुधार करने के लिए किसी भी बेहतर दृष्टिकोण है

HashMap<Integer, HashMap<Integer, String>>Outer 
        = new HashMap<Integer, HashMap<Integer,String>>(); 

    BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 
    int count = Integer.parseInt(br.readLine()); 
    for(int i =0;i<count;i++) 
    { 
     String input[] = br.readLine().split("\\s"); 

     //HashMap<Integer,String>inner = new HashMap<Integer, String>(); 
     int key = Integer.parseInt(input[0]); 
     if(Outer.isEmpty() || !Outer.containsKey(key)) 
     { 
      HashMap<Integer, String> inner = new HashMap<Integer, String>(); 
      inner.put(Integer.parseInt(input[1]),input[2]); 
      Outer.put(key, inner); 
     } 
     else if(Outer.containsKey(key)) 
      { 
       HashMap<Integer, String> inner = (HashMap<Integer, String>) Outer.get(key).clone(); 
       inner.put(Integer.parseInt(input[1]), input[2]); 
       Outer.put(key, inner); 
      } 
    } 

Answer 1

वादिम के जवाब की तरह, लेकिन आगे सुधार की जरूरत नहीं है - क्योंकि यह दोनों के लिए एक कॉल की आवश्यकता नहीं है containsKey के साथ-साथ get:

Map<Integer, Map<Integer, String>> outer = new HashMap<Integer, Map<Integer, String>>(); 
BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 
int count = Integer.parseInt(br.readLine()); 

Pattern splitter = Pattern.compile("\\s"); 

for(int i = 0; i < count; i++){ 
    String input[] = splitter.split(br.readLine()); 

    int key = Integer.parseInt(input[0]); 

    Map<Integer, String> inner = outer.get(key); 
    if(inner == null){ 
     inner = new HashMap<Integer, String>(); 
     outer.put(key, inner); 
    } 
    inner.put(Integer.parseInt(input[1]), input[2]); 
} 

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

मैंने कॉल को clone पर भी हटा दिया। यह थोड़ी सी बचत हो सकती है - और मुझे नहीं लगता कि यह आपको आपके अपेक्षित परिणाम देगा।

अंत में - एक और चीज जो मैंने बदल दी है, वह मामूली सुधार हो सकता है, जो आपके स्ट्रिंग को फ़ील्ड में विभाजित करने के लिए पूर्व-संकलित पैटर्न का उपयोग कर रहा है।

Answer 2

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

HashMap<Integer, HashMap<Integer, String>>Outer = new HashMap<Integer, HashMap<Integer,String>>(); 
BufferedReader br = new BufferedReader(new InputStreamReader(System.in)); 
int count = Integer.parseInt(br.readLine()); 
for(int i =0;i<count;i++) 
{ 
    String input[] = br.readLine().split("\\s"); 

    //HashMap<Integer,String>inner = new HashMap<Integer, String>(); 
    int key = Integer.parseInt(input[0]); 
    if(!Outer.containsKey(key)) 
    { 
     HashMap<Integer, String> inner = new HashMap<Integer, String>(); 
     inner.put(Integer.parseInt(input[1]),input[2]); 
     Outer.put(key, inner); 
    } 
    else 
    { 
     HashMap<Integer, String> inner = Outer.get(key); 
     inner.put(Integer.parseInt(input[1]), input[2]); 
    } 
} 

Answer 3

अनुकूलन लगभग हमेशा एक बुरा विचार है। विशेष रूप से जावा में जहां JVM स्वयं ही ऐसा करने में काफी अच्छा है।

तुम सच में एक Map<Integer, Map<Integer, String>> की जरूरत है, मुझे लगता है कि तुम सच में सिर्फ एक Map<Pair, String> जरूरत है जहां

public final class Pair { 
    private final int x; 
    private final int y; 
    public Pair(int x, int y) { this.x = x; this.y = y;} 
} 

मैं यह दावा करते हुए नहीं कर रहा हूँ कि इस प्रदर्शन में सुधार होगा, लेकिन यह बेहतर डिजाइन हो सकता है। मुझे नहीं पता कि आप क्या कर रहे हैं, तो शायद यह बेहतर डिजाइन नहीं है।