Issue with creating nested map using streams and collectors

Question

class QuizAnswers {
  List<CheckboxAnswer> checkBoxAnswers;
}

class CheckboxAnswer {
  int questionId;
  // The indices of the selected answer choices
  List<Integer> answer_selections;
}

The input to my function is a List<QuizAnswers> .

I want to create an output of Map<Integer, Map<Integer, Long>> that maps <CheckboxAnswer.questionId : <CheckboxAnswer.answer_selection, total count of answer_selection> . In other words, I want to create a nested map that maps each multiple selection quiz question to a map representing the total number of selections on each answer choice of that quiz question.

Suppose the input List<QuizAnswers> quizAnswersList as:

[ {questionId: 1, answer_selection: [1,2]},    
  {questionId: 1, answer_selection:[1,2,3,4]},  
  {questionId: 2, answer_selection:[3]},   
  {questionId: 2, answer_selection:[1]} ]

Then I would want the output to be:

{1 : {1:2, 2:2, 3:1, 4:1}, 2: {1:1, 3:1}}

Because the question with Id = 1 received two selections on answer choice 2 and 1 and 1 selection on answer choice 3 and 4 while the question with Id=2 had 1 selection on answer choice 1 and 3 .

I have tried

quizAnswersList.stream()
            .flatMap(
                quizAnswers ->
                    quizAnswers.getCheckboxAnswers().stream())
            .collect(
                answer -> {
                  return Collectors.groupingBy(
                      answer.getQuestionId(),
                      answer.getAnswerSelections().stream()
                          .collect(
                              Collectors.groupingBy(
                                  answerSelection -> answerSelection, 
                                  Collectors.counting())));
                        });

Which is giving me an error that the first collect() is not taking the right arguments.

Answer 1

Although you were close, your usage of collectors is syntactically incorrect.

Firstly, the required method collect() expects a collector ( there's also another flavor of collect() that expect tree "functions": supplier, accumulator and combiner; don't confuse them ), that's the correct syntax:

.collect(MyCollector);

Now, regarding the groupingBy() collector. We need its version that expects a classifier function and a downstream collector :

.collect(Collectors.groupingBy(function, AnotherCollector);

And as a downstream collector we need to provide flatMapping() . Which expects a function that should transform each CheckboxAnswer into a stream of answer selection values ( in order to be able to map each of them to its count ), and a downstream collector . In turn as the downstream of flatMapping() again we need to provide groupingBy() and counting() as its downstream collector .

The final structure of collectors will be the following:

.collect(Collectors.groupingBy(function, // <- getting a question Id
    Collectors.flatMapping(function,     // <- obtaining `answer selection values` as a stream of Integer
        Collectors.groupingBy(function,  // <- Function.identity() is used to retain a `answer selection` without changes
            Collectors.counting()        // <- obtaining a count for each `answer selection`
);

Now, let's put all the things together.

public static void main(String[] args) {
    List<QuizAnswers> quizAnswersList =
        List.of(new QuizAnswers(List.of(new CheckboxAnswer(1, List.of(1,2)),
                                        new CheckboxAnswer(1, List.of(1,2,3,4)))),
                new QuizAnswers(List.of(new CheckboxAnswer(2, List.of(3)),
                                        new CheckboxAnswer(2, List.of(1)))));

    Map<Integer, Map<Integer, Long>> answerSelectionToCountById = quizAnswersList.stream()
        .map(QuizAnswers::getCheckBoxAnswers)
        .flatMap(List::stream)
        .collect(Collectors.groupingBy(
            CheckboxAnswer::getQuestionId,
                Collectors.flatMapping(checkboxAnswer -> checkboxAnswer.getAnswerSelections().stream(),
                    Collectors.groupingBy(Function.identity(),
                        Collectors.counting()))));
    
    answerSelectionToCountById.forEach((k, v) -> System.out.println(k + " : " + v));
}

Output

1 : {1=2, 2=2, 3=1, 4=1}
2 : {1=1, 3=1}

Answer 2

It is may be easier to get to the final result in two steps: After grouping by your questionId you need to map to your answer_selections . This can be done using Collectors.mapping so that you end up with an intermediate result of Map<Integer,List<List<Integer>>> which could look like something like:

Map<Integer, List<List<Integer>>> intermediate =
        quizAnswersList.stream()
                .flatMap(quizAnswers -> quizAnswers.getCheckBoxAnswers().stream())
                .collect(Collectors.groupingBy(CheckboxAnswer::getQuestionId,
                                Collectors.mapping(CheckboxAnswer::getAnswer_selections, Collectors.toList())));

System.out.println(intermediate);

This will give you an output like:

{1=[[1, 2], [1, 2, 3, 4]], 2=[[3], [1]]}

Since the above is not what you realy wanted you need to do one more step and wrap the mapping which is done here

Collectors.mapping(CheckboxAnswer::getAnswer_selections, Collectors.toList())

in to Collectors.collectingAndThen to turn the values of above map which are of type list of lists to a Map<Integer,Long> which can be done like showed below (including the above step, which only was useful to explain the intermediate result, only the code below is needed):

Map<Integer, Map<Integer, Long>> finalresult =
quizAnswersList.stream()
        .flatMap(quizAnswers -> quizAnswers.getCheckBoxAnswers().stream())
        .collect(Collectors.groupingBy(CheckboxAnswer::getQuestionId,
                Collectors.collectingAndThen(
                        Collectors.mapping(CheckboxAnswer::getAnswer_selections, Collectors.toList()),
                        lists -> lists.stream()
                                .flatMap(List::stream)
                                .collect(Collectors.groupingBy(Function.identity(),Collectors.counting())))));

System.out.println(finalresult);

which will give you the desired result

{1={1=2, 2=2, 3=1, 4=1}, 2={1=1, 3=1}}