To Remove element from the list

objectA.removeIf(x -> conditions);

eg:

objectA.removeIf(x -> blockedWorkerIds.contains(x));

List<String> str1 = new ArrayList<String>();
str1.add("A");
str1.add("B");
str1.add("C");
str1.add("D");

List<String> str2 = new ArrayList<String>();
str2.add("D");
str2.add("E");

str1.removeIf(x -> str2.contains(x)); 

str1.forEach(System.out::println);

OUTPUT: A B C

You don't need streams for this task, especially if you want to mutate the list of friends in-place:

students.forEach(s -> s.getFriends().removeAll(badKids));

And that's it. This uses the Collection.removeAll method.

Important: for this to work, the list of friends returned by the Student.getFriends() method must be mutable, such as ArrayList.

Despite the conciseness of the above solution, it breaks encapsulation, because we are mutating the list of friends of every student from outside the Student class. To fix this, you'd need to add a method to the Student class:

void removeBadKids(List<String> badKids) {
    friends.removeAll(badKids);
}

Thus, the solution would now become:

students.forEach(s -> s.removeBadKids(badKids));

The code that you have right now works perfectly, but is also O(n * m) since removeIf iterates through the List for every Children. One way to improve would be to store every child's personId in a Set<String> and remove every Person from the List<Person> if their personId is contained in the Set:

Set<String> childIds = childrenList.stream()
                                   .map(Children::getPersonId)
                                   .collect(Collectors.toSet());

personList.removeIf(person -> childIds.contains(person.getPersonId()));

You can't efficiently locate an item in an Iterable. I would suggest copying it to a temporary set (unless it already is a set) and then calling contains():

Set<Hotel> discardedSet = new HashSet<>();
discardedHotels.forEach(discardedSet::add);
allHotels.removeIf(h -> discardedSet.contains(h.getHotel()));

If you don't mind the O(n*m) complexity, you can call List.removeIf() within Iterable.forEach():

discardedHotels.forEach(h -> allHotels.removeIf(hps -> hps.getHotel().equals(h)))

Assuming you want to modify the existing objects, not create a clone of them with shorter lists, you'd do it like this:

student.getListCourses().forEach(c ->
    c.getListCoursesDetail().removeIf(d -> ! ids.contains(d.getId())));

The most efficient way is to extract the ID from the path, then attempt to find it in the Set, making each filter execute in constant time, ie O(1) giving an overall O(n), where n is the number of paths:

filePaths.stream()
  .filter(p -> acceptedIds.contains(p.getParent().getFileName().toString()))
  .collect(Collectors.toList());

If the reverse approach is done, where each acceptedIds is searched for in the path (as in other answers), each filter is O(m*k), where m is the number of acceptedIds and k is the average Path length, giving an overall O(n * m * k), which will perform very poorly for even moderate sizes of collections.

If methods hashCode and equals are properly implemented in class Car, the stream-based solutions may look as follows:

• filter out the values, collect into a new list

// Predicate.not added in Java 11
List<Car> notJava11 = cars1.stream()
                        .filter(Predicate.not(cars2::contains))
                        .collect(Collectors.toList());

List<Car> notIn2 = cars1.stream()
                        .filter(car -> !cars2.contains(car))
                        .collect(Collectors.toList());

• Use forEach for cars2 (affecting cars1):

cars2.forEach(cars1::remove); 
// no need to call cars2.stream().forEach(cars1::remove);

Here the first occurrence of Car instance is removed in cars1

• removeIf should work also

cars1.removeIf(cars2::contains);

If you due to some reason equals/hashCode are not overridden in class Car, the following solution may be offered:

List<Car> notIn2 = cars1
        .stream()
        .filter(c1 -> cars2
            .stream()
            .noneMatch(c2 -> 
                 c1.getId() == c2.getId()
                 && Objects.equals(c1.getName(), c2.getName())
            )
        )
        .collect(Collectors.toList());

• removeIf:

cars1.removeIf(c1 -> cars2
    .stream()
    .anyMatch(c2 -> c1.getId() == c2.getId() 
        && Objects.equals(c1.getName(), c2.getName())
    )
);

Here come two possible solutions.

This one is short and concise, but does in fact not remove elements from list1 but utilizes a partitioning collector to create the two lists. Think of the partitioning collector as kind of a two-way filter: if your predicate is fulfilled, collect to one list, if it's not, collect to the other list. The predicate in our case actually is "does list2 contain an employee with the same ID as the stream element from list1?". In order to lower the actual overhead, the code prepares a list of IDs from list2 up-front.

        final List<String> list2Ids = list2.stream()
                .map(Employee::getId)
                .collect(Collectors.toList());

        Map<Boolean, List<Employee>> partitioned = list1.stream()
                .collect(Collectors.partitioningBy(e -> list2Ids.contains(e.getId())));

        list1 = partitioned.get(true);
        List<Employee> list3 = partitioned.get(false);

If you need to keep list1 - e.g. for memory foot-print reasons - and really have to remove the elements from it, I'd say you will have to stick to the really old-fashioned iterator. The reason for that is that iterators allow you to iterate some collection and remove elements while doing so. The next sample does exactly this. Note, that I prepared a list of IDs of list2 up-front again.

        final List<String> list2Ids = list2.stream()
                .map(Employee::getId)
                .collect(Collectors.toList());

        final List<Employee> list3 = new LinkedList<>();

        for (Iterator<Employee> iterator = list1.iterator(); iterator.hasNext();) {
            Employee next = iterator.next();

            if (!list2Ids.contains(next.getId())) {
                list3.add(next);
                iterator.remove();
            }
        }

You can use the removeAll method to remove the items of one list from another list.

To obtain the duplicates you can use the retainAll method, though your approach with the set is also good (and probably more efficient)

I think you can do it with stream by using removeIf and some condition :

list.removeIf(h -> h.getTokens().contains("INC") &&
        Arrays.stream(h.getTokens().split(";"))
                .filter(tag -> tag.contains("INC"))
                .map(tag -> tag.substring(tag.length() - 1))
                .filter("N"::equals)
                .anyMatch(v ->
                        (flag && !h.getPropertyA().equals(anotherObject.getPropertyAValue())) ||
                                (!flag && !h.getPropertyB().equals(anotherObject.getPropertyBValue()))));

Or you can separated the condition in a separated method, for example :

static void doAction(List<Hunt> list) {
    list.removeIf(MyClass::isCorrect);
}

private static boolean isCorrect(Hunt h) {
    return h.getTokens().contains("INC") &&
            Arrays.stream(h.getTokens().split(";"))
                    .filter(tag -> tag.contains("INC"))
                    .map(tag -> tag.substring(tag.length() - 1))
                    .filter("N"::equals)
                    .anyMatch(v ->
                            (flag && !h.getPropertyA().equals(anotherObject.getPropertyAValue())) ||
                            (!flag && !h.getPropertyB().equals(anotherObject.getPropertyBValue())));
}

Or as @Tom Hawtin - tackline suggest, you can use :

static void doAction(List<Hunt> list) {
    list.removeIf(h -> h.getTokens().contains("INC") &&
            Arrays.stream(h.getTokens().split(";"))
                    .anyMatch(tag -> tag.contains("INC") && tag.endsWith("N")
                            && !(flag ? h.getPropertyA().equals(anotherObject.getPropertyAValue())
                            : h.getPropertyB().equals(anotherObject.getPropertyBValue()))));
}