{"id":4091,"date":"2018-04-20T17:26:40","date_gmt":"2018-04-20T21:26:40","guid":{"rendered":"http:\/\/springframework.guru\/?p=4091"},"modified":"2019-06-24T20:25:00","modified_gmt":"2019-06-25T00:25:00","slug":"converting-java-map-to-list","status":"publish","type":"post","link":"https:\/\/springframework.guru\/converting-java-map-to-list\/","title":{"rendered":"Converting Java Map to List"},"content":{"rendered":"

Converting a Java Map<\/a> to a List<\/a> is a very common task. Map<\/code> and List<\/code> are common data structures used in Java. A Map<\/code> is a collection of key value pairs. While a\u00a0List<\/code> is an ordered collection of objects in which duplicate values can be stored.<\/p>\n

In this post, I will discuss different ways to convert a Map<\/code> to a List<\/code>.<\/p>\n

For the example code in this post, I\u2019ll provide JUnit tests. If you are new to JUnit, I suggest you go through my series on Unit Testing with JUnit<\/a>.<\/p>\n

Converting Map Keys to List<\/h2>\n

The Map<\/code> class comes with the keyset()<\/code> method that returns a Set<\/code> view of the keys contained in the map. The code to convert all the keys of a Map<\/code> to a Set<\/code> is this.<\/p>\n

public List<Integer> convertMapKeysToList(Map<Integer,String> map){\r\n    List<Integer> listOfKeys = new ArrayList(map.keySet());\r\n    return listOfKeys;\r\n}<\/pre>\n
Here is the JUnit test code.<\/p>\n
package springframework.guru;\r\n\r\nimport org.junit.After;\r\nimport org.junit.Before;\r\nimport org.junit.Test;\r\nimport org.hamcrest.collection.IsEmptyCollection;\r\nimport java.util.HashMap;\r\nimport java.util.List;\r\nimport java.util.Map;\r\nimport static org.hamcrest.CoreMatchers.not;\r\nimport static org.hamcrest.Matchers.hasSize;\r\nimport static org.hamcrest.core.IsCollectionContaining.hasItems;\r\nimport static org.junit.Assert.*;\r\nimport static org.hamcrest.collection.IsIterableContainingInAnyOrder.containsInAnyOrder;\r\n\r\npublic class MapToListConverterTest {\r\n    MapToListConverter mapToListConverter;\r\n    Map<Integer, String> countryDialCodeMap;\r\n\r\n    @Before\r\n    public void setUp() throws Exception {\r\n        mapToListConverter = new MapToListConverter();\r\n        countryDialCodeMap = new HashMap<>();\r\n        countryDialCodeMap.put(1, \"United States\");\r\n        countryDialCodeMap.put(44, \"United Kingdom\");\r\n        countryDialCodeMap.put(27, \"South Africa\");\r\n        countryDialCodeMap.put(33, \"France\");\r\n        countryDialCodeMap.put(55, \"Brazil\");\r\n    }\r\n\r\n    @After\r\n    public void tearDown() throws Exception {\r\n        mapToListConverter=null;\r\n        countryDialCodeMap = null;\r\n    }\r\n\r\n    @Test\r\n    public void convertMapKeysToList(){\r\n        List<Integer> convertedListOfKeys = mapToListConverter.convertMapKeysToList(countryDialCodeMap);\r\n        assertThat(convertedListOfKeys, not(IsEmptyCollection.empty()));\r\n        assertThat(convertedListOfKeys, hasSize(5));\r\n        assertThat(convertedListOfKeys, containsInAnyOrder(1,33,44,27,55));\r\n        printList(convertedListOfKeys);\r\n    }\r\n\r\n    private void printList(List list){\r\n        list.stream().forEach(System.out::println);\r\n    }\r\n}<\/pre>\n
The output on running the test in IntelliJ is this.
\n\"Test<\/a><\/p>\n
Converting Map Values to List<\/h2>\n
You use the values()<\/code> method of Map<\/code> to convert all the values of Map<\/code> entries into a List<\/code>.<\/p>\n
Here is the code to convert Map<\/code> values to a List<\/code>.<\/p>\n
public List<String> convertMapValuesToList(Map<Integer,String> map){\r\n    List<String> listOfValues = new ArrayList(map.values());\r\n    return listOfValues;\r\n}<\/pre>\n
Here is the Junit test code.<\/p>\n
@Test\r\npublic void convertMapValuesToList(){\r\n    List<String> convertedListOfValues = mapToListConverter.convertMapValuesToList(countryDialCodeMap);\r\n    assertThat(convertedListOfValues, not(IsEmptyCollection.empty()));\r\n    assertThat(convertedListOfValues, hasSize(5));\r\n    assertThat(convertedListOfValues, containsInAnyOrder(\"United States\", \"United Kingdom\", \"Brazil\", \"South Africa\", \"France\"));\r\n    printList(convertedListOfValues);\r\n}<\/pre>\n
The output on running the test in IntelliJ is this.
\n\"Test<\/a><\/p>\n
Converting Map to List using Java 8 Streams<\/h2>\n
If you are into functional programming style, you can use streams introduced in Java 8, along with some utility classes like Collectors<\/code>, which provides several useful methods to convert stream of Map<\/code> entries to List<\/code>.<\/p>\n
public List<Integer> convertMapKeysToListWithStream(Map<Integer,String> map){\r\n List<Integer> listOfKeys2 = map.keySet().stream().collect(Collectors.toList());\r\n    return listOfKeys2;\r\n}<\/pre>\n
The stream()<\/code> method return a stream of the keys from the Set<\/code> of the map keys that Map.keySet()<\/code> returns. The collect()<\/code> method of the Stream<\/code> class is called to collect the results in a List<\/code>.<\/p>\n
The Collectors.toList()<\/code> passed to the collect()<\/code> method is a generalized approach. You can collect elements of Stream<\/code> in specific collection, such as ArrayList<\/code>, LinkedList<\/code>, or any other List<\/code> implementation. To do so, call the toColection()<\/code> method, like this.<\/p>\n
List<Integer> listOfKeys2 = map.keySet().stream().collect(Collectors.toCollection(ArrayList::new));<\/pre>\n
Here is the JUnit test code.<\/p>\n
@Test\r\npublic void convertMapKeysToListWithStream(){\r\n    List<Integer> convertedListOfKeys = mapToListConverter.convertMapKeysToListWithStream(countryDialCodeMap);\r\n    assertThat(convertedListOfKeys, not(IsEmptyCollection.empty()));\r\n    assertThat(convertedListOfKeys, hasSize(5));\r\n    assertThat(convertedListOfKeys, hasItems(33,27));\r\n    assertThat(convertedListOfKeys, containsInAnyOrder(1,33,44,27,55));\r\n    printList(convertedListOfKeys);\r\n}<\/pre>\n
The JUnit test output in IntelliJ is this.
\n\"Test<\/a><\/p>\n
Converting Map<\/code> values to List<\/code> using streams is similar. You only need to get the stream of Map<\/code> values that map.values()<\/code> return, like this<\/p>\n
public List<String> convertMapValuesToListWithStream(Map<Integer,String> map){\r\n    List<String> listOfValues = map.values().stream().collect(Collectors.toCollection(ArrayList::new));\r\n    return listOfValues;\r\n}<\/pre>\n
The test code is this.<\/p>\n
@Test\r\npublic void convertMapValuesToListWithStream(){\r\n    List<String> convertedListOfValues = mapToListConverter.convertMapValuesToListWithStream(countryDialCodeMap);\r\n    assertThat(convertedListOfValues, not(IsEmptyCollection.empty()));\r\n    assertThat(convertedListOfValues, hasSize(5));\r\n    assertThat(convertedListOfValues, hasItems(\"United States\",\"France\"));\r\n    assertThat(convertedListOfValues, containsInAnyOrder(\"United States\", \"United Kingdom\", \"Brazil\", \"South Africa\", \"France\"));\r\n    printList(convertedListOfValues);\r\n}<\/pre>\n
The test output in IntelliJ is this.
\n\"Test<\/a><\/p>\n
Converting Generic Map to List using Stream and Java Lambdas<\/h2>\n
Till now I showed using method reference with stream to perform conversion of Map<\/code> to List<\/code>.
\nI personally prefer method reference over lambda expressions because I find them clear and concise.
\nAlso, when using collection, you will typically use generic collections and perform conversions between them.<\/p>\n
For such collections, you can use streams with lambda expressions, like this.<\/p>\n
public static<K, V> List<K> convertGenericMapKeysToListWithStreamLambda(Map<K,V> map){\r\n    List<K> keyList = new ArrayList<>();\r\n    map.entrySet().stream().forEach(entry->\r\n      {keyList.add(entry.getKey());\r\n       });\r\n    return keyList;\r\n}<\/pre>\n
The code to use method reference is this.<\/p>\n
public static<K, V> List<V> convertGenericMapValuesToListWithStreamMethodReference(Map<K,V> map){\r\n    List<V> keyList = new ArrayList<>();\r\n    map.values().stream().forEach(keyList::add);\r\n    return keyList;\r\n}<\/pre>\n
Here is the JUnit test code.<\/p>\n
@Test\r\npublic void convertGenericMapKeysToListWithStreamLambda(){\r\n    List<Integer> convertedListOfKeys = mapToListConverter.convertGenericMapKeysToListWithStreamLambda(countryDialCodeMap);\r\n    assertThat(convertedListOfKeys, not(IsEmptyCollection.empty()));\r\n    assertThat(convertedListOfKeys, hasSize(5));\r\n    assertThat(convertedListOfKeys, hasItems(33,27));\r\n    assertThat(convertedListOfKeys, containsInAnyOrder(1,33,44,27,55));\r\n    printList(convertedListOfKeys);\r\n}\r\n\r\n@Test\r\npublic void convertGenericMapKeysToListWithStreamMethodReference(){\r\n    List<String> convertedListOfValues = mapToListConverter.convertGenericMapValuesToListWithStreamMethodReference(countryDialCodeMap);\r\n    assertThat(convertedListOfValues, not(IsEmptyCollection.empty()));\r\n    assertThat(convertedListOfValues, hasSize(5));\r\n    assertThat(convertedListOfValues, hasItems(\"United States\",\"France\"));\r\n    assertThat(convertedListOfValues, containsInAnyOrder(\"United States\", \"United Kingdom\", \"Brazil\", \"South Africa\", \"France\"));\r\n    printList(convertedListOfValues);\r\n}<\/pre>\n
The JUnit test output in IntelliJ is this.
\n\"\"<\/a><\/p>\n","protected":false},"excerpt":{"rendered":"
Converting a Java Map to a List is a very common task. Map and List are common data structures used in Java. A Map is a collection of key value pairs. While a\u00a0List is an ordered collection of objects in which duplicate values can be stored. In this post, I will discuss different ways to […]Continue reading<\/a><\/p>\n","protected":false},"author":1,"featured_media":4592,"comment_status":"open","ping_status":"open","sticky":false,"template":"","format":"standard","meta":{"_lmt_disableupdate":"","_lmt_disable":"","_monsterinsights_skip_tracking":false,"_monsterinsights_sitenote_active":false,"_monsterinsights_sitenote_note":"","_monsterinsights_sitenote_category":0,"_uf_show_specific_survey":0,"_uf_disable_surveys":false,"_jetpack_memberships_contains_paid_content":false,"footnotes":"","jetpack_publicize_message":"","jetpack_publicize_feature_enabled":true,"jetpack_social_post_already_shared":true,"jetpack_social_options":{"image_generator_settings":{"template":"highway","enabled":false},"version":2}},"categories":[20],"tags":[27,199],"class_list":["post-4091","post","type-post","status-publish","format-standard","has-post-thumbnail","hentry","category-java","tag-java","tag-java-map-to-list"],"jetpack_publicize_connections":[],"aioseo_notices":[],"modified_by":"Simanta","jetpack_sharing_enabled":true,"jetpack_featured_media_url":"https:\/\/springframework.guru\/wp-content\/uploads\/2015\/03\/Banner560x292_07web.jpg","jetpack_shortlink":"https:\/\/wp.me\/p5BZrZ-13Z","_links":{"self":[{"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/posts\/4091"}],"collection":[{"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/posts"}],"about":[{"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/types\/post"}],"author":[{"embeddable":true,"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/users\/1"}],"replies":[{"embeddable":true,"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/comments?post=4091"}],"version-history":[{"count":10,"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/posts\/4091\/revisions"}],"predecessor-version":[{"id":5720,"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/posts\/4091\/revisions\/5720"}],"wp:featuredmedia":[{"embeddable":true,"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/media\/4592"}],"wp:attachment":[{"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/media?parent=4091"}],"wp:term":[{"taxonomy":"category","embeddable":true,"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/categories?post=4091"},{"taxonomy":"post_tag","embeddable":true,"href":"https:\/\/springframework.guru\/wp-json\/wp\/v2\/tags?post=4091"}],"curies":[{"name":"wp","href":"https:\/\/api.w.org\/{rel}","templated":true}]}}