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

Assuming you have a class PassengerBooking with a List of objects Flight, and that the passengerBooking variable represents a List of objects PassengerBooking.

You could traverse the items of your List. Then, for each PassengerBooking object retrieve the List of Flight with the corresponding getter and then invoke the removeIf method on the Collection returned.

public class Main {
    public static void main(String[] args) {
        List<PassengerBooking> passengerBooking = new ArrayList<>(List.of(
                new PassengerBooking(4, new ArrayList<>(List.of(
                        new Flight("AUS382"),
                        new Flight("ZOD498")
                )))
        ));

        System.out.println(passengerBooking);

        for (PassengerBooking passenger: passengerBooking){
            passenger.getFlights().removeIf(f -> f.getFlightNumber().equals("ZOD498"));
        }

        System.out.println(passengerBooking);
    }
}

Besides, if this is a common operation for your PassengerBooking class, you could think of implementing a custom method to remove a Flight by its id.

This is a simple assumption of your classes' implementation to test the code above.

class PassengerBooking {
    private int bookingId;
    private List<Flight> flights;

    public PassengerBooking(int bookingId, List<Flight> flights) {
        this.bookingId = bookingId;
        this.flights = flights;
    }

    public int getBookingId() {
        return bookingId;
    }

    public List<Flight> getFlights() {
        return flights;
    }

    //Custom utility method
    public void removeFlight(String flightID){
        flights.removeIf(f -> f.getFlightNumber().equals("ZOD498"));
    }

    @Override
    public String toString() {
        return String.format("%d => %s", bookingId, flights);
    }
}

class Flight {
    private String flightNumber;

    public Flight(String flightNumber) {
        this.flightNumber = flightNumber;
    }

    public String getFlightNumber() {
        return flightNumber;
    }

    @Override
    public String toString() {
        return flightNumber;
    }
}

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

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

Since you need your lists to be updated, in the below solution I am using removeIf method of the List to remove any elements which does not meet the necessary criteria. So for removeIf to work, the list should not be immutable. So replace the var list = List.of(...) code with var list = new ArrayList<>(List.of(...)); (Note: Null checks have been ignored as well.)

Now, this problem could be split into components:

1. Predicate to identify if a list has any odd elements.

Predicate<OneDObject> hasOdd = obj-> obj.getList().stream().anyMatch(i -> i % 2 != 0);

2. Predicate to remove objects from 2d list, which has odd elements in its 1d list.

Predicate<TwoDObject> validate2d = obj -> {
    // remove any 1d list that has atleast one odd number.
    obj.getList().removeIf(hasOdd);
    // check if there are any valid 1d lists
    return obj.getList().isEmpty();
};

3. Now apply the predicate to the final list:

l5.removeIf(validate2d); // l5 will now contain only the 2d object having [2,4,6] list

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

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

... It's a list of List<Instance> listInstances = new ArrayList<Instance>(); and the class Instance has vals = new ArrayList<Boolean>(); ....

In this case your solution can look like :

public static Instance deleleNthElement(Instance instance, int index) {
    instance.getVals().remove(index - 1);
    return instance;
}

then with stream you can call the method like so :

int index = 3;
listInstances = listInstances.stream()
          .map(instance -> deleleNthElement(instance, index))
          .collect(Collectors.toList());

If you don't mind, let me bend your requirements a little bit. :-)

One characteristic of the desired result is that the matching elements should end up in one collection, and the non-matching elements should end up in a different collection. In the pre-Java-8 mutative world, the easiest way to think about getting a collection of non-matching elements is to remove the matching elements from the original collection.

But is removal -- modification of the original list -- an intrinsic part of the requirement?

If it isn't, then the result can be achieved via a simple partitioning operation:

Map<Boolean, List<E>> map = data.stream().collect(partitioningBy(predicate));

The result map is essentially two lists, which contain the matching (key = true) and non-matching (key = false) elements.

The advantage is that this technique can be done in one pass and in parallel if necessary. Of course, this creates a duplicate list of non-matching elements compared to removing the matches from the original, but this is the price to pay for immutability. The tradeoffs might be worth it.

Note that in the first method, you can do the following to simplify removal.

List<Integer> list = new ArrayList<>(List.of(1,2,3,4,5,6,7,8,9,10,11,12,13,14,15));
list.removeIf(element -> element % 3 == 0);
System.out.println(list);

prints:

[1, 2, 4, 5, 7, 8, 10, 11, 13, 14]

I don't think streams win you anything in this case. All you do is iterate over the nested lists and either the enhanced for loop or forEach is more straightforward.

The improvements can come from using removeIf to modify the list and, possibly, from moving the rejection logic out of the loop:

Predicate<ThirdClass> reject = third -> !titles.contains(third.getField());

firstClassList.forEeach(first ->
    first.getSecondClassList().forEach(second ->
        second.getThirdClassList().removeIf(reject)
    )
);

So you can get access to the nested list inside of a stream operation and then work with that. In this case we can use a nested stream as our predicate for the filter

employees.stream().filter(
employee -> employee.involvedInProjects.stream()
.anyMatch(proj -> proj.projectId == myTargetId ))

This will give you a stream of all of the employees that have at least one project matching you targetId. From here you can operate further on the stream or collect the stream into a list with .collect(Collectors.toList())