Проблема со сбором в поток после фильтра на карту

Question

У меня есть два списка, и я должен создать карту из них.Во-первых, я перебираю цикл for, а во-вторых, я хотел бы бросить потоком, а затем собрать для отображения, но я не знаю, как использовать Collectors.toMap в этом конкретном случае.Возможно ли это?

Я уже принял решение, но не использовал поток, однако мне очень любопытно, можно ли это сделать, и если да, то как это сделать?

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

Answer 1

Я попытался восстановить вашу проблему, и я создаю три простых оператора

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

и следующий метод

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

Результат выглядит следующим образом:

{ObjectB {number = 3, quality = bbb1, handoverTime = null, objectC = ObjectC {number = 1, quality = aaa1}} = ObjectA {number = 1,качество = aaa1}, ObjectB {число = 4, качество = bbb2, handoverTime = ноль, objectC = ObjectC {число = 2, качество = aaa2}} = ObjectA {число = 2, качество = aaa2}}

Я надеюсь, что это помогает.

Answer 2

Вы можете попробовать с 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));

Это предполагает, что каждый экземпляр ObjectB не будет связан с более чем одним ObjectA экземпляром.