映射条目的每个键的流，包含列表作为值

Question

I have a map of <String, List<T>> and want to create a stream for each entry's value, in which I will be able to find the maximum element of List<T> and after that map <String, List<T>> to <String, T> . How do I do that? Spent over 3 hours trying to figure out.

Update Forgot to tell that I was asked to do it two ways: with Collector.toMap and without it and I'm most curious about the way without it.

The step where I'm stuck is:

employees.stream()
            .flatMap(e -> e.getJobHistory().stream()
                    .map(j -> new PersonPositionDuration(e.getPerson(), j.getPosition(), j.getDuration())))
            .collect(Collectors.groupingBy(p -> p.getPosition()))
            .entrySet().

employees is a List of Employee object, each has jobHistory property, which is a List as well and each entry of it has employer property, which is String . So I turn this List<Employee> to a Map<String, List<PersonPositionDuration>> , where key is emploer and value is a class, containing info about a person and how long he was working as someone for this emploer. Keys aren't unique.

What I want to do is to find a PersonPositionDuration with a longest duration, we can get it by getDuration() . So what do I do after I get and entry set?

Also, I am adviced to use Collectors.maxBy and Collectors.collectingAndThen , but I have no idea how to do it.

Answer 1

Assuming T implements Comparable (because you need to be able to calculate the maximum of two values) you can wrap your code in a method such as this:

public <T extends Comparable<T>> Map<String, T> convert(Map<String, List<T>> data) {
    // variable for readability, you can return it right away if you prefer
    Map<String, T> result = data.entrySet().stream().collect(Collectors.toMap(
            // for each key in our map...
            e -> e.getKey(),
            // ... we determine the maximum and store it as new value
            e -> Collections.max(e.getValue())
    ));

    return result;
}

It creates a Set<Map.Entry<String, List<T>>> of which you can create a Stream which is converted into a Map<String, T> by converting the value type using Collections.max() which uses Comparable.compareTo to compare two objects and determine which one is greater than the other. Note that you can just use it as is for boxed types like Integer or Double (and many more) as they all implement Comparable .

Answer 2

If your map is of type <String, List<Integer>> it can be done as

Map<String, List<Integer>> map = new HashMap<>();
map.put("a", Arrays.asList(5, 3, 7));
map.put("b", Arrays.asList(1, 5));
map.put("c", Arrays.asList(45, 2));
map.put("d", Arrays.asList(4, 6, 2, 34));

map.entrySet().stream().collect(Collectors.toMap(Entry::getKey, entry -> {
    return entry.getValue().stream().max(Integer::compareTo).orElse(0);
}));

output :

{a=7, b=5, c=45, d=34}

You can modify the entry.getValue().stream().max(Integer::compareTo).orElse(0) with the comparator for Type T or your class Type.

Answer 3

It is not totally clear what you want to achieve or how your data structure looks like. What you wrote and the code you showed doesn't match together. They achieve very different things.

But you wished for a solution by using Collectors.maxBy and without Collectors.toMap . The other answers didn't provide such a solution. Therefore I will try to give one.

---

Your Data:

As your data structure I assume you have employers which each employ multiple employees. Every employee has some personal information, the position he works/ed in and the duration he worked in this position until know.

For example (Map employerEmployeeMap ):

CompanyA: [{Max, Developer, 5.4}, {Mari, Designer, 6.8}, {Paul, Manager, 1.2}]
CompanyB: [{Lea, CEO, 7.1}, {Tom, Admin, 4.5}, {Ria, Marketing, 0.4}]
CompanyC: [{Alex, Secretary, 1.5}, {Lisa, Developer, 3.3}, {Mia, Developer, 2.7}]

---

What you want to achieve:

You want to have the PersonPositionDuration with the longest duration. I wasn't sure if you want only the person with the longest duration over all employers or per each employer. Therefore I will provide multiple solutions.

---

Solution with maxBy

If you only want the person with the longest duration over all employers you can just iterate over the employees and get the one with the highest duration:

Optional<PersonPositionDuration> maxDurationPerson = employerEmployeeMap.values().stream()
                .flatMap(List::stream)
                .collect(maxBy(comparing(PersonPositionDuration::getDuration)));

This would be equal to:

Optional<PersonPositionDuration> maxDurationPerson = employerEmployeeMap.values().stream()
                .flatMap(List::stream)
                .max(comparing(PersonPositionDuration::getDuration));

Result: {Lea, CEO, 7.1}

If you want only the person with the highest duration but do not want to lose the employer information:

Optional<Pair<String, PersonPositionDuration>> maxDurationPersonCompany = employerEmployeeMap.entrySet().stream()
                .flatMap(entry -> entry.getValue().stream().map(p -> new Pair<>(entry.getKey(), p)))
                .max(comparing(entry -> entry.getValue().getDuration()));

Result: CompanyB: {Lea, CEO, 7.1}

If you want the person with the highest duration for every company you can do the following:

Map<String, Optional<Pair<String, PersonPositionDuration>>> maxDurationPerCompany = employerEmployeeMap.entrySet().stream()
                .flatMap(entry -> entry.getValue().stream().map(p -> new Pair<>(entry.getKey(), p)))
                .collect(groupingBy(Pair::getKey, maxBy(comparing(entry -> entry.getValue().getDuration()))));

Result:

CompanyA: {Mari, Designer, 6.8}
CompanyB: {Lea, CEO, 7.1}
Companyc: {Lisa, Developer, 3.3}

I hope this covers your question and your need. If not, if something is missing or of if something is unclear, please feel free to comment.

---

Full working example:

import javafx.util.*;

import java.util.*;

import static java.util.Comparator.comparing;
import static java.util.stream.Collectors.*;

public class Main {

    public static void main(String[] args) {
        class PersonPositionDuration {
            private final String person;
            private final String position;
            private final Double duration;

            public PersonPositionDuration(String person, String position, Double duration) {
                this.person = person;
                this.position = position;
                this.duration = duration;
            }

            public Double getDuration() {
                return duration;
            }
        }

        Map<String, List<PersonPositionDuration>> employerEmployeeMap = new HashMap<>();
        employerEmployeeMap.put("CompanyA", Arrays.asList(new PersonPositionDuration("Max", "Developer", 5.4), new PersonPositionDuration("Mari", "Designer", 6.8), new PersonPositionDuration("Paul", "Manager", 1.2)));
        employerEmployeeMap.put("CompanyB", Arrays.asList(new PersonPositionDuration("Lea", "CEO", 7.1), new PersonPositionDuration("Tom", "Admin", 4.5), new PersonPositionDuration("Ria", "Marketing", 0.4)));
        employerEmployeeMap.put("CompanyC", Arrays.asList(new PersonPositionDuration("Alex", "Secretary", 1.5), new PersonPositionDuration("Lisa", "Developer", 3.3), new PersonPositionDuration("Mia", "Developer", 2.7)));

        Optional<PersonPositionDuration> maxDurationPerson = employerEmployeeMap.values()
                .stream()
                .flatMap(List::stream)
                .max(comparing(PersonPositionDuration::getDuration));

        Optional<Pair<String, PersonPositionDuration>> maxDurationPersonCompany = employerEmployeeMap.entrySet()
                .stream()
                .flatMap(entry -> entry.getValue()
                        .stream()
                        .map(p -> new Pair<>(entry.getKey(), p)))
                .max(comparing(entry -> entry.getValue()
                        .getDuration()));

        Map<String, Optional<Pair<String, PersonPositionDuration>>> maxDurationPerCompany = employerEmployeeMap.entrySet()
                .stream()
                .flatMap(entry -> entry.getValue()
                        .stream()
                        .map(p -> new Pair<>(entry.getKey(), p)))
                .collect(groupingBy(Pair::getKey, maxBy(comparing(entry -> entry.getValue()
                        .getDuration()))));
    }
}