如何转换列表<Employee>到地图<Employee, List<String> &gt; 使用 java8？

Question

I have a list of Employee.

I have overridden equals and hashcode of Employee class. I want to convert employee list to map with employee object as key and list of unique car numbers as values.

PS: there may be duplicate keys as well in the list. Hence I should merge the values of car numbers present in the list and put into the map.

Please find the code below which I tried using iteration. I wanted to know how this can be done using java 8.

import java.util.ArrayList;
import java.util.Arrays;
import java.util.LinkedHashMap;
import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class TestMap {

    public static void main(String[] args) {

        Map<Employee, List<String>> map = new LinkedHashMap<>();
        Employee e1 = new Employee("A", new ArrayList(Arrays.asList("car1", "car2", "car3")));
        Employee e2 = new Employee("B", new ArrayList(Arrays.asList("car111", "car222", "car333")));
        Employee e3 = new Employee("C", new ArrayList(Arrays.asList("car1111", "car2222", "car3333")));
        Employee e4 = new Employee("A", new ArrayList(Arrays.asList("car2", "car3", "car4")));

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

        employeeList.add(e1);
        employeeList.add(e2);
        employeeList.add(e3);
        employeeList.add(e4);


        for (Employee employee : employeeList) {

            if(map.containsKey(employee)) {
                List<String> temp = map.get(employee);
                temp.addAll(employee.getCars());
                temp = temp.stream().distinct().collect(Collectors.toList());
                map.put(employee, temp);
            }
            else {
                List<String> values = new ArrayList<>();
                values.addAll(employee.getCars().stream().distinct().collect(Collectors.toList()));
                map.put(employee, values);
            }

        }

        System.out.println("map::: "+ map);

    }

}


class Employee {
    private List<String> cars;


    public Employee(String empName, List<String> cars) {
        this.empName = empName;
        this.cars = cars;
    }

    public List<String> getCars() {
        return cars;
    }

    public void setCars(List<String> cars) {
        this.cars = cars;
    }

    private String empName;

    @Override
    public int hashCode() {
        final int prime = 31;
        int result = 1;
        result = prime * result + ((empName == null) ? 0 : empName.hashCode());
        return result;
    }

    @Override
    public boolean equals(Object obj) {
        if (this == obj)
            return true;
        if (obj == null)
            return false;
        if (getClass() != obj.getClass())
            return false;
        Employee other = (Employee) obj;
        if (empName == null) {
            if (other.empName != null)
                return false;
        } else if (!empName.equals(other.empName))
            return false;
        return true;
    }

    public String getEmpName() {
        return empName;
    }

    public void setEmpName(String empName) {
        this.empName = empName;
    }

}

Answer 1

I like to get a piece of imperative code and translate it into functional ... still java streams produce ugly code like the following...

        Employee e1 = new Employee("A", Arrays.asList("car1", "car2", "car3"));
        Employee e2 = new Employee("B", Arrays.asList("car111", "car222", "car333"));
        Employee e3 = new Employee("C", Arrays.asList("car1111", "car2222", "car3333"));
        Employee e4 = new Employee("A", Arrays.asList("car2", "car3", "car4"));
        List<Employee> myList = Arrays.asList(e1, e2, e3, e4);

        BinaryOperator<Employee> accumulator = (x, y) -> {
            List<String> cars = Stream.concat(x.getCars().stream(), y.getCars().stream()).distinct()
                    .collect(Collectors.toList());
            x.setCars(cars);
            return x;
        };

        Map<Employee, List<String>> collect = 
                myList
                .stream()
                .collect(Collectors.groupingBy(x -> x))
                .entrySet()
                .stream()
                .collect(
                        Collectors.toMap(
                            e -> e.getKey(),
                            e -> e.getValue()
                                    .stream()
                                    .reduce(accumulator)
                                    .map(Employee::getCars)
                                    .get())
                );
        System.out.println(collect);

It will print :

  {Employee [empName=A]=[car1, car2, car3, car4], Employee [empName=B]=[car111, car222, car333], Employee [empName=C]=[car1111, car2222, car3333]}

I would not do it, too ugly , too contrieved...

Especially if you compare it with native functional language like scala...

    val emps: List[Employee] = List(
      Employee("A", List("car1", "car2", "car3")),
      Employee("B", List("car111", "car222", "car333")),
      Employee("C", List("car1111", "car2222", "car3333")),
      Employee("A", List("car2", "car3", "car4")))

      val x = emps.groupBy(_.name)
        .map{case (k,cs) => (k,cs.flatMap(_.cars).distinct) }

      println(x)
  }
  case class Employee(name: String, cars: List[String])
  // Map(A -> List(car1, car2, car3, car2, car3, car4), C -> List(car1111, car2222, car3333), B -> List(car111, car222, car333))

In java I would consider using vavr to do so wich would result in this code:

        io.vavr.collection.List<Employee> emps = io.vavr.collection.List.of( 
                new Employee("A", Arrays.asList("car1", "car2", "car3")),         
                new Employee("B", Arrays.asList("car111", "car222", "car333")),   
                new Employee("C", Arrays.asList("car1111", "car2222", "car3333")),
                new Employee("A",Arrays.asList("car2","car3","car4")));

        io.vavr.collection.Map<String, io.vavr.collection.List<String>> 
            mapValues = emps.groupBy(emp->emp.getEmpName())
                    .mapValues( v ->v.flatMap(Employee::getCars).distinct());
        System.out.println(mapValues);

In both Vavr code and scala I used the Employee name instead of the object as a key, beacuse it seems just proper, there is no way to choose one employee instance instead of another, so I used the key .

Answer 2

Could be solved simply by using Set instead of List :

Map<Employee, Set<String>> collect = employeeList.stream()
            .collect(Collectors.groupingBy(Function.identity(),
                    Collectors.flatMapping(employee -> employee.getCars().stream(), Collectors.toSet())));

Output:

{Employee{name='A'}=[car2, car3, car1, car4], Employee{name='B'}=[car333, car222, car111], Employee{name='C'}=[car1111, car2222, car3333]}