使用stream（）collect（）groupingBy（）和reduce（）的多级映射

Question

I managed to write Collector.groupingBy(Function, groupingBy(classifier, toList())

Map<String, Map<Person.Sex, List<Person>>> groupByYearThenSex = personList.stream().collect(
    groupingBy(p ->{
            if(p.getYear() > 2015) return "New members";
            else if(p.getYear() < 2009) return "Senior members";
            else return "Normal members";
        },
        groupingBy(Person::getSex)
    )
);
groupByYearThenSex.forEach((String y, Map<Person.Sex, List<Person>> m) ->{
    System.out.println("\n" + y);
    m.forEach((Person.Sex s, List<Person> p) -> {
        System.out.println("   " + s);
        p.forEach((Person prsn) -> {
            System.out.println("      " + prsn.toString());
        });

    });
});

The corresponding result is:

New members

       MALE
           Person{name: Gawel, age: 23, sex: MALE}

Normal members

       MALE
          Person{name: Patryk, age: 34, sex: MALE}
          Person{name: Pawel, age: 21, sex: MALE}
          Person{name: Bolek, age: 12, sex: MALE}
          Person{name: Lolek, age: 12, sex: MALE}
      FEMALE
          Person{name: Jola, age: 70, sex: FEMALE}
          Person{name: Ala, age: 25, sex: FEMALE}

Senior members

      FEMALE
          Person{name: Iwona, age: 34, sex: FEMALE}
          Person{name: Oliwia, age: 17, sex: FEMALE}

Now I'm trying to produce the multi-level map that lists only the oldest members as follows:

New members

       MALE
           Person{name: Gawel, age: 23, sex: MALE}

Normal members

       MALE
          Person{name: Patryk, age: 34, sex: MALE}
      FEMALE
          Person{name: Jola, age: 70, sex: FEMALE}

Senior members

      FEMALE
          Person{name: Iwona, age: 34, sex: FEMALE}

The code below does not work. I get "inference variable RR has incompatible bounds error, which is I think Function<R,RR> => collectingAndThen(reducing(), Optional) . Is there any way I can reduce the stream of Persons to get the oldest ones and get the output above?

Map<String, Map<Person.Sex, List<Person>>> groupByYearThenSexOldest = personList.stream().collect(
    groupingBy(p ->{
            if(p.getYear() > 2015) return "New members";
            else if(p.getYear() < 2009) return "Senior members";
            else return "Normal members";
        },
        groupingBy(Person::getSex, collectingAndThen(
            reducing((p1, p2) -> p1.getAge() > p2.getAge() ? p1 : p2),
            Optional::get)
        )
    )
);

Answer 1

The problem is the type parameters of your map. It should give you a Map<String, Map<Person.Sex, Person>> instead of a Map<String, Map<Person.Sex, List<Person>>> since you are reducing the list.

But you can combine the second groupingBy collector with maxBy and collectingAndThen :

groupingBy(Person::getSex, collectingAndThen(maxBy(Comparator.comparingInt(Person::getAge)), Optional::get)

Sometimes if you need to group by multiple fields, you can use a list that groups the fields (assuming they have a proper equals and hashcode methods). For instance:

Function<Person, String> groupingYear = p -> {
     if (p.getYear() > 2015) return "New members";
     else if (p.getYear() < 2009) return "Senior members";
     else return "Normal members";
};

Map<Object, Optional<Person>> map2 = 
    personList.stream()
              .collect(groupingBy(p -> Arrays.asList(groupingYear.apply(p), p.getSex()), maxBy(Comparator.comparingInt(Person::getAge))));

which gives:

[Normal members, MALE] => Optional[Person{name='Patryk', age=34, sex=MALE}]
[Senior members, FEMALE] => Optional[Person{name='Iwona', age=34, sex=FEMALE}]
[Normal members, FEMALE] => Optional[Person{name='Jola', age=70, sex=FEMALE}]
[New members, MALE] => Optional[Person{name='Gawel', age=23, sex=MALE}]

But then you may start by using the toMap collector and compare the ages in the merge function you supply when 2 values are grouped together:

Map<Object, Person> map =
    personList.stream()
              .collect(toMap(p -> Arrays.asList(groupingYear.apply(p), p.getSex()),
                             p -> p,
                             (p1, p2) -> {
                                 if(p1.getAge() > p2.getAge()) return p1;
                                 else return p2;
                             },
                             HashMap::new));

You have an Object as key in your Map (the real type is awful and long to write), but what you can do is create a dedicated class MemberStatusAndSex that combines both attributes (instead of a List - don't forget to implement equals and hashcode for this class), and get a Map<MemberStatusAndSex, Person> at the end.