Coder Legion - Recent posts tagged java8

How to Filter a Collection Using Streams in Java?

Mon, 09 Jun 2025 03:19:12 +0000

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.

Mastering Lambda Expressions, Functional Interfaces, and Streams in Java 8 and Beyond

Thu, 08 May 2025 06:18:17 +0000

Java 8 revolutionized how developers write and think about Java code by introducing functional programming concepts. At the heart of this transformation are Lambda Expressions, Functional Interfaces, and the Streams API. These features together promote a more expressive, concise, and readable way to write code that is powerful, efficient, and scalable.

In this comprehensive article, we will dive deep into each of these features, understand the underlying theory, and then walk through practical examples with detailed, line-by-line explanations.

1. Introduction to Functional Programming in Java

Before Java 8, Java was strictly an object-oriented programming language. Functional programming concepts like passing behavior (not just data) as arguments were difficult and verbose. Java 8 brought in a hybrid model, enabling functional programming through lambdas and streams while retaining OOP principles.

What is Functional Programming?

Functional programming is a paradigm where functions are treated as first-class citizens. It encourages writing pure functions, immutability, and declarative constructs to process data.

Key concepts include:

Functions can be passed as arguments
No side effects
Lazy evaluation
Higher-order functions

Java's adoption of functional programming features made the language more expressive and concise, especially for data manipulation and collection processing.

2. Lambda Expressions in Java

What is a Lambda Expression?

A Lambda Expression is an anonymous function that can be passed around as data. It provides a clear and concise way to represent a method interface using an expression.

Syntax:

(parameters) -> expression
(parameters) -> { statements }

Characteristics:

No name (anonymous)
Can be assigned to a variable
Implements a functional interface
Enables cleaner and more expressive code

Why Use Lambda Expressions?

Simplifies writing anonymous inner classes
Makes code more readable and concise
Enables functional-style operations on collections

Example:

Runnable r = () -> System.out.println("Running a thread");
r.run();

Traditional vs Lambda:

// Traditional Runnable
Runnable r1 = new Runnable() {
    public void run() {
        System.out.println("Hello from thread");
    }
};
r1.run();

// Lambda Runnable
Runnable r2 = () -> System.out.println("Hello from lambda");
r2.run();

Common Lambda Use Cases:

Event handling
Threading
Collection iteration
Stream operations

3. Functional Interfaces

What is a Functional Interface?

A Functional Interface is an interface with exactly one abstract method. It can have default or static methods, but only one method must be abstract.

Examples in Java:

@FunctionalInterface
interface Calculator {
    int operation(int a, int b);
}

Functional Interface Characteristics:

Annotated with @FunctionalInterface (not mandatory but recommended)
Target type for lambda expressions
Defined in java.util.function package for standard use cases

Common Built-in Functional Interfaces:

Interface	Abstract Method	Description
Predicate	test(T t)	Returns true/false
Consumer	accept(T t)	Consumes input, no return
Function	apply(T t)	Converts T to R
Supplier	get()	Supplies a result
BiFunction	apply(T,U)	Takes two args, returns one

Example with Lambda:

Function<String, Integer> lengthFunc = s -> s.length();
System.out.println(lengthFunc.apply("Lambda")); // Output: 6

4. Streams API

What is a Stream?

A Stream is a pipeline of elements from a data source (e.g., collections) that supports aggregate operations such as filter, map, reduce, collect, etc.

Stream Characteristics:

Doesn’t store data, just processes it
Lazy evaluation
Can be sequential or parallel
Doesn’t modify the source

Stream Pipeline Structure:

Source: e.g., List, Set, Map
Intermediate Operations: e.g., filter, map, sorted
Terminal Operation: e.g., collect, count, forEach

Common Operations:

filter(Predicate)
map(Function)
sorted(Comparator)
limit(long)
collect(Collectors)

5. Practical Example with Explanation

Let’s analyze this common example:

List<String> names = Arrays.asList("John", "Alice", "Bob");

List<String> filtered =
    names.stream()
         .filter(name -> name.startsWith("A"))
         .map(String::toUpperCase)
         .collect(Collectors.toList());

System.out.println(filtered); // [ALICE]

Line-by-Line Breakdown:

Line 1:

List<String> names = Arrays.asList("John", "Alice", "Bob");

Creates a List of String with three names.
Arrays.asList() creates a fixed-size list backed by an array.

Line 3:

names.stream()

Converts the list into a Stream.
No data is processed yet (lazy initialization).

Line 4:

.filter(name -> name.startsWith("A"))

Intermediate operation.
Filters elements where the name starts with "A".
Result: Stream.of("Alice")

Line 5:

.map(String::toUpperCase)

Maps the name "Alice" to its uppercase form.
Result: Stream.of("ALICE")

Line 6:

.collect(Collectors.toList());

Terminal operation.
Converts the stream into a List<String> containing one element: ["ALICE"]

Line 8:

System.out.println(filtered);

Prints the final result: [ALICE]

6. Real-World Use Cases of Lambdas, Functional Interfaces, and Streams

1. Filtering and transforming user data

List<User> users = ...
List<String> emails = users.stream()
    .filter(user -> user.isActive())
    .map(User::getEmail)
    .collect(Collectors.toList());

2. Logging and event handling

button.setOnClickListener(event -> System.out.println("Clicked!"));

3. Sorting with Comparator and Lambdas

Collections.sort(users, (u1, u2) -> u1.getName().compareTo(u2.getName()));

7. Best Practices

Keep lambdas short and expressive
Use method references when possible (String::toUpperCase)
Avoid side-effects in stream pipelines
Use parallel streams only when beneficial (e.g., large datasets)
Chain operations for readability and maintainability

8. Conclusion

Lambda expressions, functional interfaces, and the Stream API are cornerstones of modern Java programming. They enable a declarative, functional, and clean way to process data and compose logic.

By mastering these constructs, Java developers can write code that is more concise, expressive, thread-safe, and easier to test and maintain.

If you haven’t already started integrating these into your projects, now is the time to evolve your Java style into the functional future.

Originally published at Medium.