Operating on and Removing an Item from Stream

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:

itemList.stream()
  .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:

itemList.stream()
  .filter(isQualified)
  .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:

itemList.removeIf(isQualified);

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<>();
itemList.stream()
  .filter(item -> item.isQualified())
  .forEach(item -> {
    item.operate();
    operatedList.add(item);
});
itemList.removeAll(operatedList);

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.