Course contentsShow
← Java
Lesson 1425 of 2,87032. Streams API: Intermediate OperationsFree lesson

Chaining Multiple filter Operations

Understand that multiple filter calls can be chained together, and how this affects readability versus single complex predicates.

Chaining Multiple filter Operations

You'll learn how combining multiple filter calls affects code readability and execution compared to using a single complex predicate.

The Core Idea

When you need to apply several filtering conditions, you have two approaches: write one filter with a compound predicate (using &&, ||), or chain multiple filter operations one after another. Java Streams allow both, but they have different impacts on readability and maintenance.

Single Complex Predicate vs Multiple Filters

You can write:

stream.filter(person -> person.getAge() > 18 && person.isActive() && person.hasValidEmail())

Or chain multiple filters:

stream.filter(person -> person.getAge() > 18)
      .filter(person -> person.isActive())
      .filter(person -> hasValidEmail())

Both produce the same result—only elements passing all conditions survive.

Why Chain Multiple Filters?

Readability: Each filter expresses one clear criterion. It's easier to understand "adults AND active AND valid email" when each condition stands on its own line.

Maintainability: Adding or removing a condition means adding/removing one line, not editing a complex boolean expression.

Reusability: Individual predicates can be extracted as variables or methods and reused elsewhere.

Performance Consideration

Thanks to lazy evaluation and fusion, the Stream implementation optimizes chained filters into a single pass. Each element is tested by all predicates sequentially, but the stream isn't re-processed multiple times. Performance is essentially identical to a single compound predicate.

Key Takeaway: Chaining multiple filter operations improves code clarity by separating concerns into distinct, readable steps, while Java's lazy evaluation ensures no performance penalty compared to complex single predicates.