Using groupingBy to create a Map with immutable list as the key

Question

Say, I've a class called Project,

class Project {
    private String projectId;
    private String projectName;
}

and a class called Employee, which has a list of projects

class Employee {
    private String name;
    private List<Project> projects
}

I also have a list of Employee objects. Now, I need to create a Map with the list of projects as the key and a set of employee objects as the value from this list. I can get it working by

Map<List<Project>, Set<Employee>> x =
        employees
        .stream
        .collect(Collectors.groupingBy(Employee::getProjects, Collectors.toSet()));

However, since I'm using List as the key, I want to be extra careful and make sure that the list is immutable. Is there a way to achieve this?

Thanks.

Answer 1

List immutability is supported in Java 9. You can simply change Employee#getProjects to the following:

public List<Project> getProjects() {
    return List.of(projects.toArray(new Project[projects.size()]));
}

If you don't want this method to return an immutable List, then you can change the Collector:

employees.stream()
         .collect(Collectors.groupingBy(e -> List.of(e.getProjects().toArray(new Project[0])), Collectors.toSet()));

Answer 2

This is how you would do it with Guava (I tried it with version 24.1, which is the latest one as of today)

List<Employee> employees = new ArrayList<>();

//  ... let's assume someone fills in the employees

// Everything mutable
Map<List<Project>, Set<Employee>> x =
    employees
        .stream()
        .collect(Collectors.groupingBy(Employee::getProjects, Collectors.toSet()));

// Everything immutable
ImmutableMap<ImmutableList<Project>, ImmutableSet<Employee>> immutableX =
    employees
        .stream()
        .collect(
            Collectors.collectingAndThen(
                Collectors.groupingBy(
                    (employee) -> ImmutableList.copyOf(employee.getProjects()),
                    ImmutableSet.<Employee>toImmutableSet()),
                ImmutableMap::copyOf));

// Only the List<Project> immutable
Map<ImmutableList<Project>, Set<Employee>> immutableListX =
    employees
        .stream()
        .collect(
            Collectors.groupingBy(
                (employee) -> ImmutableList.copyOf(employee.getProjects()),
                Collectors.toSet()));

This assumes your classes definitions are these (I needed to add the method getProjects for the original example to compile):

class Project {
  public String projectId;
  public String projectName;
}

class Employee {
  public String name;
  public List<Project> projects;

  public List<Project> getProjects() {
    return projects;
  }
}

Answer 3

If I am not missing something obvious here, can't you simply wrap that into Collections.unmodifiableList:

 collect(Collectors.groupingBy(
          emps -> Collections.unmodifiableList(emps.getProjects()), 
          Collectors.toSet());

If you have guava on the class path on the other hand, you could use ImmutableList

Answer 4

You can use

private List<? extends Project> projects = new LinkedList<>();

when populating employees. It sets up a logically immutable list.

Answer 5

If you don't mind your map to be initially stored in a mutable Map and then copied to an immutable collection, you could do something like the following:

ImmutableMap<List<Project>, List<Employee>> collect = employees.stream()
            .collect(Collectors.collectingAndThen(Collectors.groupingBy(Employee::getProjects),
                    ImmutableMap::copyOf));

The ImmutableMap is a Google Common's structure (com.google.common.collect.ImmutableMap). Credits to this as well.