Ich muss a HashMap<String, Object>in ein Array konvertieren . Kann mir jemand zeigen, wie es geht?

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

Bearbeiten

Es sollte beachtet werden, dass die Reihenfolge beider Arrays möglicherweise nicht gleich ist. Siehe oxbow_lakes Antwort für einen besseren Ansatz für die Iteration, wenn der Paarschlüssel / die Paarwerte benötigt werden.

Wenn Sie die Schlüssel und Werte möchten, können Sie dies jederzeit über Folgendes tun entrySet:

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

Von jedem Eintrag können Sie (natürlich) sowohl den Schlüssel als auch den Wert über die Methoden getKeyund getValueabrufen

Wenn Sie HashMap<String, SomeObject> hashMapdann haben:

hashMap.values().toArray();

Wird eine zurückgeben Object[]. Wenn Sie stattdessen ein Array des Typs möchten SomeObject, können Sie Folgendes verwenden:

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

Verwenden Sie diese Option, um die richtige Reihenfolge für jedes Array von Schlüsseln und Werten zu gewährleisten (bei den anderen Antworten werden Personen verwendet, Setdie 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 Vorschlag von CrackerJacks. Wenn Sie möchten, dass die HashMap die Reihenfolge beibehält, können Sie stattdessen eine LinkedHashMap verwenden. Soweit mir bekannt ist, ist die Funktionalität identisch mit einer HashMap, es handelt sich jedoch um FIFO, sodass die Reihenfolge beibehalten wird, in der Elemente hinzugefügt wurden.

Ich habe fast das gleiche wie @kmccoy verwendet, aber stattdessen habe keySet()ich dies getan

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

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

Object[][] twoDarray = new Object[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];
}

// Print out the new 2D array
for (int i = 0; i < twoDarray.length; i++) {
    for (int j = 0; j < twoDarray[i].length; j++) {
        System.out.println(twoDarray[i][j]);
    }
}

In ein eindimensionales Array 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++;
    }

Um in ein zweidimensionales Array zu gelangen.

   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 eine zweidimensionale Version benötigen Array, 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 Ihr Objects Strings ist und Sie ein benötigen String[][], versuchen Sie:

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 es in 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);