How do I filter a list using a stream in Java?

You can use the Stream API’s filter() method to select elements that match a condition.

In this example, you will select numbers greater than or equal to 20 from a list and collect them into a new list.

Source code

Save the following code as FilterListExample.java:

import java.util.List;

public class FilterListExample {
    void main() {
        List<Integer> numbers = List.of(5, 20, 12, 35, 8, 40);

        List<Integer> filteredNumbers = numbers.stream()
                .filter(number -> number >= 20)
                .toList();

        IO.println("Original list: " + numbers);
        IO.println("Filtered list: " + filteredNumbers);
    }
}

Explanation

The original list contains six integers:

List<Integer> numbers = List.of(5, 20, 12, 35, 8, 40);

The following pipeline selects the matching values and collects them:

List<Integer> filteredNumbers = numbers.stream()
        .filter(number -> number >= 20)
        .toList();

Each step has a purpose:

Step Purpose
stream() Creates a sequential stream of the list’s elements
filter(...) Keeps elements that match the condition
toList() Collects the selected elements into a list

Defining the condition

The filter() method accepts a predicate: a function that checks an element and returns true or false.

Here, the predicate is a lambda expression:

number -> number >= 20

When the result is true, the number remains in the stream. When it is false, the number is excluded.

For this input, the matching values are 20, 35, and 40.

Collecting the result

filter() is an intermediate operation. It describes the selection but does not process the elements until a terminal operation runs.

In this example, toList() is the terminal operation:

.toList()

It collects the matching elements into an unmodifiable list. Calling add() or remove() on that result would throw an UnsupportedOperationException.

The result preserves the original list’s encounter order. Filtering does not change the original list.

Run the example

Compile and run the file:

javac FilterListExample.java
java FilterListExample

Output

Original list: [5, 20, 12, 35, 8, 40]
Filtered list: [20, 35, 40]

Combining conditions

Use && to require multiple conditions. For example, this filter keeps numbers that are at least 20 and even:

.filter(number -> number >= 20 && number % 2 == 0)

With the same input, the resulting list is:

[20, 40]

If no elements match the condition, toList() returns an empty list.

How do I calculate a moving average with Stream Gatherers in Java 24?

A moving average smooths out short-term changes in a series of readings. Instead of averaging all the readings once, you average the first few readings, move one position forward, and repeat.

In this example, you’ll calculate an average for every three consecutive temperature readings using Java’s Gatherers.windowSliding().

Stream Gatherers became a standard feature in Java 24, so no preview flags or external libraries are needed. See the Java 24 Gatherers API.

1. Group the readings into overlapping windows

Start with five readings: 18, 21, 24, 27, 23. A window size of three gives you [18, 21, 24] first. The next window drops 18 and adds 27, giving you [21, 24, 27].

The call .gather(Gatherers.windowSliding(3)) turns a stream of individual readings into a stream of these lists.

2. Keep complete windows and calculate each average

If the input has one or two readings, windowSliding(3) produces a single shorter window. The filter() below skips that window so every reported average uses exactly three readings. Empty input produces no windows.

For each remaining list, mapToInt() creates a stream of integers and average() computes the mean. The result is present because every window that reaches this step contains three values.

3. Compile and run the example

Save this file as MovingAverageExample.java:

import java.util.List;
import java.util.Locale;
import java.util.stream.Gatherers;

public class MovingAverageExample {
    public static void main(String[] args) {
        List<Integer> readings = List.of(18, 21, 24, 27, 23);
        int windowSize = 3;

        readings.stream()
                .gather(Gatherers.windowSliding(windowSize))
                .filter(window -> window.size() == windowSize)
                .forEachOrdered(window -> {
                    double average = window.stream()
                            .mapToInt(Integer::intValue)
                            .average()
                            .orElseThrow();

                    System.out.printf(Locale.ROOT, "%s -> %.2f%n",
                            window, average);
                });
    }
}

From the directory containing the file, run:

javac --release 24 MovingAverageExample.java
java MovingAverageExample

Output:

[18, 21, 24] -> 21.00
[21, 24, 27] -> 24.00
[24, 27, 23] -> 24.67

The last window averages 74 / 3. The %.2f format rounds the displayed value to two decimal places; it does not change the stored average.

Best practices

  • Put readings in chronological order before making windows. The gatherer follows the stream’s existing order.
  • Use a positive window size. If it comes from user input, validate it before creating the gatherer.
  • Decide what to do when there are too few readings. This example waits for a full window; if you need early results, define how partial averages should work.
  • A three-reading window counts samples. If your readings arrive at irregular intervals and you need a three-minute average, group them by timestamps instead.

How do I use Java Streams without making my code hard to read?

Using Java Streams readably is mostly about using them where they express intent clearly and avoiding “clever” pipelines that hide business logic.

Good uses of Streams

Streams are great when you are doing simple collection transformations:

List<String> activeUserEmails = users.stream()
        .filter(User::isActive)
        .map(User::getEmail)
        .toList();

This reads almost like a sentence:

From users, keep active ones, get their emails, collect to a list.

Prefer method references when they are obvious

Readable:

List<Long> ids = orders.stream()
        .map(Order::getId)
        .toList();

Less readable:

List<Long> ids = orders.stream()
        .map(order -> order.getId())
        .toList();

Both are valid, but the method reference is simpler here.

However, do not force method references if a lambda is clearer:

List<Order> expensiveOrders = orders.stream()
        .filter(order -> order.total().compareTo(BigDecimal.valueOf(1000)) > 0)
        .toList();

Name complex predicates

If your filter condition gets complicated, extract it.

Hard to read:

List<Customer> customers = customers.stream()
        .filter(customer -> customer.isActive()
                && customer.getBalance().compareTo(BigDecimal.ZERO) > 0
                && customer.getLastOrderDate().isAfter(cutoffDate))
        .toList();

Better:

List<Customer> eligibleCustomers = customers.stream()
        .filter(customer -> isEligible(customer, cutoffDate))
        .toList();

private boolean isEligible(Customer customer, LocalDate cutoffDate) {
    return customer.isActive()
            && customer.getBalance().compareTo(BigDecimal.ZERO) > 0
            && customer.getLastOrderDate().isAfter(cutoffDate);
}

The stream now says what you are doing, and the helper explains how.

Avoid deeply nested streams

This is usually a readability warning sign:

List<String> productNames = orders.stream()
        .flatMap(order -> order.getLineItems().stream()
                .filter(item -> item.getQuantity() > 0)
                .map(item -> item.getProduct().getName()))
        .distinct()
        .sorted()
        .toList();

This is not terrible, but if it grows more complex, extract the inner logic:

List<String> productNames = orders.stream()
        .flatMap(order -> validProductNames(order).stream())
        .distinct()
        .sorted()
        .toList();

private List<String> validProductNames(Order order) {
    return order.getLineItems().stream()
            .filter(item -> item.getQuantity() > 0)
            .map(item -> item.getProduct().getName())
            .toList();
}

Do not use streams for a complicated control flow

Streams are not ideal when you need lots of branching, mutation, logging, exception handling, or early exits.

Less readable:

orders.stream()
        .filter(order -> {
            if (order.isCancelled()) {
                log.info("Skipping cancelled order {}", order.getId());
                return false;
            }

            if (!order.hasValidPayment()) {
                log.warn("Skipping unpaid order {}", order.getId());
                return false;
            }

            return true;
        })
        .forEach(this::ship);

A plain loop may be clearer:

for (Order order : orders) {
    if (order.isCancelled()) {
        log.info("Skipping cancelled order {}", order.getId());
        continue;
    }

    if (!order.hasValidPayment()) {
        log.warn("Skipping unpaid order {}", order.getId());
        continue;
    }

    ship(order);
}

Rule of thumb:

If the stream needs block lambdas with several statements, a loop may be better.

Keep stream operations on separate lines

Prefer this:

List<ProductDto> products = products.stream()
        .filter(Product::isVisible)
        .sorted(Comparator.comparing(Product::getName))
        .map(ProductDto::from)
        .toList();

Avoid cramming everything into one line:

List<ProductDto> products = products.stream().filter(Product::isVisible).sorted(Comparator.comparing(Product::getName)).map(ProductDto::from).toList();

Vertical formatting makes each step visible.

Avoid side effects inside streams

This is usually a bad sign:

List<String> names = new ArrayList<>();

users.stream()
        .filter(User::isActive)
        .forEach(user -> names.add(user.getName()));

Prefer collecting the result directly:

List<String> names = users.stream()
        .filter(User::isActive)
        .map(User::getName)
        .toList();

Side effects inside streams can make code harder to reason about, especially if someone later changes it to parallelStream().

Use collect only when needed

In modern Java, prefer toList() when you just need a list:

List<String> emails = users.stream()
        .map(User::getEmail)
        .toList();

Use Collectors when you need something more specific:

Map<Long, User> usersById = users.stream()
        .collect(Collectors.toMap(User::getId, Function.identity()));

Or grouping:

Map<Department, List<Employee>> employeesByDepartment = employees.stream()
        .collect(Collectors.groupingBy(Employee::getDepartment));

Avoid overly clever collectors

This may be technically impressive but hard to maintain:

Map<Department, Set<String>> namesByDepartment = employees.stream()
        .collect(Collectors.groupingBy(
                Employee::getDepartment,
                Collectors.mapping(
                        Employee::getName,
                        Collectors.toCollection(TreeSet::new)
                )
        ));

This is acceptable if your team is comfortable with collectors. Otherwise, consider extracting it:

Map<Department, Set<String>> namesByDepartment = employees.stream()
        .collect(groupEmployeeNamesByDepartment());

private Collector<Employee, ?, Map<Department, Set<String>>> groupEmployeeNamesByDepartment() {
    return Collectors.groupingBy(
            Employee::getDepartment,
            Collectors.mapping(
                    Employee::getName,
                    Collectors.toCollection(TreeSet::new)
            )
    );
}

Use meaningful variable names

Bad:

List<String> result = list.stream()
        .filter(x -> x.isActive())
        .map(x -> x.getName())
        .toList();

Better:

List<String> activeUserNames = users.stream()
        .filter(User::isActive)
        .map(User::getName)
        .toList();

Readable streams depend heavily on meaningful names.

Be careful with Optional.stream()

This can be elegant:

List<Address> addresses = users.stream()
        .map(User::getAddress)
        .flatMap(Optional::stream)
        .toList();

But if your team is unfamiliar with it, this may be clearer:

List<Address> addresses = users.stream()
        .map(User::getAddress)
        .filter(Optional::isPresent)
        .map(Optional::get)
        .toList();

The first version is more idiomatic; the second may be easier for some teams. Prefer consistency with your codebase.

Use loops when they are clearer

Streams are not inherently better than loops.

Readable stream:

boolean hasExpiredInvoice = invoices.stream()
        .anyMatch(Invoice::isExpired);

Readable loop:

boolean hasExpiredInvoice = false;

for (Invoice invoice : invoices) {
    if (invoice.isExpired()) {
        hasExpiredInvoice = true;
        break;
    }
}

For simple matching, the stream is excellent:

boolean hasExpiredInvoice = invoices.stream()
        .anyMatch(Invoice::isExpired);

But for multistep logic, logging, error handling, or mutation, use a loop.

Practical rules of thumb

Use streams when:

  • You are filtering, mapping, sorting, grouping, or matching.
  • The pipeline has about 2–5 clear steps.
  • Each lambda is short and clear.
  • The result is a transformed collection, map, count, boolean, or optional.

Avoid streams when:

  • You need complex branching.
  • You need many side effects.
  • You need checked exception handling in lambdas.
  • The pipeline becomes deeply nested.
  • The stream is harder to debug than a loop.
  • You are using streams just to avoid writing for.

A good readable stream style

List<OrderSummary> summaries = orders.stream()
        .filter(Order::isCompleted)
        .filter(order -> order.placedAfter(startDate))
        .sorted(Comparator.comparing(Order::getPlacedAt).reversed())
        .map(OrderSummary::from)
        .toList();

This is readable because:

  • Each operation has one job.
  • The order of operations is clear.
  • The variable name explains the result.
  • Lambdas are short.
  • Business logic can be extracted if it grows.

Bottom line

Use Java Streams to make simple data transformations read like a pipeline. If the stream starts needing complex lambdas, nested streams, side effects, or lots of comments to explain it, switch to helper methods or a plain loop. Readability matters more than using Streams everywhere.

How do I use Collectors.filtering() introduced in Java 9?

In Java 9, the Collectors.filtering method was introduced to the Stream API as part of java.util.stream.Collectors. It allows you to apply a filter to elements of a stream before collecting them into a downstream collector (e.g., toList, toSet, etc.).

This can be particularly useful when you want to filter elements as part of the data collection pipeline.


Syntax

static <T, A, R> Collector<T, ?, R> filtering(Predicate<? super T> predicate, Collector<? super T, A, R> downstream)
  • predicate: A filter condition to be applied (e.g., a lambda expression).
  • downstream: The collector that will gather the filtered elements (e.g., Collectors.toList()).

How It Works

  1. The filtering method applies the specified Predicate to filter the elements of the stream.
  2. Only the elements that match the predicate are passed to the downstream collector.
  3. The filtered results are then collected as specified by the downstream collector.

Usage Example

Here’s a basic example of using Collectors.filtering:

Collecting only even integers from a list:

package org.kodejava.util.stream;

import java.util.List;
import java.util.stream.Collectors;

public class FilteringExample {
    public static void main(String[] args) {
        List<Integer> numbers = List.of(1, 2, 3, 4, 5, 6, 7, 8, 9, 10);

        // Apply filtering before collecting to a list
        List<Integer> evenNumbers = numbers.stream()
                .collect(Collectors.filtering(n -> n % 2 == 0, Collectors.toList()));

        System.out.println("Even Numbers: " + evenNumbers);
    }
}

Output:

Even Numbers: [2, 4, 6, 8, 10]

Filtering with Downstream Grouping

You can use filtering in more complex collectors, such as those involving grouping. For example:

Grouping strings by their first character and filtering only strings longer than 3 characters:

package org.kodejava.util.stream;

import java.util.List;
import java.util.Map;
import java.util.stream.Collectors;

public class FilteringWithGrouping {
    public static void main(String[] args) {
        List<String> words = List.of("apple", "ant", "banana", "bat", "cat", "car", "dog");

        // Group by the first character and filter words with length > 3
        Map<Character, List<String>> filteredWordsByGroup = words.stream()
                .collect(Collectors.groupingBy(
                        word -> word.charAt(0), // Grouping by the first character
                        Collectors.filtering(
                                word -> word.length() > 3, // Filter words with length > 3
                                Collectors.toList() // Collect filtered words into a list
                        )
                ));

        System.out.println("Filtered Words: " + filteredWordsByGroup);
    }
}

Output:

Filtered Words: {a=[apple], b=[banana], c=[cat, car], d=[dog]}

When to Use

Collectors.filtering is particularly useful for:

  1. Grouped collections: Applying a filter while grouping elements.
  2. Custom collections: Collecting filtered elements into different collection types without needing an intermediate filtered stream.
  3. Improved readability: Reduces the need for chaining multiple Stream.filter() calls in complex data processing.

Overall, Collectors.filtering makes streams more flexible and concise for advanced data collection scenarios!

How do I use Optional Stream with flatMap?

Using the Optional.stream() method with flatMap is a common scenario when you want to work with collections and operations involving Optional.

The Optional.stream() method converts an Optional value into a Stream, which will either contain the single value (if the Optional is present) or be empty (if the Optional is empty). This is particularly useful in combination with flatMap when working with streams.

Here’s how to use Optional.stream with flatMap in practice:

Example

Here’s an example demonstrating the usage of Optional.stream with flatMap:

package org.kodejava.util.stream;

import java.util.Optional;
import java.util.stream.Stream;

public class OptionalStreamExample {
    public static void main(String[] args) {
        Optional<String> optional1 = Optional.of("Hello");
        Optional<String> optional2 = Optional.of("World");

        // Combine optionals using flatMap and stream
        String result = Stream.of(optional1, optional2)
                .flatMap(Optional::stream)
                .reduce((s1, s2) -> s1 + " " + s2)
                .orElse("No Value");

        System.out.println(result); // Output: Hello World
    }
}

Explanation of the Code:

  1. Stream of Optionals:
    • Start with a Stream containing Optional objects (in this case, optional1 and optional2).
  2. FlatMap with Optional.stream:
    • Use flatMap(Optional::stream) to convert each Optional into a stream:
      • If the Optional contains a value, it will be represented as a Stream with a single element.
      • If the Optional is empty, it results in an empty Stream.
  3. Reduce the Result:
    • Use the reduce method on the resulting stream to combine the values.
    • In the example, s1 + " " + s2 concatenates the non-empty values together.
    • If the result is absent after combining, it defaults to "No Value" using orElse.

Why Use Optional.stream with flatMap?

  • Stream-Friendly Operations: It allows you to continue working seamlessly in the stream pipeline even if the values are wrapped in Optional.
  • Handling Empty Optionals: Automatically avoids null pointer exceptions or manual checks for empty Optional values.
  • Code Simplicity: Reduces boilerplate code by directly transforming Optional into a stream.

Another Example: Filtering and Transforming

Here’s another example where we filter and transform Optional values:

package org.kodejava.util.stream;

import java.util.Optional;
import java.util.stream.Stream;

public class OptionalStreamFilter {
    public static void main(String[] args) {
        Optional<Integer> optional1 = Optional.of(10);
        Optional<Integer> optional2 = Optional.of(20);

        // Sum values greater than 15
        int sum = Stream.of(optional1, optional2)
                .flatMap(Optional::stream)
                .filter(val -> val > 15)
                .mapToInt(Integer::intValue)
                .sum();

        System.out.println("Sum: " + sum); // Output: Sum: 20
    }
}

Key Points:

  • Optional.stream bridges the gap between Optional and Stream APIs.
  • Common use cases include combining multiple Optional values, filtering, transforming, or reducing them in a stream flow.