How To Convert Map To List In Java

Converting a Map to a List is a common requirement in Java programming. A Map represents a collection of key-value pairs, while a List represents an ordered collection of elements. Converting a Map to a List allows you to work with the values, keys, or key-value pairs in a more structured and ordered way.

There are several ways to convert a Map to a List in Java, depending on the specific requirements of the use cases such as Map.values(), Map.entrySet(), Map.keyset(), foreach loop and ArrayList constructor.

Why is there a need to convert Map to List in java?

Converting a Map to a List in Java can be useful in a variety of situations. Here are some reasons why there is a need to convert a Map to a List in Java:

Ordered access to map elements: A Map in Java does not guarantee any particular order of its elements, whereas a List maintains the order of its elements. Converting a Map to a List can be useful when you need to access its elements in a specific order.
Simplifying data manipulation: Converting a Map to a List can simplify data manipulation by providing a more structured and organized way to work with its elements. This can make it easier to perform certain operations, such as filtering or sorting.
Compatibility with APIs: Some APIs or libraries may require data in the form of a List. Converting a Map to a List can make it easier to integrate with such APIs or libraries.
Reducing memory footprint: In some cases, converting a Map to a List can help reduce the memory footprint of the application. This is because a List requires less memory than a Map, especially if the Map has many elements.

Methods for converting Map to List in Java:

Following are the several ways to convert map to list in java:

Using Map.values() method
Using Map.entrySet() method
Using Map.keySet() method
Using foreach loop
Using ArrayList constructor and Map.entrySet() method

A thorough explanation of each strategy:

1. Convert Map values to List using Map.values() method:

This approach involves using the Map.values() method to retrieve the values of the Map and storing them in a List. This method is useful when you only need the values of a Map.

Program:

import java.util.*;

public class MapToList {
    public static void main(String[] args) {
        // Create a HashMap object with Integer keys and String values
        Map<Integer, String> map = new HashMap<>();
        
        // Add some key-value pairs to the map
        map.put(1, "one");
        map.put(2, "two");
        map.put(3, "three");

        // Create a new ArrayList object with the map's values
        List<String> list = new ArrayList<>(map.values());

        // Print the list of values to the console
        System.out.println("List of Map values: " + list);
    }
}

Output:

List of Map values: [one, two, three]

Explanation:

Create a HashMap and add key-value pairs to it using the put() method.
Call the values() method on the HashMap to get a Collection of its values.
Create a new ArrayList and pass the Collection of values to its constructor. This will create a new ArrayList containing all the values of the HashMap.
Print the ArrayList.

2. Convert Map entries to List using Map.entrySet() method:

This approach involves using the Map.entrySet() method to retrieve the entries of the Map, which are key-value pairs, and storing them in a List. This method is useful when you need both the keys and values of a Map.

Program:

import java.util.*;

public class MapToList {
    public static void main(String[] args) {
        // Create a HashMap object with Integer keys and String values
        Map<Integer, String> map = new HashMap<>();
        
        // Add some key-value pairs to the map
        map.put(1, "one");
        map.put(2, "two");
        map.put(3, "three");

        // Create a new ArrayList object with the map's entries
        List<Map.Entry<Integer, String>> list = new ArrayList<>(map.entrySet());

        // Print the list of entries to the console
        System.out.println("List of Map entries: " + list);
    }
}

Output:

List of Map entries: [{1=one}, {2=two}, {3=three}]

Explanation:

Create a HashMap and add key-value pairs to it using the put() method.
Call the entrySet() method on the HashMap to get a Set of its key-value pairs.
Create a new ArrayList and pass the Set of key-value pairs to its constructor. This will create a new ArrayList containing all the key-value pairs of the HashMap as Map.Entry objects.
Print the ArrayList.

3. Convert Map keys to List using Map.keySet() method:

This approach involves using the Map.keySet() method to retrieve the keys of the Map and storing them in a List. This method is useful when you only need the keys of a Map.

Program:

import java.util.*;
public class MapToList {
    public static void main(String[] args) {
        // Create a HashMap object with Integer keys and String values
        Map<Integer, String> map = new HashMap<>();
        
        // Add some key-value pairs to the map
        map.put(1, "one");
        map.put(2, "two");
        map.put(3, "three");

        // Create a new ArrayList object with the map's keys
        List<Integer> list = new ArrayList<>(map.keySet());

        // Print the list of keys to the console
        System.out.println("List of Map keys: " + list);
    }   }

Output:

List of Map keys: [1, 2, 3]

Explanation:

Create a HashMap and add key-value pairs to it using the put() method.
Call the keySet() method on the HashMap to get a Set of its keys.
Create a new ArrayList and pass the Set of keys to its constructor. This will create a new ArrayList containing all the keys of the HashMap.
Print the ArrayList.

4. Convert Map to List using a foreach loop:

This approach involves using a foreach loop to iterate over the entries of the Map, and adding each entry to a List. This method is similar to using a regular loop, but may be more concise and easier to read.

Program:

import java.util.*;

public class MapToList {
    public static void main(String[] args) {
        // Create a new HashMap and add key-value pairs to it
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "one");
        map.put(2, "two");
        map.put(3, "three");

        // Create a new ArrayList that contains all the values from the map
        List<String> list = new ArrayList<>();
        for (String value : map.values()) {
            list.add(value); // Add each value to the list using a foreach loop
        }

        // Print out the resulting list of map values
        System.out.println("List of Map values using foreach loop: " + list);
    }
}

Output:

List of Map values using foreach loop: [one, two, three]

Explanation:

Create a HashMap and add key-value pairs to it using the put() method.
Create a new ArrayList.
Use a foreach loop to iterate over the values of the HashMap, adding each value to the ArrayList.
Print the ArrayList.

5. Convert Map to List using ArrayList constructor and Map.entrySet() method:

This approach involves using the ArrayList constructor that takes a Collection as its argument and passing in the result of calling the Map.entrySet() method. This method is a simple and efficient way to convert a Map to a List.

Program:

import java.util.*;

public class MapToList {
    public static void main(String[] args) {
        // Create a HashMap to store integer keys and string values
        Map<Integer, String> map = new HashMap<>();
        map.put(1, "one");
        map.put(2, "two");
        map.put(3, "three");

        // Convert the values of the map to a list using ArrayList constructor
        // The list type is Map.Entry<Integer, String>, which represents a key-value pair
        // This method creates a new ArrayList and populates it with the entries from the map
        List<Map.Entry<Integer, String>> list = new ArrayList<>(map.entrySet());

        // Print the resulting list of map entries
        System.out.println("List of Map entries using ArrayList constructor: " + list);
    }
}

Output:

List of Map entries using ArrayList constructor: [{1=one}, {2=two}, {3=three}]

Explanation:

Create a HashMap and add key-value pairs to it using the put() method.
Create a new ArrayList.
Pass the entrySet() method of the HashMap to the constructor of the ArrayList. This will create a new ArrayList containing all the key-value pairs of the HashMap as Map.Entry objects.
Print the ArrayList.

Best approach for converting Map to List in Java:

The Map.entrySet() method is the best approach to convert a Map to a List in Java because it provides the most flexibility by allowing you to get the entire key-value pairs as Map.Entry objects. Here are some reasons why Map.entrySet() method is a good choice:

Provides access to both keys and values: Map.entrySet() method returns a set of key-value pairs as Map.Entry objects. This means that you have access to both the key and value of each entry in the map.
Easy to iterate: The Map.entrySet() method returns a set that can be easily iterated using a for-each loop or other types of loops. This makes it easy to perform operations on each key-value pair in the map.
Efficient performance: The Map.entrySet() method provides efficient performance when converting a Map to a List, especially for larger maps. This is because it only needs to iterate through the map once to get all the key-value pairs.
Consistent ordering: The order of the key-value pairs in the resulting list is guaranteed to be the same as the order in which they appear in the original map. This is because the Map.entrySet() method returns a set that maintains the order of the elements based on their insertion order.
Memory efficiency: Using Map.entrySet() method is memory-efficient, as it does not create any new objects while iterating over the Map object. Instead, it returns a view of the Map object’s entries.

Sample Problems:

Problem 1:

Given a Map containing the names of students and their corresponding grades, write a Java program to convert the grades to a List using the Map.values() method.

Program:

import java.util.*;

public class MapToValuesToListExample {

    public static void main(String[] args) {
        
        // Create a Map with student names as keys and their grades as values
        Map<String, Integer> studentGrades = new HashMap<>();
        studentGrades.put("Alice", 85);
        studentGrades.put("Bob", 90);
        studentGrades.put("Charlie", 75);
        studentGrades.put("David", 80);
        studentGrades.put("Eve", 95);
        
        // Convert the values of the Map to a List using Map.values() method
        List<Integer> gradesList = new ArrayList<>(studentGrades.values());
        
        // Print the original Map and the converted List
        System.out.println("Original Map: " + studentGrades);
        System.out.println("Converted List: " + gradesList);
    }
}

Output:

Original Map: {Charlie=75, Bob=90, David=80, Alice=85, Eve=95}
Converted List: [75, 90, 80, 85, 95]

Explanation:

First, we create a Map named studentGrades with the names of students as keys and their grades as values.
To convert the values of the Map to a List, we use the Map.values() method which returns a Collection of all the values in the Map.
We then pass this Collection as an argument to the ArrayList constructor to create a new List object with the same elements as the Collection.
Finally, we print both the original Map and the converted List to verify the output.

Problem 2:

Write a Java program to convert the contents of a Map containing the names of countries and their corresponding populations to a List of String arrays using the Map.entrySet() method.

Program:

import java.util.*;

public class CountryPopulationsToList {

    public static void main(String[] args) {
        // create a map of country names and their populations
        Map<String, Integer> countryPopulations = new HashMap<>();
        countryPopulations.put("India", 1366000000);
        countryPopulations.put("China", 1398000000);
        countryPopulations.put("United States", 329500000);
        countryPopulations.put("Indonesia", 270200000);
        countryPopulations.put("Pakistan", 216600000);

        // convert the map to a list of string arrays using Map.entrySet() method
        List<String[]> countryPopulationsList = new ArrayList<>();
        for (Map.Entry<String, Integer> entry : countryPopulations.entrySet()) {
            String[] countryPopulation = new String[2];
            countryPopulation[0] = entry.getKey();
            countryPopulation[1] = String.valueOf(entry.getValue());
            countryPopulationsList.add(countryPopulation);
        }

        // print the list of string arrays
        for (String[] countryPopulation : countryPopulationsList) {
            System.out.println(Arrays.toString(countryPopulation));
        }
    }
}

Output:

[India, 1366000000]
[China, 1398000000]
[United States, 329500000]
[Indonesia, 270200000]
[Pakistan, 216600000]

Explanation:

We first create a map countryPopulations with country names as keys and their populations as values.
Next, we create an empty ArrayList countryPopulationsList which will contain the list of string arrays.
We loop through each Map.Entry in the countryPopulations map using the entrySet() method.
For each entry, we create a new string array countryPopulation of size 2.
We set the first element of the countryPopulation array as the key of the current map entry using entry.getKey().
We set the second element of the countryPopulation array as the value of the current map entry converted to a string using String.valueOf(entry.getValue()).
We add the countryPopulation array to the countryPopulationsList.
Finally, we print the contents of the countryPopulationsList using a for-each loop and Arrays.toString() method.

Problem 3:

Given a Map containing the names of cities and their corresponding populations, write a Java program to convert the city names to a List using the Map.keySet() method.

Program:

import java.util.*;

public class CityNamesToList {

    public static void main(String[] args) {
        
        // Creating a Map containing city names and their corresponding populations
        Map<String, Integer> cityPopulations = new HashMap<>();
        cityPopulations.put("New York", 8537673);
        cityPopulations.put("Los Angeles", 3977683);
        cityPopulations.put("Chicago", 2693976);
        cityPopulations.put("Houston", 2320268);
        cityPopulations.put("Phoenix", 1680992);
        
        // Creating a List to store the city names
        List<String> cityNames = new ArrayList<>(cityPopulations.keySet());
        
        // Printing the city names list
        System.out.println("City names list:");
        for (String city : cityNames) {
            System.out.println(city);
        }
    }
}

Output:

City names list:
New York
Los Angeles
Chicago
Houston
Phoenix

Explanation:

We first create a Map<String, Integer> called cityPopulations containing the names of cities as keys and their corresponding populations as values.
We then create an empty ArrayList<String> called cityNames.
We use the keySet() method of the Map class to retrieve a Set containing all the keys (i.e. city names) in the cityPopulations map, and pass this Set to the ArrayList constructor to create a new ArrayList containing all the city names.
Finally, we iterate through the cityNames list using a for loop and print each city name to the console.

Problem 4:

Write a Java program to convert the values of a Map containing the names of students and their corresponding grades to a List using a foreach loop.

Program:

import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

public class MapToListUsingForEachLoop {

    public static void main(String[] args) {
        // Create a Map containing the names of students and their corresponding grades
        Map<String, Integer> studentGrades = new HashMap<>();
        studentGrades.put("John", 85);
        studentGrades.put("Emily", 92);
        studentGrades.put("Jessica", 78);
        studentGrades.put("Tom", 90);

        // Create an empty List to store the grades
        List<Integer> gradesList = new ArrayList<>();

        // Iterate over the values of the Map using a foreach loop
        for (Integer grade : studentGrades.values()) {
            // Add each grade to the List
            gradesList.add(grade);
        }

        // Print the List of grades
        System.out.println("List of grades: " + gradesList);
    }
}

Output:

List of grades: [85, 92, 78, 90]

Explanation:

We first create a Map called studentGrades containing the names of students and their corresponding grades.
We then create an empty List called gradesList to store the grades.
We iterate over the values of the studentGrades Map using a foreach loop.
For each grade in the studentGrades Map, we add it to the gradesList.
Finally, we print the contents of the gradesList to the console.

Problem 5:

Given a Map containing the names of fruits and their corresponding prices, write a Java program to convert the contents of the Map to a List of Fruit objects using the ArrayList constructor and Map.entrySet() method.

Program:

import java.util.*;

public class Fruit {
    private String name;
    private double price;

    public Fruit(String name, double price) {
        this.name = name;
        this.price = price;
    }

    public String getName() {
        return name;
    }

    public double getPrice() {
        return price;
    }
}

public class Main {
    public static void main(String[] args) {
        // Create a map of fruits and their prices
        Map<String, Double> fruitPrices = new HashMap<>();
        fruitPrices.put("apple", 1.2);
        fruitPrices.put("banana", 0.8);
        fruitPrices.put("orange", 1.5);
        fruitPrices.put("grape", 2.0);

        // Create a list of Fruit objects using ArrayList constructor and Map.entrySet() method
        List<Fruit> fruitList = new ArrayList<>();
        for (Map.Entry<String, Double> entry : fruitPrices.entrySet()) {
            String fruitName = entry.getKey();
            double fruitPrice = entry.getValue();
            Fruit fruit = new Fruit(fruitName, fruitPrice);
            fruitList.add(fruit);
        }

        // Print the contents of the fruitList
        System.out.println("Fruits and their prices:");
        for (Fruit fruit : fruitList) {
            System.out.println(fruit.getName() + " : " + fruit.getPrice());
        }
    }
}

Output:

Fruits and their prices:
apple : 1.2
banana : 0.8
orange : 1.5
grape : 2.0

Explanation:

We define a Fruit class with a constructor, and two getter methods for the name and price attributes.
In the main() method, we create a Map<String, Double> object fruitPrices and populate it with some fruits and their prices.
We create an empty List<Fruit> object fruitList using the ArrayList constructor.
We use a for loop with the entrySet() method of the Map interface to iterate through the key-value pairs of fruitPrices.
For each iteration, we extract the key (fruit name) and value (fruit price), and use them to create a new Fruit object.
We add this new Fruit object to the fruitList using the add() method of ArrayList.
Finally, we iterate through the fruitList using a for loop, and print the name and price of each fruit.

Conclusion:

Converting a Map to a List is a common task in Java programming, and there are multiple approaches available for achieving this. We can convert Map values, keys, or entries to a List using methods such as Map.values(), Map.keySet(), Map.entrySet(), foreach loop, and ArrayList constructor with Map.entrySet().

The best approach to use depends on the specific use case and performance considerations. In general, the Map.entrySet() method is the most efficient and flexible approach because it allows us to access both the keys and values of the Map and provides good performance for large Maps.

Java developers must understand the different ways to convert a Map to a List so that they can choose the most appropriate approach for their specific needs and optimize the performance of their code. Properly converting a Map to a List can make it easier to manipulate and process the data in the Map and can simplify certain programming tasks.

24×7 Live Java Homework Help From Expert Tutors! Get Help Now

Author:

Shushank Gautam

I am an aspiring Java developer, with handful of web development experience. Heading forward to acquire more tech skills. Follow: