使用流和收集器创建嵌套地图的问题

Question

class QuizAnswers {
  List<CheckboxAnswer> checkBoxAnswers;
}

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

我功能的输入是 list＆lt; quizanswers＆gt; 。

我想创建一个 map＆lt; integer，map＆lt; integer，long＆gt;＆gt; 映射＆lt; chackboxanswer.questionid：＆lt; chackboxanswer.answer.answer.answer.answer_selection代码>。换句话说，我想创建一个嵌套地图，将每个多个选择测验问题映射到代表该测验问题的每个答案选择总数的地图。

假设输入 list＆lt; quizanswers＆gt; 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]} ]

然后我希望输出为：

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

因为 id = 1 接收到答案选择的两个选择 2 和 1 < /code>和 1 在答案选择上选择 3 和 4 iD = 2 hate > 1 在答案选择上选择 1 和 3 。

我已经尝试过

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

，这给我一个错误，即第一个收集（）没有采用正确的论点。

Answer 1

尽管您很接近，但您对收藏家的使用在句法上是不正确的。

首先，必需的方法 collect> collect（） 期望收集器（也有另一种味道 collect> collect> collect（） 期望树“函数”：供应商，累加器和组合者

.collect(MyCollector);

； .oracle.com/en/java/javase/17/docs/api/java.base/java/java/util/stream/collectors.html＃groupingby（java.util.function.function.function.function.function.function.function）“ rel =” nofollow noreforler noreferrer“ noreferrer”> <代码> groupingby（） 收集器。我们需要它的版本，它可以期望 classifier 函数和a downstream collector ：

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

作为下游收集器，我们需要提供 flatmapping（） 。期望将每个 checkboxanswer 转换为答案选择值的流（） >）和A 下游收集器。依次为 flatmapping（）的下游再次提供 groupingby（） and and counting（） as它的下游收集器。

收藏家的最终结构将是以下内容：

.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`
);

现在，让我们将所有内容放在一起。

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));
}

输出

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

Answer 2

分两个步骤可以更容易地到达最终​​结果：按照质疑进行分组后，您需要将映射到 answers_selections 。可以使用 collector.mapping 来完成此操作类似：

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);

这将为您提供类似的输出：

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

由于以上不是您真正想要的，因此您需要再做一个步骤并包装在此处完成的映射

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

。上述映射的值，即列表的类型列表的类型列表列出到 map＆lt; integer，long＆gt; ，可以如下所示（包括上述步骤，这仅对解释中间结果有用，仅是有用的需要以下代码）：

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);

这将为您带来所需的结果

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