java stream分组并在一次迭代中找到前10名

Question

它推迟了这个如何在使用Java流分组后应用排序和限制，因为我想在一次迭代中解决这个问题

假设我有以下实体：

public static class Hospital {
    private AREA area;
    private int patients;

    public Hospital(AREA area, int patients) {
        this.area = area;
        this.patients = patients;
    }

    public AREA getArea() {
        return area;
    }

    public void setArea(AREA area) {
        this.area = area;
    }

    public int getPatients() {
        return patients;
    }

    public void setPatients(int patients) {
        this.patients = patients;
    }
}

public enum AREA {
    AREA1,
    AREA2,
    AREA3
}

现在，我列出了一个医院列表，我想找到患者最多的地区，以下是我迄今为止所做的工作：

public static void main(String[] args) {
    List<Hospital> list = Arrays.asList(
            new Hospital(AREA.AREA1, 20),
            new Hospital(AREA.AREA2, 10),
            new Hospital(AREA.AREA1, 10),
            new Hospital(AREA.AREA3, 40),
            new Hospital(AREA.AREA2, 10));
    Map<AREA, Integer> map = findTopTen(list);
    for (AREA area : map.keySet())
        System.out.println(area);

}

public static Map<AREA, Integer> findTopTen(Iterable<Hospital> iterable) {
    Map<AREA, Integer> map = StreamSupport.stream(iterable.spliterator(), false)
            .collect(Collectors.groupingBy(Hospital::getArea,
                    Collectors.summingInt(Hospital::getPatients)));
    for (Map.Entry<AREA, Integer> area : map.entrySet())
        System.out.println(area.getKey() + "...." + area.getValue());
    return map.entrySet().stream()
            .sorted((e1, e2) -> e2.getValue() - e1.getValue())
            .collect(Collectors.toMap(Map.Entry::getKey,
                    Map.Entry::getValue, (o, o2) -> o,
                    LinkedHashMap::new));

}

显然，我已经迭代了两次，以找到其中包含大多数患者的前十个区域（一次用于按区域对医院进行分组并计算该组的总和，一次用于查找前十个区域）。

现在我想知道的是：

1） 有没有更好的方法可以在一个流和一次迭代中解决这个问题？

2） 在一次迭代中进行有什么性能优势吗？解决这类问题的最佳实践是什么？（在我看来，一方面，当我调用collect时，这是一个终端操作，它第一次迭代我的iterable并将中间结果保存在另一个对象中，在我的代码中，我将该对象命名为iterationOneResult，因此使用一个流并调用collect一次将忽略该中间结果，这是在java中使用流的主要好处。另一方面，解决这个问题一次迭代中的问题将复杂性从O（2n）降低到O（n））

Answer 1

这很难在使用stream的一次迭代中完成，但使用一个流链可以更简洁

Map<AREA, Integer> map = list.stream()
        .collect(Collectors.groupingBy(Hospital::getArea, Collectors.summingInt(Hospital::getPatients)))
        .entrySet().stream()
        .sorted(Map.Entry.comparingByValue(Comparator.reverseOrder()))
        .limit(10)
        .collect(Collectors.toMap(Map.Entry::getKey, Map.Entry::getValue));

此外，如果要打印中间结果（仅用于调试目的），可以插入

.peek(e -> System.out.println(e.getKey() + " " + e.getValue()))

在.entrySet（）.stream（）之后的rigth