Java Stream sortingBy 和 filter()

Question

I have a specific question about Java 8 streams. I could not find anything that was close to the solution of my problem even it sounds not too complicated.

I want to convert a List<Person> into a Map<Company, List<Person>> . The Company is an enum. Now the Map should be grouped by the Company (so far I got everything working. After I want to filter all the List<Person> of the Map by an attribute : the Name of the Person . I only want to have the Person(s) with the longest name inside. Example:

This is what I got so far:

import java.util.LinkedList;
import java.util.List;
import java.util.Map;
import java.util.Map.Entry;
import java.util.stream.Collectors;

public class PersonMap {

    public static void main(String[] args) {
        Person person1 = new Person("Pete", Company.APPLE);
        Person person2 = new Person("Joe", Company.APPLE);
        Person person3 = new Person("Jack", Company.APPLE);
        Person person4 = new Person("Robert", Company.MICROSOFT);
        Person person5 = new Person("Cate", Company.MICROSOFT);
        Person person6 = new Person("Abi", Company.MICROSOFT);

        List<Person> list = new LinkedList<>();
        list.add(person1);
        list.add(person2);
        list.add(person3);
        list.add(person4);
        list.add(person5);
        list.add(person6);
    }

    public Map<Company, List<Person>> groupPersonByCompanyAndFilterByName (List <Person> list){
        Map<Company, List<Person>> outputMap =
                list.stream().collect(Collectors.groupingBy(Person::getCompany))
                .entrySet().stream()
                .filter(p -> p.getValue().stream().toString().length() !=
                p.getValue().stream().map(Person::getName).mapToInt(String::length).max().getAsInt())
                .collect(Collectors.toMap(Entry::getKey, Entry::getValue));

        return outputMap;
    }
}

The filter function is not working here. The output I want is:

{MICROSOFT=["person4"], APPLE=[person1, person3]}

Does anybody have good knowledge and can help me please!

Answer 1

Here is an approach using teeing

public Map<Company, List<Person>> groupPersonByCompanyAndFilterByName (List <Person> list){
    return list.stream().collect(groupingBy(Person::getCompany,
           teeing(
                  mapping(Person::getName, maxBy(Comparator.comparing(String::length))),
                  toList(),
                  (a, b) -> b.stream().filter(x -> x.getName().length() == a.get().length())
                                      .collect(toList())

           )
    ));

}

Answer 2

For better performance, you shouldn't do it in a single stream chain.

Try this instead:

List<Person> list = new LinkedList<>();
list.add(new Person("Pete", Company.APPLE));
list.add(new Person("Joe", Company.APPLE));
list.add(new Person("Jack", Company.APPLE));
list.add(new Person("Robert", Company.MICROSOFT));
list.add(new Person("Cate", Company.MICROSOFT));
list.add(new Person("Abi", Company.MICROSOFT));

Map<Company, List<Person>> map = list.stream().collect(Collectors.groupingBy(Person::getCompany));
map.values().forEach(persons -> {
    int maxLen = persons.stream().mapToInt(p -> p.getName().length()).max().getAsInt();
    persons.removeIf(p -> p.getName().length() != maxLen);
});

System.out.println(map);

Output

{APPLE=[Pete, Jack], MICROSOFT=[Robert]}

For the above code, I used the following extra classes:

enum Company {
    APPLE, MICROSOFT
}

class Person {
    private final String name;
    private final Company company;
    public Person(String name, Company company) {
        this.name = name;
        this.company = company;
    }
    public String getName() {
        return this.name;
    }
    public Company getCompany() {
        return this.company;
    }
    @Override
    public String toString() {
        return this.name;
    }
}

Answer 3

You can do it grouping by on multiple fields Company and length of name

Map<Company, Map<Integer, List<Person>>> map = list.stream()
            .collect(Collectors.groupingBy(Person::getCompany, Collectors.groupingBy(p -> p.getName().length())));

And the create Entries from outer map key and inner map value having max length (name) which is inner map key

Map<Company, List<Person>> resultMap = map.entrySet().stream()
            .map(e -> new AbstractMap.SimpleEntry<>(e.getKey(),
                    e.getValue().entrySet().stream()
                            .max(Comparator.comparing(Map.Entry<Integer, List<Person>>::getKey)).get().getValue()))
            .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

You can combine these two operations into single stream also

Answer 4

     Person person1 = new Person("Pete", "APPLE");
            Person person2 = new Person("Joe", "APPLE");
            Person person3 = new Person("Jack", "APPLE");
            Person person4 = new Person("Robert", "MICROSOFT");
            Person person5 = new Person("Cate", "MICROSOFT");
            Person person6 = new Person("Abi", "MICROSOFT");

            List<Person> list = new ArrayList<>();

            list.add(person1);
            list.add(person2);
            list.add(person3);
            list.add(person4);
            list.add(person5);
            list.add(person6);

  //Adapt your structure and with this function you can group  
            Map<String, List<Person>> map = list.stream().collect(Collectors.groupingBy(person -> person.getCompany()));

            for (String name: map.keySet()){
                List<Person> persons = map.get(name);
                System.out.println("[" + name + "]");
                persons.forEach(s -> System.out.println(s.getName()));
            }

Out Log: [APPLE] Pete Joe Jack [MICROSOFT] Robert Cate Abi