How to Sort Map Value List by Element Field Using Java Streams

1. Overview

In this tutorial, we’ll explore the benefits of Streams API in sorting elements in a List stored within a Map. In the process, we’ll also compare it with the more traditional approach of using the List#sort(Comparator) method and see which is more effective.

2. Problem Statement

Before we look at the solution, let’s discuss the problem first.

Let’s assume there’s an Employee class:

public class Employee {
    private String name;
    private int salary;
    private String department;
    private String sex;
    public Employee(String name, int salary, String department, String sex) {
        this.name = name;
        this.salary = salary;
        this.department = department;
        this.sex = sex;
    }
    
    //getter and setters ..
}

The Employee class has fields name, salary, department, and sex. Additionally, we’ve got a constructor helping us to create the Employee object.

We’ll create a list of Employee objects by reading the records from a CSV file emp_not_sorted.csv consisting of the employees’ data:

Sales,John Doe,48000,M
HR,Jane Smith,60000,F
IT,Robert Brown,75000,M
Marketing,Alice Johnson,55000,F
Sales,Chris Green,48000,M
HR,Emily White,62000,F
IT,Michael Black,72000,M
Marketing,Linda Blue,60000,F
More records...

The CSV file has columns for department, name, salary, and sex.

We’ll read this CSV file and store the records in a Map:

static void populateMap(String filePath) throws IOException {
    String[] lines = readLinesFromFile(filePath);
    Arrays.asList(lines)
      .forEach(e -> {
        String[] strArr = e.split(",");
            Employee emp = new Employee(strArr[1], Integer.valueOf(strArr[2]), strArr[0], strArr[3]);
            MAP_OF_DEPT_TO_MAP_OF_SEX_TO_EMPLOYEES.computeIfAbsent(emp.getDepartment(),
              k -> new HashMap<>())
                .computeIfAbsent(emp.getSex(), k -> new ArrayList<>())
                .add(emp);
        });
}

In the method, the MAP_OF_DEPT_TO_MAP_OF_SEX_TO_EMPLOYEES field is of type Map<String, Map<String, List>>. The outer key of the map is the department field while the inner key in the map consists of the sex field.

In the next section, we’ll access the Employee List in the inner Map and try sorting it by salary and then by the employees’ name.

Here’s the result we expect after sorting:

Sales,Chris Green,48000,M
Sales,John Doe,48000,M
Sales,Matthew Cyan,48000,M
Sales,David Grey,50000,M
Sales,James Purple,50000,M
Sales,Aiden White,55000,M
More records..
HR,Isabella Magenta,60000,F
HR,Jane Smith,60000,F
HR,Emily White,62000,F
HR,Sophia Red,62000,F
More records..

First, the records are sorted by salary and then by the name of the employees. We follow the same pattern for the other departments.

3. Solution Without Stream API

Traditionally, we’d go for the List#sort(Comparator) method:

void givenHashMapContainingEmployeeList_whenSortWithoutStreamAPI_thenSort() throws IOException {
    final List<Employee> lstOfEmployees = new ArrayList<>();
    MAP_OF_DEPT_TO_MAP_OF_SEX_TO_EMPLOYEES.forEach((dept, deptToSexToEmps) ->
        deptToSexToEmps.forEach((sex, emps) ->
        {
            emps.sort(Comparator.comparingInt(Employee::getSalary).thenComparing(Employee::getName));
            emps.forEach(this::processFurther);
            lstOfEmployees.addAll(emps);
        })
    );
    String[] expectedArray = readLinesFromFile(getFilePath("emp_sorted.csv"));
    String[] actualArray = getCSVDelimitedLines(lstOfEmployees);
    assertArrayEquals(expectedArray, actualArray);
}

We’ve used the forEach() method for iterating through the Map instead of the for or while loop over the Set of keys or the Entrys of the Map class. This method is part of the enhancements such as the Generics, Functional Programming, and Stream API that were brought in Java 8.

The List#sort(Comparator) method takes the Comparator Functional Interface introduced in Java 8. The Comparator#comparingInt() sorts by the field salary and returns a Comparator object which calls the thenComparing() method to sort on the name field. The chain of methods provides a flexible custom sorting logic with a function or a lambda expression. This style of code is more declarative and thus easier to understand.

The sort() method sorts the original Employee List object in the emps variable, violating the principle of immutability. This mutation can complicate troubleshooting and debugging while fixing programming defects. Moreover, it doesn’t return a List or a Stream object for further processing. Hence, we need to loop through the List object again for further processing. It breaks the flow making it less intuitive to understand.

4. Solution With Stream API

Considering the disadvantages discussed in the previous section, let’s address them with the help of Stream API:

void givenHashMapContainingEmployeeList_whenSortWithStreamAPI_thenSort() throws IOException {
    final List<Employee> lstOfEmployees = new ArrayList<>();
    MAP_OF_DEPT_TO_MAP_OF_SEX_TO_EMPLOYEES.forEach((dept, deptToSexToEmps) ->
      deptToSexToEmps.forEach((sex, emps) ->
        {
             List<Employee> employees = emps.stream()
               .sorted(Comparator.comparingInt(Employee::getSalary).thenComparing(Employee::getName))
               .map(this::processFurther)
               .collect(Collectors.toList());
             lstOfEmployees.addAll(employees);
        })
    );
    String[] expectedArray = readLinesFromFile(getFilePath("emp_sorted.csv"));
    String[] actualArray = getCSVDelimitedLines(lstOfEmployees);
    assertArrayEquals(expectedArray, actualArray);
}

Unlike the previous approach, the Stream#sorted(Comparator) method returns a Stream object. It works similarly to the List#sort(Comparator) method, but here we can further process each element of the Employee List with the help of the Stream#map() method. For example, the processFurther() function-argument in the map() method takes each employee element as a parameter to process it further.

We can perform multiple intermediate operations in a pipeline, concluding with a terminal operation like collect() or reduce(). Finally, we collect the sorted Employee list and later use it to verify if it was sorted by comparing it with the sorted employee data in the emp_sorted.csv file.

5. Conclusion

In this article, we discussed the Stream#sorted(Comparator) method and compared it to List#sort(Comparator).

We can conclude that Stream#sorted(Comparator) provides better continuity and readability to the code than List#sort(Comparator). While the Stream API has many powerful features, it’s essential to consider the principles of functional programming in Stream API such as immutability, statelessness, and pure functions. Without following them, we can end up with erroneous results.

As usual, the code used in this article is available over on GitHub.