对对象列表进行排序和分组

Question

我有一个过程对象列表如下

Procedure1  01/01/2020
Procedure2  03/01/2020
Procedure3  03/01/2020
Procedure1  04/01/2020
Procedure5  05/01/2020, 02/01/2020
Procedure2  06/01/2020

我的程序class就像

Class Procedure {
    List<Date> procedureDate;
    String procedureName;
}

我想根据以下条件对对象进行排序和分组。

应根据过程名称对所有过程进行分组。
程序必须按程序日期降序排列。 [日期列表中的第一个元素，即 procedureDate.get[0]]
相同的程序组合在一起应按日期降序排列。

最终结果必须是，

Procedure2  06/01/2020
Procedure2  03/01/2020

Procedure5  05/01/2020, 02/01/2020

Procedure1  04/01/2020
Procedure1  01/01/2020

Procedure3  03/01/2020

我能够使用 Comparator 和旧的 java 代码实现这一点。是否可以使用 java8 个流、收集器和分组来实现相同的目的？

Answer 1

这是一个非常有趣的问题。解决方案并不像看上去的那么简单。您必须将解决方案分为多个步骤：

根据 List<Date> 中的第一个日期获取每个分组 procedureName 的最大值。
根据第一步中创建的 Map<String, Date 的最大 Date 值比较 Procedure 个实例。
如果它们相等，则按名称区分它们（例如两次 Procedure 2）。
如果它们仍然相等，则根据实际的第一个日期对 Procedure 个实例进行排序。

这是演示：https://www.jdoodle.com/iembed/v0/Te。

步骤 1

List<Procedure> procedures = ...

Map<String, Date> map = procedures.stream().collect(
    Collectors.collectingAndThen(
        Collectors.groupingBy(
            Procedure::getProcedureName,
            Collectors.maxBy(Comparator.comparing(s -> s.getProcedureDate().get(0)))),
    s -> s.entrySet().stream()
        .filter(e -> e.getValue().isPresent())
        .collect(Collectors.toMap(
              Map.Entry::getKey,
              e -> e.getValue().get().getProcedureDate().get(0)))));

.. 解释：有一种简单的方法可以获取 Procedure 的最大第一个日期按 procedureName.

分组

Map<String, Optional<Procedure>> mapOfOptionalProcedures = procedures.stream()
    .collect(Collectors.groupingBy(
             Procedure::getProcedureName,
             Collectors.maxBy(Comparator.comparing(o -> o.getProcedureDate().get(0)))));

不过，returned结构有点笨拙（Map<String, Optional<Procedure>>），要使其有用和直接return Date，需要额外的下游收集器 Collectors::collectingAndThen 使用 Function 作为结果映射器：

Map<String, Date> map = procedures.stream().collect(
    Collectors.collectingAndThen(
        /* grouping part */,
        s -> s.entrySet().stream()
            .filter(e -> e.getValue().isPresent())
            .collect(Collectors.toMap(
                    Map.Entry::getKey,
                    e -> e.getValue().get().getProcedureDate().get(0)))));

...这实际上是第一个片段。

步骤 2、3 和 4

基本上，按每个组的最大日期排序。然后按姓名排序，最后按实际第一次约会排序。

Collections.sort(
    procedures,
    (l, r) -> {
        int dates = map.get(r.getProcedureName()).compareTo(map.get(l.getProcedureName()));
        if (dates == 0) {
             int names =  l.getProcedureName().compareTo(r.getProcedureName());
             if (names == 0) {
                 return r.getProcedureDate().get(0).compareTo(l.getProcedureDate().get(0));
             } else return names;
        } else return dates;
    }
);

排序结果

根据您的问题使用已弃用的 java.util.Date，排序后的 procedures 将具有与您预期的代码段类似的排序项目（我已覆盖 Procedure::toString 方法）

@Override
public String toString() {
     return procedureName + " " + procedureDate;
}

Procedure2 [Mon Jan 06 00:00:00 CET 2020]
Procedure2 [Fri Jan 03 00:00:00 CET 2020]
Procedure5 [Sun Jan 05 00:00:00 CET 2020, Thu Jan 02 00:00:00 CET 2020]
Procedure1 [Sat Jan 04 00:00:00 CET 2020]
Procedure1 [Wed Jan 01 00:00:00 CET 2020]
Procedure3 [Fri Jan 03 00:00:00 CET 2020]

Answer 2

我的想法来自于基于map-reduce的函数式编程。你可以看到 groupBy/collect 实际上是 reduce 的一种形式，这个问题可以更好地“合并”而不是使用 Stream 的 groupBy 特性。这是我在纯 Stream 中的实现。

List<Procedure> a = List.of(
    new Procedure(...),
    ...

)


List<Procedure> b = a.stream().map((p)-> {                    // Prepare for reduce by create Map for each object
        Map<String,Procedure> mapP = new HashMap<>();
        mapP.put(p.getProcedureName(),p)
        return mapP
    }).reduce((p,q)->{                                         //Use reduce to merge
        q.entrySet().stream().forEach((qq)-> {
            if (p.containsKey(qq.getKey())) {
                p.get(qq.getKey()).setProcedureDate(
                    new ArrayList<Date>(
                        Stream.concat(
                            p.get(qq.getKey()).getProcedureDate().stream(),
                            qq.getValue().getProcedureDate().stream())
                        .collect(Collectors.toSet()))
                );
            } else {
                p.put(qq.getKey(), qq.getValue());
            }

        })

        return p;
    }).get().values().stream().map(p-> {                          //sort date inside object
            p.setProcedureDate(p.getProcedureDate().stream().sorted().collect(Collectors.toList()))
            return p;
        }
    ).sorted((x,y)->                                         //sort object by the first date

        x.procedureDate.get(0).compareTo(y.procedureDate.get(0))

    ).collect(Collectors.toList());

对对象列表进行排序和分组

Sorting and Grouping on a list of objects

java

java-8

java-stream

collectors

groupingby