Java 过滤到映射后收集到流的问题

我有两个列表，我必须从中创建一个地图。第一，我在for循环中迭代，第二，我想通过流抛出，然后收集到map，但我不知道在这种特定情况下如何使用Collectors.toMap。可能吗

我已经提出了一个解决方案，但没有使用stream，但我很好奇是否可以这样做，如果可以，如何做

public void findMatch(List<ObjectA> objectAList, List<ObjectB> objectBList) {
Map<ObjectB, ObjectA> objectBObjectAMap = new HashMap<>();
for (ObjectB objectB : objectBList) {
    if (isNull(objectB.getHandoverTime())) {
        objectBObjectAMap.putAll(
        objectAList
                .stream()
                .filter(objectA -> {
                    ObjectC objectC = objectB.getObjectC();
                    return objectA.getNumber().equals(objectC.getNumber())
                            && objectA.getQuality().equals(objectC.getQuality());
                })
                .collect(Collectors.toMap(???)));
        }
    }
}

public void findMatch（列表对象主义者，列表对象主义者）{
Map objectBObjectAMap=newhashmap（）；
for（ObjectB ObjectB:objectBList）{
if（isNull（objectB.getHandoverTime（））{
ObjectBobObjectAmap.putAll(
反对者
.stream（）
.filter（对象A->{
ObjectC ObjectC=objectB.getObjectC（）；
返回objectA.getNumber（）.equals（objectC.getNumber（））
&&objectA.getQuality（）.equals（objectC.getQuality（））；
})
.collect（Collectors.toMap（？）；
}
}
}

您可以尝试使用

flatMap

：

Map<ObjectB, ObjectA> objectBObjectAMap =
    objectBList.stream()
               .filter(b -> isNull(b.getHandoverTime()))
               .flatMap(b -> objectAList.stream()
                                        .filter(a -> {
                                            ObjectC c = b.getObjectC();
                                            return a.getNumber().equals(c.getNumber()) &&
                                                   a.getQuality().equals(c.getQuality());
                                        })
                                        .map(a -> new SimpleEntry<>(b,a)))
               .collect(Collectors.toMap(Map.Entry::getKey,Map.Entry::getValue));

映射对象对象对象映射=
objectBList.stream（）
.filter（b->isNull（b.getHandoverTime（））
.flatMap（b->objectAList.stream（）
.过滤器（a->{
ObjectC=b.getObjectC（）；
返回a.getNumber（）.equals（c.getNumber（））&&
a、 getQuality（）等于（c.getQuality（））；
})
.map（a->new SimpleEntry（b，a）））
.collect（Collectors.toMap（Map.Entry:：getKey，Map.Entry:：getValue））；

---

这是假设每个

ObjectB

实例不会与多个

ObjectA

实例关联。

我尝试恢复您的问题，并创建了三个简单的类别

public class ObjectA {
    Long number;
    String quality;
    ...
}

public class ObjectB {
    Long number;
    String quality;
    Date handoverTime;
    ObjectC objectC;
    ...
}

public class ObjectC {
    Long number;
    String quality;
    ...
}

主要功能与我希望您的处理

    ObjectA a1 = new ObjectA();
    a1.setNumber(1L);
    a1.setQuality("aaa1");

    ObjectA a2 = new ObjectA();
    a2.setNumber(2L);
    a2.setQuality("aaa2");

    List<ObjectA> aList = new ArrayList<>();
    aList.add(a1);
    aList.add(a2);

    ObjectB b1 = new ObjectB();
    b1.setNumber(3L);
    b1.setQuality("bbb1");
    //b1.setHandoverTime(new Date());
    ObjectC c1 = new ObjectC();
    c1.setNumber(1L);
    c1.setQuality("aaa1");
    b1.setObjectC(c1);

    ObjectB b2 = new ObjectB();
    b2.setNumber(4L);
    b2.setQuality("bbb2");
    //b2.setHandoverTime(new Date());
    ObjectC c2 = new ObjectC();
    c2.setNumber(2L);
    c2.setQuality("aaa2");
    b2.setObjectC(c2);

    List<ObjectB> bList = new ArrayList<>();
    bList.add(b1);
    bList.add(b2);

    Map<ObjectB, ObjectA> mapzz = findMatch(aList, bList);

    System.out.println(mapzz);

ObjectA a1=新的ObjectA（）；
a1.设置编号（1L）；
a1.设定质量（“aaa1”）；
ObjectA a2=新的ObjectA（）；
a2.设置编号（2L）；
a2.设定质量（“aaa2”）；
列表列表=新的ArrayList（）；
3.添加（a1）；
（a）添加（a2）；
ObjectB b1=新的ObjectB（）；
b1.设置编号（3L）；
b1.设定质量（“bbb1”）；
//b1.设置切换时间（新日期（））；
ObjectC c1=新的ObjectC（）；
c1.设置编号（1L）；
c1.设定质量（“aaa1”）；
b1.setObjectC（c1）；
ObjectB b2=新的ObjectB（）；
b2.设定值（4L）；
b2.setQuality（“bbb2”）；
//b2.设置切换时间（新日期（））；
ObjectC c2=新的ObjectC（）；
c2.设置编号（2L）；
c2.设定质量（“aaa2”）；
b2.setObjectC（c2）；
List bList=new ArrayList（）；
b添加（b1）；
bList.add（b2）；
Map mapzz=findMatch（列表，bList）；
System.out.println（mapzz）；

和以下方法

public static Map<ObjectB, ObjectA> findMatch(List<ObjectA> objectAList, List<ObjectB> objectBList) {
    List<ObjectA> checkPoint1 = new ArrayList<>();
    Map<ObjectB, ObjectA> mapzz = new HashMap<>();

    mapzz.putAll(
        objectBList.stream()
            .filter(objB -> isNull(objB.getHandoverTime()))
            .collect(Collectors.toMap(Function.identity(), 
                    objB -> objectAList
                        .stream()
                        .filter((a) -> a.getNumber().equals(objB.getObjectC().getNumber()) && a.getQuality().equals(objB.getObjectC().getQuality()))
                        .peek(checkPoint1::add)
                        .findAny().get()
                    ))
    );
    return mapzz;
}

公共静态映射findMatch（列表对象主义者，列表对象主义者）{
List checkPoint1=new ArrayList（）；
Map mapzz=新的HashMap（）；
普塔尔地图(
objectBList.stream（）
.filter（objB->isNull（objB.getHandoverTime（））
.collect（Collectors.toMap（Function.identity（）），
反对者
.stream（）
.filter（（a）->a.getNumber（）.equals（objB.getObjectC（）.getNumber（））和&a.getQuality（）.equals（objB.getObjectC（）.getQuality（））
.peek（检查点1:：添加）
.findAny（）.get（）
))
);
返回mapzz；
}

结果如下：

{ObjectB{number=3，quality=bbb1，handoverTime=null，objectC=objectC{number=1，quality=aaa1}}=ObjectA{number=1，quality=aaa1}，ObjectB{number=4，quality=bbb2，handoverTime=null，objectC=objectC{number=2，quality=aaa2}=ObjectA{number=2，quality=aaa2}

---

我希望这会有所帮助。

如果多个ObjectA实例与同一个ObjectB实例关联，您打算怎么办？从业务角度看，这是不可能的，因为收集器中仍然存在问题：无法从静态上下文引用非静态方法。@rudkul一定是打字错误。我找到了一个丢失的（见编辑）。希望这是唯一的打字错误。