Java流平均值

Question

我需要使用流创建两个方法。返回每个任务平均分数的方法。

    public Map<String, Double> averageScoresPerTask(Stream<CourseResult> results) {}

以及一种返回平均得分最高的任务的方法。

    public String easiestTask(Stream<CourseResult> results) {}

我只能修改这两种方法。

这是CourseResult课程

public class CourseResult {
    private final Person person;
    private final Map<String, Integer> taskResults;

    public CourseResult(final Person person, final Map<String, Integer> taskResults) {
        this.person = person;
        this.taskResults = taskResults;
    }

    public Person getPerson() {
        return person;
    }

    public Map<String, Integer> getTaskResults() {
        return taskResults;
    }
}

以及创建CourseResult对象的方法。

private final String[] programTasks = {"Lab 1. Figures", "Lab 2. War and Peace", "Lab 3. File Tree"};
private final String[] practicalHistoryTasks = {"Shieldwalling", "Phalanxing", "Wedging", "Tercioing"};

private Stream<CourseResult> programmingResults(final Random random) {
    int n = random.nextInt(names.length);
    int l = random.nextInt(lastNames.length);

    return IntStream.iterate(0, i -> i + 1)
            .limit(3)
            .mapToObj(i -> new Person(
                    names[(n + i) % names.length],
                    lastNames[(l + i) % lastNames.length],
                    18 + random.nextInt(20)))
            .map(p -> new CourseResult(p, Arrays.stream(programTasks).collect(toMap(
                    task -> task,
                    task -> random.nextInt(51) + 50))));
}

private Stream<CourseResult> historyResults(final Random random) {
    int n = random.nextInt(names.length);
    int l = random.nextInt(lastNames.length);
    AtomicInteger t = new AtomicInteger(practicalHistoryTasks.length);

    return IntStream.iterate(0, i -> i + 1)
            .limit(3)
            .mapToObj(i -> new Person(
                    names[(n + i) % names.length],
                    lastNames[(l + i) % lastNames.length],
                    18 + random.nextInt(20)))
            .map(p -> new CourseResult(p,
                    IntStream.iterate(t.getAndIncrement(), i -> t.getAndIncrement())
                            .map(i -> i % practicalHistoryTasks.length)
                            .mapToObj(i -> practicalHistoryTasks[i])
                            .limit(3)
                            .collect(toMap(
                                    task -> task,
                                    task -> random.nextInt(51) + 50))));
}

基于这些方法，我可以通过将该任务的分数之和除以3来计算每个任务的平均值，因为只有3个人可以让它除以一个等于流中CourseResult对象数量的数字，如果这些方法改变了它们的. limited（3）。我不知道如何访问任务结果地图的键。我想我需要他们然后返回一个唯一键的地图。每个唯一键的值应该是来自任务结果地图分配给这些键的值的平均值。

Answer 1

对于您的第一个问题：将每个CourseResult映射到task结果，平面映射以获取每个task结果映射形成所有CourseResults的所有条目，按映射键（任务名称）分组并收集相同键的平均值：

public Map<String, Double> averageScoresPerTask(Stream<CourseResult> results) {
    return results.map(CourseResult::getTaskResults)
            .flatMap(m -> m.entrySet().stream())
            .collect(Collectors.groupingBy(Map.Entry::getKey, Collectors.averagingInt(Map.Entry::getValue)));
}

您可以对第二个问题使用相同的方法来计算每个任务的平均值，并最终在结果地图的条目上流式传输以找到平均值最高的任务。

public String easiestTask(Stream<CourseResult> results) {
    return results.map(CourseResult::getTaskResults)
            .flatMap(m -> m.entrySet().stream())
            .collect(Collectors.groupingBy(Map.Entry::getKey, Collectors.averagingInt(Map.Entry::getValue)))
            .entrySet().stream()
            .max(Map.Entry.comparingByValue())
            .map(Map.Entry::getKey)
            .orElse("No easy task found");
}

为了避免代码重复，可以在第二个方法中调用第一个方法：

public String easiestTask(Stream<CourseResult> results) {
    return averageScoresPerTask(results).entrySet()
            .stream()
            .max(Map.Entry.comparingByValue())
            .map(Map.Entry::getKey)
            .orElse("No easy task found");
}

Answer 2

要为每个任务创建一个包含平均分数的映射，您需要展平流中每个CourseResult结果对象的maptaskResult，并按键（即任务名称）对数据进行分组。

为此，您可以使用收集器groupingBy（），作为其下游收集器，负责计算映射到同一任务的分数值的平均值，您可以使用averagingDouble（）。

这就是它看起来的样子：

public Map<String, Double> averageScoresPerTask(Stream<CourseResult> results) {
    
    return results
        .map(CourseResult::getTaskResults)
        .flatMap(map -> map.entrySet().stream())
        .collect(Collectors.groupingBy(
            Map.Entry::getKey,
            Collectors.averagingDouble(Map.Entry::getValue)
        ));
}

要找到最简单的任务，您可以使用此映射而不是将流作为参数传递。

public String easiestTask( Map<String, Double>  averageByTask) {
    
    return averageByTask.entrySet().stream()
        .max(Map.Entry.comparingByValue())
        .map(Map.Entry::getKey)
        .orElse("no data"); // or orElseThrow() depending on your needs
}