Java-Stream-API：Map Reduce

Question

假设我有多个 obj_vx 类型的java对象，每个对象的日期时间不同（作为成员变量）。

obj_v1[D1]
obj_v1[D2]
obj_v1[D3]
obj_v1[D4]

obj_v2[D2]
obj_v2[D3]
obj_v2[D4]

obj_v3[D2]
obj_v3[D3]
obj_v3[D4]

obj_v4[D1]
obj_v4[D2]
obj_v4[D5]


obj_v5[D1]
obj_v5[D4]
obj_v5[D5]
obj_v5[D6]

obj_v5[D4]
obj_v5[D5]

or 

obj_v1 [D1, D2, D3, D4]
obj_v2 [D2, D3, D4]
obj_v3 [D2, D3, D4]
obj_v4 [D1, D2, D5]
obj_v5 [D1, D4, D5, D6]
obj_v6 [D4, D5]

现在，我要过滤给定日期 D（D1 ，将日期时间最短的 obj_vx （D2年龄较小比D1）。 谁能告诉我，如何使用Java-Stream-API构建它？

Map-Reduce操作返回 obj_vx 对象的列表。

响应：

- after 1st iteration
obj_v1 [D1, D2, D3]
obj_v2 [D2, D3]
obj_v3 [D2, D3]
obj_v4 [D1, D2]
obj_v5 [D1]
- after 2nd iteration
obj_v1[D3], obj_v2[D3], obj_v3[D3], obj_v4[D2], obj_v5[D1].

主张：

public class FilterTest {
       static class X {
             String group;
             int y;

             X(String group, int y) {
                    this.group = group;
                    this.y = y;
             }

             public String getGroup() {
                    return group;
             }

             public int getY() {
                    return y;
             }

             @Override
             public String toString() {
                    return String.format("[group: '%s', y: '%s']", group, y);
             }
       }

       public static void main(String[] args) {
             int val = 2;

             List<X> l = new ArrayList<>();
             l.add(new X("A", 1));
             l.add(new X("Y", 3));
             l.add(new X("A", 2));
             l.add(new X("Y", 1));
             l.add(new X("B", 8));
             l.add(new X("A", 3));

             Map<String, X> map = l.stream().filter(d -> d.y <= val).collect(
                     Collectors.groupingBy(X::getGroup,
                         Collectors.collectingAndThen(
                             Collectors.reducing(
                                        (X d1, X d2) -> d1.getY() > d2.getY() ? d1 : d2
                           ),
                             Optional::get)));
             System.out.println("m: " + map);     
       }
}

Answer 1

代表您的主张的更好的方法可能是：

Map<String, X> map = l.stream()
        .filter(d -> d.getY() <= val)
        .collect(Collectors.toMap(X::getGroup, Function.identity(), 
                BinaryOperator.maxBy(Comparator.comparing(X::getY))));