Java: So konvertieren Sie HashMap <String, Object> in ein Array

Wenn Sie die Schlüssel und Werte wünschen, können Sie dies immer über die entrySet tun:

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

Sie können von jedem Eintrag (natürlich) sowohl den Schlüssel als auch über die Methoden getKey und getValue erhalten

Wenn Sie HashMap<String, SomeObject> hashMap dann haben

hashMap.values().toArray();

gibt ein Objekt [] zurück. Wenn Sie stattdessen ein Array vom Typ SomeObject möchten, können Sie Folgendes verwenden:

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

Um die korrekte Reihenfolge für jedes Array von Schlüsseln und Werten zu gewährleisten, verwenden Sie diese Option (die anderen Antworten verwenden einzelne Sets, die keine Garantie für die Bestellung bieten.

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++;
}

Eine Alternative zum CrackerJacks-Vorschlag: Wenn Sie möchten, dass die HashMap die Reihenfolge beibehält, können Sie stattdessen eine LinkedHashMap verwenden. Soweit sie sich bewusst sind, ist ihre Funktionalität identisch mit einer HashMap, jedoch mit FIFO, sodass die Reihenfolge beibehalten wird, in der Elemente hinzugefügt wurden.

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]);
    }
}

Ich habe fast das gleiche wie @kmccoy verwendet, aber anstelle von keySet() habe ich das gemacht

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

Um in ein Dimension-Array zu gelangen. 

    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++;
    }

In zwei Dimension Array zu bekommen. 

   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++;
}

Wenn Sie Java 8+ verwenden und ein zweidimensionales Array benötigen, möglicherweise für TestNG-Datenanbieter, können Sie Folgendes versuchen:

map.entrySet()
    .stream()
    .map(e -> new Object[]{e.getKey(), e.getValue()})
    .toArray(Object[][]::new);

Wenn Ihre Objects Strings sind und Sie einen String[][] benötigen, versuchen Sie Folgendes:

map.entrySet()
    .stream()
    .map(e -> new String[]{e.getKey(), e.getValue().toString()})
    .toArray(String[][]::new);

Sie können dies auch versuchen.

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;
    }

Hier verwende ich String als Rückgabetyp. Sie können den von Ihnen gewünschten Rückgabetyp ändern.

@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;
    }

HashMap<String, String> hashMap = new HashMap<>();
String[] stringValues= new String[hashMap.values().size()];
hashMap.values().toArray(stringValues);