Traverse two collections looking for matches, falling back to certain value for those elements that didn't match

Say I have two collections of A { id, foo } and B { identifier, bar }.

Initially I solved this problem using nested for-loops, but I did try to solve it (unsuccessful I would say) using the Stream API. Basically I need to traverse both collections looking for matches based on a given condition: A.id === B.identifier, in order to create a final map of A elements as keys and the values would be the corresponding A.foo + B.bar for the matches.

The problem for me in the solution using the Stream API was the second part of the requirements: if some element(s) from A did not satisfy the condition, a default value should be assigned (based on a function call)... and I don't know how to plug this while using the Stream API along with the rest of the conditions.

> Notice that the final collection will have as many elements as (initial) A — with the modifications.

Is there an efficient way to accomplish this using the Stream API rather than using nested for-loops and a couple of if conditions?

Can you use the temporary collection? If yes, I would suggest to convert List<B> into Map<Identifier, Bar> mapOfB, so you can much easier and faster find the specified B.identifier without need to traverse the B list for each A element.

Then you can simply do something like:

listOfA.stream()
.collect(toMap(a -> a, a -> {
    var bar = mapOfB.get(a.getId());
    if (bar == null) {
        bar = getDefault();
    }
    return a.getFoo() + bar;
}));

If you can't create the temporary Map:

listOfA.stream()
.collect(toMap(a -> a, a -> {
    var bar = getBarFromBOrDefault(listOfB, a.getId());
    return a.getFoo() + bar;
}))

private Bar getBarFromBOrDefault(List<B> listOfB, Id id) {
    return listOfB.stream()
        .filter(b -> b.getIdentity() == id) // or use .equals() here if it's not a primitive type
        .findFirst()
        .map(B::getBar)
        .orElseGet(() -> getDefault());
}

You can map each A to the list of matching Bs:

List<A> as = ...
List<B> bs = ...

as.stream()
    .map(a -> new Pair<>(a, bs.stream()
                .filter(b -> matches(a, b))
                .toList()))
    .collect(Collectors.toMap(p -> p.fst, p -> p.snd));

For this to work you need to declare you own Pair type, which is prominently missing from the JDK.

record Pair<F, S>(F fst, S snd) {}

Note that even there is no nested for loops, there is still nested iteration: each A is mapped to a list of Bs, which is obtained by traversing all Bs to find the ones that match.

Update

To account for the case where you want to return a default value should there be no matches, you can move the joining to a helper method:

private List<B> join(A a, List<B> bs, B defaultB) {
    List<B> matchingBs = bs.stream()
        .filter(b -> matches(a, b))
        .toList();

    return matchingBs.isEmpty()
        ? List.of(defaultB)
        : matchingBs;
}

and supply a default value from within the stream processing

as.stream()
    .map(a -> new Pair<>(a, join(a, bs, defaultB(a))))
    .collect(Collectors.toMap(p -> p.fst, p -> p.snd));