.removeIf() vs .filter().collect()

Question

I need a method, which filter out a collection by checking if the element's field is contained in another collection's element's field. Which way is better:

A method, returning filtered collection:

List method1(List foo, List bar){
    if(bar.isEmpty()) 
        return Collections.emptyList();
    Set<Integer> ids = bar.stream().map(elem->elem.getId).collect(Collectors.toSet());
    return foo.stream().filter(elem->ids.contains(elem.barId));
}

• easy handling empty conditional collection
• creating stream and another collection

Or a method, modifying the original collection:

void method2(List foo, List bar){
    if(bar.isEmpty()){ 
         foo.clear();
         return;
    }
    Set<Integer> ids = bar.stream().map(elem->elem.getId).collect(Collectors.toSet());
    foo.removeIf(elem->ids.contains(elem.barId));
}

• no redundant object
• clearing original collection instead of just return new

Answer 1

Your method1 & method2 will not work as you expected as it does not have a terminal operation in your last stream on foo. It is recommended to use immutable approach whenever possible as it leads to less error-prone code and easy to understand the code behaviour. You should read about this

List method1(List foo, List bar){
    
    if (bar.isEmpty()) 
        return Collections.emptyList();

    final Set<Integer> barIds = getIds(bar);
    return foo.stream()
              .filter(elem->barIds.contains(elem.barId))
              .collect(Collectors.toList());
}

private Set<Integer> getIds(final List bar) {

  return bar.stream()
            .map(elem->elem.getId)
            .collect(Collectors.toSet());
}

Answer 2

First approach is imho better. Out parameter concept in real life is hard to maintain.