Java流API:Map-Reduce

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

现在，我想过滤给定日期D（D1最年轻日期时间（D2小于D1）的对象vx。 有人能告诉我，如何用Java流API构建它吗

Map Reduce操作返回对象列表

答复：

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

公共类过滤器测试{
静态X类{
字符串组；
int-y；
X（字符串组，整数y）{
this.group=组；
这个。y=y；
}
公共字符串getGroup（）{
返回组；
}
公共int getY（）{
返回y；
}
@凌驾
公共字符串toString（）{
返回字符串。格式（“[组：'%s'，y:'%s']”，组，y）；
}
}
公共静态void main（字符串[]args）{
int-val=2；
列表l=新的ArrayList（）；
l、 添加（新X（“A”，1））；
l、 增加（新的X（“Y”，3））；
l、 增加（新的X（“A”，2））；
l、 增加（新的X（“Y”，1））；
l、 增加（新的X（“B”，8））；
l、 添加（新的X（“A”，3））；
Map Map=l.stream（）.filter（d->d.y d1.getY（）>d2.getY（）？d1:d2
),
可选：：get））；
System.out.println（“m:+map”）；
}
}

表达您的主张的更好方式可以是：

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

Map Map=l.stream（）
.filter（d->d.getY（）事实上，我是这样做的，我只是想知道是否有更简单的方法来处理这个问题。我用一个简单的对象XGreat测试了我的建议，更新了帖子。什么不起作用？你共享的代码？我想我的问题是，我不明白，我很确定没有人能理解。正如我所说的。我只是想知道一个最有可能的w可以构建这种构造。我刚刚开始处理流APIIMHO，您的解决方案应该与您所寻找的内容一起工作。只是一种更简洁的方式来表示它。谢谢……这正是我的意思！
Map<String, X> map = l.stream()
        .filter(d -> d.getY() <= val)
        .collect(Collectors.toMap(X::getGroup, Function.identity(), 
                BinaryOperator.maxBy(Comparator.comparing(X::getY))));