जावा: हैश मैप <स्ट्रिंग, ऑब्जेक्ट> को सरणी

Question

में कनवर्ट करने के लिए मुझे HashMap<String, Object> को सरणी में कनवर्ट करने की आवश्यकता है; क्या कोई मुझे दिखा सकता है कि यह कैसे हुआ?

Answer 1

hashMap.keySet().toArray(); // returns an array of keys 
hashMap.values().toArray(); // returns an array of values 

संपादित

ध्यान दिया जाना चाहिए कि दोनों सरणियों के आदेश नहीं जब जोड़ी कुंजी/मान की जरूरत है यात्रा के लिए एक बेहतर दृष्टिकोण के लिए एक ही है, देखें oxbow_lakes जवाब हो सकता है। getKey और getValue के माध्यम से प्रत्येक प्रविष्टि आप (बेशक) प्राप्त कर सकते हैं दोनों कुंजी और मूल्य से

hashMap.entrySet().toArray(); // returns a Map.Entry<K,V>[] 

:

Answer 2

आप कुंजी और मूल्यों चाहते हैं, आप हमेशा इस entrySet के माध्यम से कर सकते हैं तरीकों

Answer 3

Map<String, String> map = new HashMap<String, String>(); 
map.put("key1", "value1"); 
map.put("key2", "value2"); 

Object[][] twoDarray = new String[map.size()][2]; 

Object[] keys = map.keySet().toArray(); 
Object[] values = map.values().toArray(); 

for (int row = 0; row < twoDarray.length; row++) { 
    twoDarray[row][0] = keys[row]; 
    twoDarray[row][1] = values[row]; 
} 

for (int i = 0; i < twoDarray.length; i++) { 
    for (int j = 0; j < twoDarray[i].length; j++) { 
     System.out.println(twoDarray[i][j]); 
    } 
} 

Answer 4

यदि आपके पास HashMap<String, SomeObject> hashMap तो

hashMap.values().toArray();

एक ऑब्जेक्ट [] वापस कर देगा। आप प्रकार SomeObject की एक सरणी चाहते हैं बजाय, आप इस्तेमाल कर सकते हैं:

hashMap.values().toArray(new SomeObject[0]);

Answer 5

कुंजियां और मान से प्रत्येक सरणी के लिए सही क्रम की गारंटी करने के लिए, का उपयोग इस (अन्य उत्तर का उपयोग अलग-अलग Set रों जो की पेशकश नहीं आदेश के रूप में गारंटी।

Map<String, Object> map = new HashMap<String, Object>(); 
String[] keys = new String[map.size()]; 
Object[] values = new Object[map.size()]; 
int index = 0; 
for (Map.Entry<String, Object> mapEntry : map.entrySet()) { 
    keys[index] = mapEntry.getKey(); 
    values[index] = mapEntry.getValue(); 
    index++; 
} 

Answer 6

crackerjacks सुझाव के लिए एक वैकल्पिक, अगर आप व्यवस्था बनाए रखने के HashMap चाहते हैं। इसके स्थान पर कोई LinkedHashMap उपयोग करने पर विचार कर सकता है जहां तक ​​im बारे में पता के रूप में यह सुविधा है एक HashMap के समान है, लेकिन यह फीफो है इसलिए यह उस क्रम को बनाए रखता है जिसमें आइटम जोड़े गए थे।

Answer 7

आप इसे भी आजमा सकते हैं।

public static String[][] getArrayFromHash(Hashtable<String,String> data){ 
     String[][] str = null; 
     { 
      Object[] keys = data.keySet().toArray(); 
      Object[] values = data.values().toArray(); 
      str = new String[keys.length][values.length]; 
      for(int i=0;i<keys.length;i++) { 
       str[0][i] = (String)keys[i]; 
       str[1][i] = (String)values[i]; 
      } 
     } 
     return str; 
    } 

यहां मैं स्ट्रिंग का उपयोग रिटर्न प्रकार के रूप में कर रहा हूं। आप इसे अपने द्वारा आवश्यक वापसी प्रकार में बदल सकते हैं।

Answer 8

एक आयाम ऐरे में प्राप्त करने के लिए।

String[] arr1 = new String[hashmap.size()]; 
    String[] arr2 = new String[hashmap.size()]; 
    Set entries = hashmap.entrySet(); 
    Iterator entriesIterator = entries.iterator(); 

    int i = 0; 
    while(entriesIterator.hasNext()){ 

     Map.Entry mapping = (Map.Entry) entriesIterator.next(); 

     arr1[i] = mapping.getKey().toString(); 
     arr2[i] = mapping.getValue().toString(); 

     i++; 
    } 

दो आयाम सरणी में प्राप्त करने के लिए।

String[][] arr = new String[hashmap.size()][2]; 
    Set entries = hashmap.entrySet(); 
    Iterator entriesIterator = entries.iterator(); 

    int i = 0; 
    while(entriesIterator.hasNext()){ 

    Map.Entry mapping = (Map.Entry) entriesIterator.next(); 

    arr[i][0] = mapping.getKey().toString(); 
    arr[i][1] = mapping.getValue().toString(); 

    i++; 
} 

Answer 9

मैं लगभग @kmccoy के रूप में ही इस्तेमाल किया है, लेकिन एक keySet() के बजाय मैं इस

hashMap.values().toArray(new MyObject[0]); 

Answer 10

@SuppressWarnings("unchecked") 
    public static <E,T> E[] hashMapKeysToArray(HashMap<E,T> map) 
    { 
     int s; 
     if(map == null || (s = map.size())<1) 
      return null; 

     E[] temp; 
     E typeHelper; 
     try 
     { 
      Iterator<Entry<E, T>> iterator = map.entrySet().iterator(); 
      Entry<E, T> iK = iterator.next(); 
      typeHelper = iK.getKey(); 

      Object o = Array.newInstance(typeHelper.getClass(), s); 
      temp = (E[]) o; 

      int index = 0; 
      for (Map.Entry<E,T> mapEntry : map.entrySet()) 
      { 
       temp[index++] = mapEntry.getKey(); 
      } 
     } 
     catch (Exception e) 
     { 
      return null; 
     } 
     return temp; 
    } 
//-------------------------------------------------------- 
    @SuppressWarnings("unchecked") 
    public static <E,T> T[] hashMapValuesToArray(HashMap<E,T> map) 
    { 
     int s; 
     if(map == null || (s = map.size())<1) 
      return null; 

     T[] temp; 
     T typeHelper; 
     try 
     { 
      Iterator<Entry<E, T>> iterator = map.entrySet().iterator(); 
      Entry<E, T> iK = iterator.next(); 
      typeHelper = iK.getValue(); 

      Object o = Array.newInstance(typeHelper.getClass(), s); 
      temp = (T[]) o; 

      int index = 0; 
      for (Map.Entry<E,T> mapEntry : map.entrySet()) 
      { 
       temp[index++] = mapEntry.getValue(); 
      } 
     } 
     catch (Exception e) 
     {return null;} 

     return temp; 
    }