स्ट्रिंग का स्थैतिक मानचित्र कैसे बनाएं -> ऐरे

Question

मुझे एक स्थिर Map बनाने की आवश्यकता है जो String को int की सरणी में दिया गया है।

दूसरे शब्दों में, मैं की तरह कुछ का निर्धारण कैसे करेंगे:

"fred" -> {1,2,5,8} 
"dave" -> {5,6,8,10,11} 
"bart" -> {7,22,10010} 
... etc 

वहाँ एक आसान तरीका जावा में यह करने के लिए है?

और यदि संभव हो, तो मैं static स्थिरांक String और int मानों दोनों के लिए उपयोग करना चाहता हूं।

संपादित करें: स्पष्ट करने के लिए मैं मूल्यों के लिए static स्थिरांक द्वारा क्या मतलब है, और देने के लिए क्या है तो सही कोड होने के लिए देखते हैं, यहाँ समाधान पर मेरी पहली वार है:

public final static String FRED_TEXT = "fred"; 
public final static String DAVE_TEXT = "dave"; 

public final static int ONE = 1; 
public final static int TWO = 2; 
public final static int THREE = 3; 
public final static int FOUR = 4; 

public final static HashMap<String, int[]> myMap = new HashMap<String, int[]>(); 
static { 
    myMap.put(FRED_TEXT, new int[] {ONE, TWO, FOUR}); 
    myMap.put(DAVE_TEXT, new int[] {TWO, THREE}); 
} 

ध्यान दें, ये नाम वह नहीं हैं जो मैं वास्तव में उपयोग कर रहा हूं। यह सिर्फ एक विकसित उदाहरण है।

Answer 1

आप को घोषणा और प्रारंभिकरण को अलग करने की आवश्यकता नहीं है। यदि आप जानते हैं कि, यह सब एक पंक्ति में किया जा सकता है!

// assumes your code declaring the constants ONE, FRED_TEXT etc is before this line 
private static final Map<String, int[]> myMap = Collections.unmodifiableMap(
    new HashMap<String, int[]>() {{ 
     put(FRED_TEXT, new int[] {ONE, TWO, FOUR}); 
     put(DAVE_TEXT, new int[] {TWO, THREE}); 
    }}); 

क्या हम यहाँ है एक inialization block साथ एक अनाम वर्ग है - कोड का एक खंड है कि निर्माता के बाद निर्माण पर कार्यान्वित करता है, जो हम यहाँ का उपयोग किया है नक्शा लोड करने के लिए (यह कभी कभी ग़लती से "डबल ब्रेस के रूप में जाना जाता है प्रारंभिकरण "- मुझे लगता है क्योंकि दो आसन्न ब्रेसिज़ हैं = लेकिन वास्तव में ऐसी कोई चीज़ नहीं है)।

इसके बारे में दो अच्छी चीजें हैं) यह सामग्री के साथ घोषणा से शादी करती है और बी) क्योंकि प्रारंभिकता ऑनलाइन है, आप Collections.unmodifiableMap() पर एक ऑनलाइन कॉल भी कर सकते हैं, जिसके परिणामस्वरूप एक साफ एक पंक्ति हो सकती है घोषणा, प्रारंभिकरण और अपरिवर्तनीय में रूपांतरण।

आप की जरूरत/नहीं है, तो नक्शा, unmodifiable हो कि कॉल बाहर छोड़ना चाहते हैं:

private static final Map<String, int[]> myMap = new HashMap<String, int[]>() {{ 
    put(FRED_TEXT, new int[] {ONE, TWO, FOUR}); 
    put(DAVE_TEXT, new int[] {TWO, THREE}); 
}}; 

Answer 2

static Map<String, int[]> map = new HashMap<>(); 

नक्शा, स्थिर है आप कक्षा में परिभाषित किया है का उदाहरण बनाकर बिना पहुँच सकते हैं। मैं नहीं जानता कि आप कुंजी होने के साथ क्या मतलब है और साथ ही स्थिर महत्व देता है क्योंकि यह कोई मतलब नहीं है मेरे लिए।

Answer 3

आपको अपने स्थिर मानचित्र को अलग से घोषित करने और आरंभ करने की आवश्यकता है।

static { 
    Map<String,int[]> tmpMap = new HashMap<String,int[]>(); 
    tmpMap.put("fred", new int[] {1,2,5,8}); 
    tmpMap.put("dave", new int[] {5,6,8,10,11}); 
    tmpMap.put("bart", new int[] {7,22,10010}); 
    MyMap = Collections.unmodifiableMap(tmpMap); 
} 

दुर्भाग्य से, सरणियों हमेशा जावा में लिखने योग्य हैं:

private static final Map<String,int[]> MyMap; 

यहाँ प्रारंभ टुकड़ा है:

यहाँ घोषणा टुकड़ा है। आप MyMap असाइन करने में सक्षम नहीं होंगे, लेकिन आप अपने प्रोग्राम के अन्य हिस्सों से मूल्य जोड़ने या निकालने में सक्षम होंगे जो मानचित्र तक पहुंचता है।

Answer 4

public class ExampleClass { 
    public final static HashMap consts = new HashMap(); 
    static 
    { 
     constants.put("A", "The Letter A"); 
     constants.put("B", "The Letter B"); 
     constants.put("C", "The Letter C"); 
    } 
    /* Rest of your class that needs to know the consts */ 
} 

Answer 5

पूर्णता के लिए के लिए के रूप में इस 'जावा स्थिर के लिए गूगल का पहला परिणाम है मानचित्र को परिभाषित करें 'जावा 8 में आप अब यह कर सकते हैं।

Collections.unmodifiableMap(Stream.of(
      new SimpleEntry<>("a", new int[]{1,2,3}), 
      new SimpleEntry<>("b", new int[]{1,2,3}), 
      new SimpleEntry<>("c", new int[]{1,2,3})) 
      .collect(Collectors.toMap((e) -> e.getKey(), (e) -> e.getValue()))); 

इस के साथ यह अच्छा हिस्सा है कि हम डबल ब्रेस वाक्य रचना ({{ }})

हम तो इस आदमी की तरह पैटर्न को साफ करने के लिए कुछ कोड के साथ इस विस्तार कर सकते हैं के साथ अब और गुमनाम कक्षाएं नहीं बना रहे हैं है यहां किया http://minborgsjavapot.blogspot.ca/2014/12/java-8-initializing-maps-in-smartest-way.html

public static <K, V> Map.Entry<K, V> entry(K key, V value) { 
    return new AbstractMap.SimpleEntry<>(key, value); 
} 

public static <K, U> Collector<Map.Entry<K, U>, ?, Map<K, U>> entriesToMap() { 
    return Collectors.toMap((e) -> e.getKey(), (e) -> e.getValue()); 
} 

public static <K, U> Collector<Map.Entry<K, U>, ?, ConcurrentMap<K, U>> entriesToConcurrentMap() { 
    return Collectors.toConcurrentMap((e) -> e.getKey(), (e) -> e.getValue()); 
} 

अंतिम परिणाम

Collections.unmodifiableMap(Stream.of(
      entry("a", new int[]{1,2,3}), 
      entry("b", new int[]{1,2,3}), 
      entry("c", new int[]{1,2,3})) 
      .collect(entriesToMap())); 

जो हमें एक समवर्ती अप्रचलित मानचित्र प्रदान करेगा।