Expand Authors Top

If you have a few years of experience in the Java ecosystem and you’d like to share that with the community, have a look at our Contribution Guidelines.

November Discount Launch 2022 – Top
We’re finally running a Black Friday launch. All Courses are 30% off until next Friday:


November Discount Launch 2022 – TEMP TOP (NPI)
We’re finally running a Black Friday launch. All Courses are 30% off until next Friday:


Expanded Audience – Frontegg – Security (partner)
announcement - icon User management is very complex, when implemented properly. No surprise here.

Not having to roll all of that out manually, but instead integrating a mature, fully-fledged solution - yeah, that makes a lot of sense.
That's basically what Frontegg is - User Management for your application. It's focused on making your app scalable, secure and enjoyable for your users.
From signup to authentication, it supports simple scenarios all the way to complex and custom application logic.

Have a look:

>> Elegant User Management, Tailor-made for B2B SaaS

1. Overview

In this quick tutorial, we'll learn about the various ways in which we can operate on an item in a Java 8 stream and then remove it once the operation is complete.

2. Setup

Let us define our Item object first. This is a simple object with a single int field.

It has a method that determines whether the object is qualified for operation, based on the internal value:

class Item {
    private int value;

    // constructors

    public boolean isQualified() {
        return value % 2 == 0;

    public void operate() {
        System.out.println("Even Number");

Now we can create a source for our Stream which can be a collection of Items:

List<Item> itemList = new ArrayList<>();
for (int i = 0; i < 10; i++) {
    itemList.add(new Item(i));

3. Filtering Items

In many cases, if we want to do something with a subset of items, we can use the Stream#filter method, and we don't need to remove anything first:

  .filter(item -> item.isQualified())

4. Operating and Removing an Item

4.1. Collection.removeIf

We can use Streams to iterate and operate over the collection of Items.

Using Streams, we can apply lambda functions known as Predicates. To read more about Streams and Predicates, we have another article here.

We can create a Predicate that would determine if an Item qualifies to be operated on:

Predicate<Item> isQualified = item -> item.isQualified();

Our Predicate will filter the Items that we want to operate on:

  .forEach(item -> item.operate());

Once we've finished operating on the items in the stream, we can remove them using the same Predicate we used earlier for filtering:


Internally, removeIf uses an Iterator to iterate over the list and match the elements using the predicate. We can now remove any matching elements from the list.

4.2. Collection.removeAll

We can also use another list to hold the elements that have been operated upon, and then remove them from the original list:

List<Item> operatedList = new ArrayList<>();
  .filter(item -> item.isQualified())
  .forEach(item -> {

Unlike removeIf that uses an Iterator, removeAll uses a simple for-loop to remove all the matching elements in the list.

5. Conclusion

In this article, we looked at a way of operating on an item in Java 8 Streams and then removing it. We also saw a way of doing it by using an additional list and removing all the matched elements.

The source code for this tutorial and the relevant test cases are available over on GitHub.

November Discount Launch 2022 – Bottom
We’re finally running a Black Friday launch. All Courses are 30% off until next Friday:


Generic footer banner
Comments are closed on this article!