流数和常数的流平均值

Question

这是我的代码，它根据一个人所做测试的平均分数返回一个分数。

    public Map<Person, String> defineMarks(Stream<CourseResult> results) {
    return results.collect(Collectors.toMap(CourseResult::getPerson,x->{
        double avg=x.getTaskResults().values().stream().collect(Collectors.summarizingInt(Integer::intValue)).getAverage();
        if(avg > 90) return "A";
        if(avg >= 83) return "B";
        if(avg >= 75) return "C";
        if(avg >= 68) return "D";
        if(avg >= 60) return "E";
        else return "F";
    }));
}

以下是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;
    }
}

和2种生成测试分数的方法。历史结果

private final String[] practicalHistoryTasks = {"Shieldwalling", "Phalanxing", "Wedging", "Tercioing"};

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

和编程结果

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

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

所以每个人有3个测试分数。如果我使用编程生成分数，结果很好，因为只有3个编程测试，但是如果我使用历史生成分数，结果我也每个人得到3个测试分数，但是我应该把它当作第四个测试根本没有尝试，这意味着0分。我如何让我的定义标记方法得到收集的测试分数的平均值，而在历史结果的情况下，得到收集的测试分数的平均值和0分。

如果我的问题不清楚，请指导我如何让它变得更好： D

Answer 1

我不太明白这个练习的意义。但是如果你只想在你的流中添加一个值，并且你不能修改测试分数的产生方法（在那里很容易将限制（3）更改为限制（4）），那么你可以使用任务名称来改变你计算平均值的方式，因为所有编程任务都以Lab...开头：

return results.collect(
        Collectors.toMap(
                CourseResult::getPerson,
                x -> {
                    boolean areProgramTasks = x.getTaskResults().keySet().stream().allMatch(key -> key.startsWith("Lab "));
                    double avg;
                    if(areProgramTasks){
                        avg = x.getTaskResults().values().stream().collect(Collectors.summarizingInt(Integer::intValue)).getAverage();
                    }
                    else {
                        avg = Stream.concat(Stream.of(0), x.getTaskResults().values().stream()).collect(Collectors.summarizingInt(Integer::intValue)).getAverage();
                    }
                    if(avg >  90) return "A";
                    if(avg >= 83) return "B";
                    if(avg >= 75) return "C";
                    if(avg >= 68) return "D";
                    if(avg >= 60) return "E";
                    else return "F";
                }
        ));