Java Stream API Examples: Practical Use Cases

Introduction to Java Stream API

The Java Stream API, introduced in Java 8, provides a powerful way to process sequences of elements, such as collections, in a functional style. It allows developers to write concise and readable code for operations such as filtering, mapping, and reducing data. In this article, we will present three practical examples of Java Stream API that demonstrate its capabilities in real-world scenarios.

Example 1: Filtering and Collecting Unique Names

Context

In many applications, you may need to filter a list of names to collect only unique entries. This example demonstrates how to use the Stream API to achieve this efficiently.

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

public class UniqueNamesExample {
    public static void main(String[] args) {
        List<String> names = Arrays.asList(
            "Alice",
            "Bob",
            "Charlie",
            "Alice",
            "David",
            "Bob"
        );

        Set<String> uniqueNames = names.stream()\n            .distinct()
            .collect(Collectors.toSet());

        System.out.println(uniqueNames);
    }
}

Notes

• The distinct() method removes duplicate elements from the stream.
• The result is collected into a Set, which inherently maintains uniqueness.

Example 2: Calculating the Average Age

Context

In applications that manage user data, calculating average values is a common requirement. This example uses the Stream API to calculate the average age of users from a list.

import java.util.Arrays;
import java.util.List;

public class AverageAgeExample {
    static class User {
        String name;
        int age;

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

    public static void main(String[] args) {
        List<User> users = Arrays.asList(
            new User("Alice", 30),
            new User("Bob", 25),
            new User("Charlie", 35)
        );

        double averageAge = users.stream()
            .mapToInt(user -> user.age)
            .average()
            .orElse(0);

        System.out.println("Average Age: " + averageAge);
    }
}

Notes

• The mapToInt() method converts the stream of User objects to an IntStream containing their ages.
• The average() method computes the average age, returning an OptionalDouble which is handled with orElse(0) to provide a default value of 0 if there are no users.

Example 3: Grouping Data by a Property

Context

When working with collections, grouping data based on certain properties is often necessary for analytics. This example demonstrates how to group users by their age using the Stream API.

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

public class GroupByAgeExample {
    static class User {
        String name;
        int age;

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

    public static void main(String[] args) {
        List<User> users = Arrays.asList(
            new User("Alice", 30),
            new User("Bob", 25),
            new User("Charlie", 30),
            new User("David", 25)
        );

        Map<Integer, List<User>> usersByAge = users.stream()
            .collect(Collectors.groupingBy(user -> user.age));

        usersByAge.forEach((age, userList) -> {
            System.out.println("Age: " + age + " -> Users: " + userList);
        });
    }
}

Notes

• The groupingBy() method creates a Map where each key is an age, and the value is a list of users of that age.
• The output can be easily iterated to display grouped results, allowing for straightforward data analysis.