Introduction

In order to turn Java Map to array, it always depend what you actually want to take from the Map itself. You can only want keys or values or transform key-value pairs on a completely different object while turning them into an array.

Note

We need to note, that in most of our examples we will use HashMap implementation as underlying layer upon which the algorithms are build. If the implementation change and it will affect the algorithm, it will be notably depicted and described.

Map Map.Entry to Array

Our first approach is the simplest and probably covers most of the cases in real life. The approach obtains Map.Entry from Map and then turn the collection to an array.

We will use non-parametrized call of Set.toArray() for Entry collection. Let’s look at the example below:

// Method to convert Map entry set into an Array in Java
public static void entrySetToArray()
{
    final Map map = new HashMap<>();

    map.put("John Doe", "555-869-759");
    map.put("Thomas Cook", "555-906-941");
    map.put("Paul Smith", "555-400-321");

    // Gets the Map entry set and turns it into an Array of Objects
    final Object[] objectArray = map.entrySet().toArray();

    System.out.println(Arrays.toString(objectArray));
}

Output

[Paul Smith=555-400-321, John Doe=555-869-759, Thomas Cook=555-906-941]

Map Keys to Array

Sometimes we want to map Map keys to an array. For this we need to use combination of Map.keySet() for obtaining keys and parametrized call of Set.toArray(T[] a) method for keeping a set of keys. Than we can turn key set to an Array.

// Method to convert Map keys into an Array in Java
public static void keySetToArray()
{
    final Map map = new HashMap<>();<>

    map.put("John Doe", "555-869-759");
    map.put("Thomas Cook", "555-906-941");
    map.put("Paul Smith", "555-400-321");

    // Gets the Map set of keys which is turned to an Array of Strings
    String[] keys = map.keySet().toArray(new String[0]);

    System.out.println(Arrays.toString(keys));
}

Output

[Paul Smith, John Doe, Thomas Cook]

Map Values to Array

Other times, we want to map Map values to an array. For this we need to use combination of Map.values() for obtaining keys and parametrized call of Collection.toArray(T[] a) method for keeping a collection of values. Than we can turn value collection to an Array.

// Method to convert Map values into an Array in Java
public static void valuesCollectionToArray()
{
    final Map map = new HashMap<>();

    map.put("John Doe", "555-869-759");
    map.put("Thomas Cook", "555-906-941");
    map.put("Paul Smith", "555-400-321");

    // Gets the Map collection of values and turn it into the Array of Strings
    String[] values = map.values().toArray(new String[0]);

    System.out.println(Arrays.toString(values));
}

Output

[555-400-321, 555-869-759, 555-906-941]

Map to Array with element order secured

We have seen that we can get an array of keys and values of the Map using Map.keySet() and Map.values(). Using both methods we can keep the individual elements in separate arrays and construct a new array of key-value pairs from them.

However we will need to use different Map interface implementation than HashMap. We have to use LinkedHashMap which can secure the order of elements in the order of their insertion into the Map data structure implementation. In this way, we can create two different arrays, one for keys and the second for values, but we can rest assure that the order of elements in individual arrays will be matching their mutual pair in the Map.

// Method to convert Map elements to an Array in Java
// However, the core of this method lies in the Map's implementation LinkedHashMap
// which maintains the order of inserted elements in the order of their insertion.
public static void useLinkedHashMapElementOrderForArrayConversion()
{
    final Map map = new LinkedHashMap<>();

    map.put("John Doe", "555-869-759");
    map.put("Thomas Cook", "555-906-941");
    map.put("Paul Smith", "555-400-321");

    // Get an array of keys in order of the LinkedHashMap
    final String[] keys = map.keySet().toArray(new String[0]);

    // Get an array of values in order of the LinkedHashMap
    final String[] values = map.values().toArray(new String[0]);

    for (int i = 0; i < map.size(); i++) {
        System.out.println( "[ " + keys[i] + " = " + values[i] + " ]" );
    }
}

Output

[ John Doe = 555-869-759 ]
[ Thomas Cook = 555-906-941 ]
[ Paul Smith = 555-400-321 ]

Map to Array with element order unsecured

Finally, we need to discuss the option when the elements' order is not secured, but we want to use two different arrays for help.

When we look on the algorithm above, it seems a little bit straightforward how to map elements to an array. However, when HashMap or TreeMap implementation of Map is used, the order of element in both arrays might change. For example for any index i, there is no guarantee that key[i] will represents the pairing key for value[i] value. To guarantee the correct pair position we need to construct helping arrays and map the pair position into the same indexes in helping arrays.

// Method to convert Map to an Array in Java
public static void maintainKeySetAndValueCollectionArray()
{
    final Map map = new HashMap<>();

    map.put("John Doe", "555-869-759");
    map.put("Thomas Cook", "555-906-941");
    map.put("Paul Smith", "555-400-321");

    // Temporary array to store map keys
    final String[] keys = new String[map.size()];

    // Temporary array to store map values
    final String[] values = new String[map.size()];

    int i = 0;

    for (Map.Entry entry : map.entrySet()) {
        keys[i] = entry.getKey();
        values[i] = entry.getValue();
        i++;
    }

    for (i = 0; i < map.size(); i++) {
        System.out.println( "[ " + keys[i] + " = " + values[i] + " ]" );
    }
}

Note

i is local variable. We can insert i incrementation into the values[i] if you like concise code. However for more readable code, we recomment the incrementation to place on to the new line.

Also, local i variable is reseted for System.out line printing.

Output

[ Paul Smith = 555-400-321 ]
[ John Doe = 555-869-759 ]
[ Thomas Cook = 555-906-941 ]

Conclusion

This article has shown how to convert Java's Map to an Array by various approaches.

All algorithms are placed in the Java method for quick copy and paste into your projects.

While the first three algorithms (Entry, Keys, Values) will cover most of the real-life scenarios of Map to Array conversion, we have shown two more approaches which give you a space for more transformation and conversion. Plus, last two approaches (Map element order secured, Map element order unsecured) pointing out solutions for element order Map security issues.

As always, you can find all our examples on our GitHub project!

Introduction

Every approach for sorting a map consists of a few consequent steps, no matter by which map’s property (key/value)n we want to sort Map.

Basic sorting algorithm

Sorting Map algorithm goes like this:

• First, we convert a Map into a Stream
• Second, we sort streaming elements
• Third, we collect sorted elements, and we maintain order by placing elements into the correct data structure (LinkedHashMap)

HashMap entrySet() method in Java

The java.util.HashMap.entrySet() method in Java is used to create a set out of the same elements contained in the HashMap. It returns a set of entries from the HashMap. Alternatively we can create a new set and store the map elements into it.

Sort Map by Keys

public void sortMapByKeys() {

    Map<String, Integer> unsortedMap = new HashMap<>();

    unsortedMap.put("z", 0);
    unsortedMap.put("b", 5);
    unsortedMap.put("a", 6);
    unsortedMap.put("e", 7);
    unsortedMap.put("k", 8);
    unsortedMap.put("f", 9);
    unsortedMap.put("n", 100);
    unsortedMap.put("o", -4);
    unsortedMap.put("m", 2);
    unsortedMap.put("d", 1);

    System.out.println("Unsorted map: ");
    System.out.println(unsortedMap);

    // We need a LinkedHashMap to keep an order of newly returned sorted map.
    Map<String, Integer> result = unsortedMap.entrySet()
        .stream()
        .sorted(Map.Entry.comparingByKey())
        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (oldValue, newValue) -> oldValue, LinkedHashMap::new));

    // Alternative way
    Map<String, Integer> resultAlternative = new LinkedHashMap<>();
    unsortedMap.entrySet()
        .stream()
        .sorted(Map.Entry.comparingByKey())
        .forEachOrdered(x -> resultAlternative.put(x.getKey(), x.getValue()));

    System.out.println("Sorted map by keys: ");
    System.out.println(result);
    System.out.println(resultAlternative);
}

Output

Unsorted map:
{a=6, b=5, d=1, e=7, f=9, z=0, k=8, m=2, n=100, o=-4}

Sorted map by keys:
{a=6, b=5, d=1, e=7, f=9, k=8, m=2, n=100, o=-4, z=0}
{a=6, b=5, d=1, e=7, f=9, k=8, m=2, n=100, o=-4, z=0}

Order in unsortedMap is not secured. However, after the map sorting with the key, we can see that the map is ordered. The newly created map is placed in LinkedHashMap implementation, which maintains the elements’ order.

Sort Map by Values

public void sortMapByValues() {

    Map<String, Integer> unsortedMap = new HashMap<>();

    unsortedMap.put("z", 0);
    unsortedMap.put("c", 7);
    unsortedMap.put("q", 4);
    unsortedMap.put("a", 6);
    unsortedMap.put("e", 7);
    unsortedMap.put("k", 8);
    unsortedMap.put("n", 100);
    unsortedMap.put("o", -4);
    unsortedMap.put("m", 2);
    unsortedMap.put("d", 1);

    System.out.println("Unsorted map: ");
    System.out.println(unsortedMap);

    // We need a LinkedHashMap to keep an order of newly returned sorted map.
    Map<String, Integer> result = unsortedMap.entrySet()
        .stream()
        .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))
        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (oldValue, newValue) -> oldValue, LinkedHashMap::new));

    // Alternative way
    Map<String, Integer> resultAlternative = new LinkedHashMap<>();
    unsortedMap.entrySet()
        .stream()
        .sorted(Map.Entry.<String, Integer>comparingByValue().reversed())
        .forEachOrdered(x -> resultAlternative.put(x.getKey(), x.getValue()));

    System.out.println("Sorted map by values: ");
    System.out.println(result);

    System.out.println("Sorted map by values (alternative approach): ");
    System.out.println(resultAlternative);
}

Output

Unsorted map:
{q=4, a=6, c=7, d=1, e=7, z=0, k=8, m=2, n=100, o=-4}

Sorted map by values:
{n=100, k=8, c=7, e=7, a=6, q=4, m=2, d=1, z=0, o=-4}

Sorted map by values (alternative approach):
{n=100, k=8, c=7, e=7, a=6, q=4, m=2, d=1, z=0, o=-4}

Order in unsortedMap is not secured. However, after the map is sorted by value, we can see it is in order. The newly created map is kept in LinkedHashMap implementation, which maintains the elements’ order.

Sort special case of Map<Object,Object>

There exist special case in Map sorting. It is when we place Object type into the Map parameters. The Stream can’t sort the Map<Object, Object> directly. To solve this case we need to convert Map<Object, Object> into Map<String, String>. Let’s take a look on the code example below:

Note : If you have better idea for Map sorting, let me know in comments below.

public void sortObjectMap() {

    // Example of the Object map
    Properties properties = System.getProperties();
    Set<Map.Entry<Object, Object>> entries = properties.entrySet();

    System.out.println("Unsorted Object map: ");
    entries.forEach(System.out::println);

    LinkedHashMap<String, String> collect = entries.stream()
        .collect(Collectors.toMap(k -> (String) k.getKey(), e -> (String) e.getValue()))
        .entrySet()
        .stream()
        .sorted(Map.Entry.comparingByKey())
        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue, (oldValue, newValue) -> oldValue, LinkedHashMap::new));

    System.out.println("Sorted Object map by keys: ");
    result.forEach((key, value) -> System.out.println(key + " : " + value));
}

Output

Unsorted Object map:
sun.desktop=windows
java.specification.version=8
...

Sorted Object map by keys:
awt.toolkit:sun.awt.windows.WToolkit
file.encoding:UTF-8
file.separator:\
java.awt.graphicsenv:sun.awt.Win32GraphicsEnvironment
...

Conclusion

In this article we have shown how to sort Map by key and by value. As some implementation of Map do not maintain order we created ordered maps with LinkedHashMap.

Eventually we have shown a special case of Map<Object, Object> which require transformation of Object into the string in order to to be compared by key or value.

As always, you can find all our examples on our GitHub project!