Java: how to convert HashMap<String, Object> to array

Question

I need to convert a HashMap<String, Object> to an array; could anyone show me how it's done?

• harto: you want the keys, the values, or both?

Answer 1

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

---

Edit

It should be noted that the ordering of both arrays may not be the same, See oxbow_lakes answer for a better approach for iteration when the pair key/values are needed.

• CrackerJack9: Actually, this code offers no guarantee that hashMap.keySet().toArray()[0] will be the original key for hashMap.values().toArray()[0] from the original Map. So this is extremely dangerous
• Jake Wilson: @CrackerJack9 can you explain?
• Landon Kuhn: The keys wont correspond to their values across the two arrays.
• CrackerJack9: @Jakobud landon9720 is correct...the order is psuedo-random, and it cannot be guaranteed that key[0] will correspond to value[0] after you convert the keys to a Set and the values to a Collection. While they are technically converted to arrays (and answers your question), the concept of the key-value pair has been lost - which is why this is a very misleading (and dangerous) answer....
• artxur: I can attest to the danger of this code snippet. When I wrote it, my terminal reached out and slapped me. Extremely dangerous! Beware!

Answer 2

If you want the keys and values, you can always do this via the entrySet:

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

From each entry you can (of course) get both the key and value via the getKey and getValue methods

• Tobiq: @CrackerJack9 No, it works. Unlike the accepted solution, this one maintains the key-value pairs. You get {key, value}[] as opposed to key[], value[]
• Damola Obaleke: This seems a better solution

Answer 3

If you have HashMap<String, SomeObject> hashMap then:

hashMap.values().toArray();

Will return an Object[]. If instead you want an array of the type SomeObject, you could use:

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

• Paul Bellora: I think you mean values() instead of keySet() for an array of SomeObject.
• Hamburg is nice: @Alex "In older Java versions using pre-sized array was recommended (...) However since late updates of OpenJDK 6 this call was intrinsified, making the performance of the empty array version the same and sometimes even better, compared to the pre-sized version. Also passing pre-sized array is dangerous for a concurrent or synchronized collection as a data race is possible between the size and toArray call which may result in extra nulls at the end of the array, if the collection was concurrently shrunk during the operation." - intellij

Answer 4

To guarantee the correct order for each array of Keys and Values, use this (the other answers use individual Sets which offer no guarantee as to order.

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

• Aquarius Power: perfect! we get both key and value, with auto types fill in eclipse, long time looking for this, thx!

Answer 5

An alternative to CrackerJacks suggestion, if you want the HashMap to maintain order you could consider using a LinkedHashMap instead. As far as im aware it's functionality is identical to a HashMap but it is FIFO so it maintains the order in which items were added.

Answer 6

I used almost the same as @kmccoy, but instead of a keySet() I did this

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

Answer 7

If you are using Java 8+ and need a 2 dimensional Array, perhaps for TestNG data providers, you can try:

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

If your Objects are Strings and you need a String[][], try:

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

Answer 8

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

Answer 9

To Get in One Dimension Array.

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

To Get in two Dimension Array.

 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 10

In the case keys and values are strings and you want to alternate key and value in the same array:

String[] result = myMap.entrySet()
 .stream()
 .flatMap(entry -> Stream.of(entry.getKey(),entry.getValue()))
 .toArray(String[]::new);
// result = {key_1, value_1, key_2, value_2 ...}

Answer 11

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

Answer 12

You may try this too.

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

Here I am using String as return type. You may change it to required return type by you.

• Choletski: the question is about HashMap() but your solution is about Hashtable()... There are some differences between them

Answer 13

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

Answer 14

if you need to pass values to an array of objects try:

Array:
Object[] object= hashMap.values().toArray(new Object[0]);
Arraylist:
ArrayList<Object> object=new ArrayList<>(hashMap.values());