How to Filter a Collection Using Streams in Java?

Java 8 introduced the Stream API, which allows for functional-style operations on collections. One of the most common use cases is filtering a collection based on certain conditions. In this article, we’ll explore how to filter a collection using streams in Java, covering the basics, advanced techniques, and best practices.

What are Java Streams?

Java streams are a sequence of elements supporting parallel and functional-style operations. They’re designed to work with collections, allowing you to process data in a declarative way. Streams don’t store data; instead, they provide a pipeline for processing data.

To understand Java streams, let’s consider an analogy. Imagine you’re at a coffee shop, and you want to order a coffee. You don’t need to know how the coffee is made; you simply tell the barista what you want. In a similar way, when working with Java streams, you specify what you want to do with your data, and the Stream API takes care of the details.

Creating a Stream

To filter a collection using streams, you first need to create a stream from the collection. You can do this using the stream() method, which is available on most collection classes, such as List, Set, and Map.

List<String> colors = Arrays.asList("Red", "Green", "Blue", "Yellow");
Stream<String> colorStream = colors.stream();

Filtering a Collection Using Streams

To filter a collection, you need to apply the filter() method to the stream. The filter() method takes a predicate, which is a function that returns a boolean value indicating whether an element should be included in the filtered results.

Let’s dive into an example. Suppose we have a list of Person objects and want to filter out those who are under 18 years old.

// Define the Person class
class Person {
    private String name;
    private int age;

    public Person(String name, int age) {
        this.name = name;
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public int getAge() {
        return age;
    }

    @Override
    public String toString() {
        return "Person{" +
                "name='" + name + '\'' +
                ", age=" + age +
                '}';
    }
}

public class Main {
    public static void main(String[] args) {
        // Create a list of Person objects
        List<Person> people = Arrays.asList(
                new Person("John", 25),
                new Person("Alice", 17),
                new Person("Bob", 30),
                new Person("Charlie", 15)
        );

        // Filter the list using streams
        List<Person> adults = people.stream()
                .filter(person -> person.getAge() >= 18)
                .collect(Collectors.toList());

        // Print the filtered list
        adults.forEach(System.out::println);
    }
}

In this example:

We create a stream from the people list using the stream() method.
We apply the filter() method to specify the condition person.getAge() >= 18.
We collect the filtered results into a new list adults using collect(Collectors.toList()).

The output will be:

Person{name='John', age=25}
Person{name='Bob', age=30}

Using Multiple Conditions

You can chain multiple filter() operations to apply multiple conditions. For instance, to filter people who are both adults and have a name starting with “J” or “B”:

List<Person> filteredPeople = people.stream()
        .filter(person -> person.getAge() >= 18)
        .filter(person -> person.getName().startsWith("J") || person.getName().startsWith("B"))
        .collect(Collectors.toList());

Alternatively, you can combine the conditions using logical operators within a single filter():

List<Person> filteredPeople = people.stream()
        .filter(person -> person.getAge() >= 18 && 
                (person.getName().startsWith("J") || person.getName().startsWith("B")))
        .collect(Collectors.toList());

Filtering with Complex Conditions

For more complex conditions, you can define a separate method that takes a Person object and returns a boolean indicating whether the condition is met.

private static boolean isValidPerson(Person person) {
    // Complex condition logic here
    return person.getAge() >= 18 && person.getName().length() > 3;
}

public static void main(String[] args) {
    // ...
    List<Person> validPeople = people.stream()
            .filter(Main::isValidPerson)
            .collect(Collectors.toList());
    // ...
}

Benefits of Using Streams for Filtering

Declarative Code: Streams allow you to specify what you want to do with your data, rather than how to do it. This leads to more concise and readable code.
Lazy Evaluation: Streams are lazily evaluated, meaning that the filtering operation is only executed when the results are actually needed. This can improve performance.
Parallelization: Streams can be easily parallelized, making it simple to take advantage of multi-core processors.

Best Practices

Use Meaningful Variable Names: Choose variable names that clearly indicate the purpose of the stream or the filtered collection.
Keep Lambda Expressions Concise: If a lambda expression is too complex, consider breaking it out into a separate method.
Profile Your Code: While streams can be efficient, they may not always be the best choice for every situation. Profile your code to ensure that using streams is beneficial for your specific use case.
Avoid Unnecessary Operations: Be mindful of unnecessary operations, such as filtering a collection multiple times. Instead, combine conditions into a single filter() operation.

Common Use Cases

Data Processing Pipelines: Streams are well-suited for data processing pipelines, where data needs to be filtered, transformed, and aggregated.
Data Validation: You can use streams to validate data, such as checking if a collection contains valid or invalid elements.
Data Aggregation: Streams can be used to aggregate data, such as calculating the sum or average of a collection of numbers.

Advanced Techniques

Using Predicate Objects: Instead of using lambda expressions, you can create Predicate objects to represent complex conditions.
Combining Predicate Objects: You can combine Predicate objects using logical operators to create more complex conditions.
Using Stream Methods: The Stream API provides various methods for processing data, such as map(), reduce(), and collect().

Example Use Cases

Filtering a List of Strings: You can use streams to filter a list of strings based on certain conditions, such as length or prefix.
Filtering a List of Objects: You can use streams to filter a list of objects based on certain conditions, such as age or name.

Real-World Applications

Data Analysis: Streams can be used in data analysis to filter and process large datasets.
Machine Learning: Streams can be used in machine learning to preprocess data and filter out irrelevant features.
Web Development: Streams can be used in web development to filter and process data from databases or APIs.

By mastering Java streams and filtering techniques, you can write more efficient, readable, and maintainable code. Whether you’re working with data analysis, machine learning, or web development, Java streams can help you process data with ease.

Conclusion

Java streams provide a powerful and flexible way to filter collections. By using streams, you can write more concise and readable code, and take advantage of parallelization and lazy evaluation. By following best practices and using advanced techniques, you can master Java streams and improve your coding skills.