Java Stream API: Complete Guide with Examples. Practical Tasks

Run a single line: Arrays.asList(new int[]{1, 2, 3}).size(). You expect 3, you get 1. The compiler says nothing, your test fails, and half an hour disappears into a bug that is not where you are looking. That is exercise 4 on this page — and Stream API and Optional have a few more corners like it.

This page collects nine hands-on exercises on Java Stream API, Optional and Collectors: from a plain filter → map → collect pipeline to grouping with downstream collectors and Optional chains that contain no if at all. The exercises get harder as you go, so work through them in order — each one builds on techniques from the previous ones. Write your own code first, then compare it with the expected output printed in the comments.

What to review before you start

Every exercise maps to a specific lesson in the module. If a task statement feels unclear, go back to the theory instead of reaching for a ready-made answer.

1. Basic pipeline: filter, map, collect

You are given a list of movie titles. Build a new list that contains only the titles longer than 10 characters, converted to upper case. The original list must stay untouched. Solve it with a single pipeline — no for loops and no intermediate variables.

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

public class Task1 {
    public static void main(String[] args) {
        List<String> movies = List.of(
                "Interstellar", "The Mist", "Inception",
                "Schindler's List", "Django", "The Shawshank Redemption");

        List<String> result = /* your code */;

        System.out.println(result);
        // Expected output:
        // [INTERSTELLAR, SCHINDLER'S LIST, THE SHAWSHANK REDEMPTION]
    }
}

Going further: sort the result by title length in descending order without introducing another collection.

2. Infinite streams and limit

Streams do not have to come from collections. Write two methods, each returning a List<Long> built from an infinite source that is cut off by limit():

1. powersOfTwo(int n) — the first n powers of two, starting at 1 (that is, 2⁰).
2. fibonacci(int n) — the first n Fibonacci numbers, starting with 0 and 1.

For the second method you will need the "two-element state" trick: the value flowing through the stream is a pair of neighbouring numbers, and only the first of them is exposed to the caller.

import java.util.List;
import java.util.stream.Stream;

public class Task2 {

    public static List<Long> powersOfTwo(int n) {
        return Stream.iterate(1L, /* your code */)
                .limit(n)
                /* your code */;
    }

    public static List<Long> fibonacci(int n) {
        return Stream.iterate(new long[]{0, 1}, pair -> new long[]{/* your code */})
                /* your code */;
    }

    public static void main(String[] args) {
        System.out.println(powersOfTwo(5)); // [1, 2, 4, 8, 16]
        System.out.println(fibonacci(10));  // [0, 1, 1, 2, 3, 5, 8, 13, 21, 34]
    }
}

Think before you run: what happens if you remove limit() from fibonacci? Answer first, then check.

3. Terminal operations: reduce, min, max

This exercise has two parts.

1. Use reduce() to compute the product of all numbers in a list. For an empty list the result must be 1.
2. Find the longest and the shortest word in a list using max() and min() with a Comparator. Both methods return an Optional — work out why, and handle the empty case explicitly.

import java.util.Comparator;
import java.util.List;

public class Task3 {

    public static int product(List<Integer> numbers) {
        return /* your code: reduce */;
    }

    public static String longest(List<String> words) {
        return /* your code: max + Comparator, empty list -> "" */;
    }

    public static String shortest(List<String> words) {
        return /* your code: min + Comparator, empty list -> "" */;
    }

    public static void main(String[] args) {
        System.out.println(product(List.of(2, 3, 4)));   // 24
        System.out.println(product(List.of()));          // 1
        System.out.println(longest(List.of("cat", "elephant", "ox")));  // elephant
        System.out.println(shortest(List.of("cat", "elephant", "ox"))); // ox
    }
}

4. Array to list and back

Implement four conversions and test one widespread misconception along the way:

1. int[] → List<Integer>;
2. int[] → ArrayList<Integer> explicitly, so that the list is guaranteed to be mutable — add an element to it and confirm that nothing is thrown;
3. List<Integer> → int[];
4. print the size of Arrays.asList(numbers), where numbers is an int[], and explain the number you get.

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

public class Task4 {
    public static void main(String[] args) {
        int[] numbers = {5, 3, 9, 1};

        List<Integer> list = /* your code */;
        ArrayList<Integer> arrayList = /* your code */;
        arrayList.add(42);
        int[] back = /* your code */;

        System.out.println(list);                  // [5, 3, 9, 1]
        System.out.println(arrayList);             // [5, 3, 9, 1, 42]
        System.out.println(Arrays.toString(back)); // [5, 3, 9, 1]

        System.out.println(Arrays.asList(numbers).size()); // what prints here?
    }
}

5. Grouping with Collectors.groupingBy

You are given a list of employees (a record Employee with name, department and salary). Write two methods:

1. countByDepartment — a Map<String, Long> with the number of employees per department (groupingBy + counting());
2. averageSalaryByDepartment — a Map<String, Double> with the average salary per department (groupingBy + averagingDouble()).

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

public class Task5 {

    record Employee(String name, String department, double salary) { }

    public static Map<String, Long> countByDepartment(List<Employee> employees) {
        return /* your code */;
    }

    public static Map<String, Double> averageSalaryByDepartment(List<Employee> employees) {
        return /* your code */;
    }

    public static void main(String[] args) {
        List<Employee> employees = List.of(
                new Employee("Anna", "IT", 3000),
                new Employee("Brian", "IT", 5000),
                new Employee("Clara", "HR", 2000),
                new Employee("Daniel", "HR", 2500),
                new Employee("Emma", "Sales", 4000));

        System.out.println(countByDepartment(employees));
        // {HR=2, IT=2, Sales=1}
        System.out.println(averageSalaryByDepartment(employees));
        // {HR=2250.0, IT=4000.0, Sales=4000.0}
    }
}

Going further: return the result as a TreeMap with departments in alphabetical order. Hint: groupingBy has an overload that accepts a map factory.

6. Splitting into two groups: partitioningBy

You are given a list of exam results. Split the students into those who passed (a score of 60 or above) and those who did not, using Collectors.partitioningBy. Then print the size of each group without opening a second stream just to count.

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

public class Task6 {

    record Result(String student, int score) { }

    public static void main(String[] args) {
        List<Result> results = List.of(
                new Result("Anna", 91),
                new Result("Brian", 45),
                new Result("Clara", 60),
                new Result("Daniel", 59));

        Map<Boolean, List<Result>> byPassed = /* your code */;
        Map<Boolean, Long> counts = /* your code: partitioningBy + counting */;

        System.out.println(byPassed.get(true));  // [Result[student=Anna, score=91], Result[student=Clara, score=60]]
        System.out.println(byPassed.get(false)); // [Result[student=Brian, score=45], Result[student=Daniel, score=59]]
        System.out.println(counts);              // {false=2, true=2}
    }
}

Think it through: how does partitioningBy differ from groupingBy(r -> r.score() >= 60)? Test your answer on an empty list — the difference shows up immediately.

7. Building a string with Collectors.joining

Turn a list of products into one string: items separated by a comma and a space, the whole thing wrapped in square brackets. Normalise each name to "first letter capital" form and drop names that are empty or blank.

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

public class Task7 {

    public static String format(List<String> products) {
        return products.stream()
                /* your code: drop blanks, normalise the case */
                .collect(Collectors.joining(/* delimiter, prefix, suffix */));
    }

    public static void main(String[] args) {
        System.out.println(format(List.of("apple", "  ", "banana", "CHERRY", "")));
        // [Apple, Banana, Cherry]
        System.out.println(format(List.of()));
        // []
    }
}

8. Optional instead of null in a lookup

You have a user store backed by a Map<Long, User>. Write a method findById(long id) that returns an Optional<User> and never returns null. On top of it, implement two calling styles:

1. getOrThrow(long id) — throws your own UserNotFoundException via orElseThrow();
2. getOrGuest(long id) — returns a guest user via orElseGet(), and the placeholder object must be created only when the user is genuinely missing.

import java.util.Map;
import java.util.Optional;

public class Task8 {

    record User(long id, String name) { }

    static class UserNotFoundException extends RuntimeException {
        UserNotFoundException(long id) {
            super("User not found: id=" + id);
        }
    }

    private static final Map<Long, User> USERS = Map.of(
            1L, new User(1, "Anna"),
            2L, new User(2, "Brian"));

    public static Optional<User> findById(long id) {
        return /* your code */;
    }

    public static User getOrThrow(long id) {
        return /* your code: orElseThrow */;
    }

    public static User getOrGuest(long id) {
        return /* your code: orElseGet */;
    }

    public static void main(String[] args) {
        System.out.println(findById(1));     // Optional[User[id=1, name=Anna]]
        System.out.println(findById(99));    // Optional.empty
        System.out.println(getOrGuest(99));  // User[id=-1, name=Guest]
        System.out.println(getOrThrow(99));  // UserNotFoundException
    }
}

9. An Optional chain with no null checks

The method receives a string that may be null. Return the length of the string if it is neither null nor blank, and 0 otherwise. if statements and the ternary operator are banned: build a chain of Optional.ofNullable → filter → map → orElse.

The second part is an experiment. Implement lengthOrElse and lengthOrElseGet, where the default value comes from a method with a side effect (a console print), and run both on a non-empty string. Count how many times the message appears in each case and explain the result.

import java.util.Optional;

public class Task9 {

    public static int length(String text) {
        return Optional.ofNullable(text)
                /* your code: filter + map */
                .orElse(0);
    }

    static int expensiveDefault() {
        System.out.println("Computing the default value...");
        return 0;
    }

    public static int lengthOrElse(String text) {
        return Optional.ofNullable(text).map(String::length).orElse(expensiveDefault());
    }

    public static int lengthOrElseGet(String text) {
        return Optional.ofNullable(text).map(String::length).orElseGet(Task9::expensiveDefault);
    }

    public static void main(String[] args) {
        System.out.println(length("Java"));  // 4
        System.out.println(length("   "));   // 0
        System.out.println(length(null));    // 0

        lengthOrElse("Java");     // how many lines are printed?
        lengthOrElseGet("Java");  // and here?
    }
}

Check yourself before looking up solutions

Walk through this list before you go looking for an answer key. If any point makes you hesitate, go back to the matching exercise.

1. Does all of your code compile and print exactly the output stated in the comments?
2. Are there any for loops or if (x != null) checks left where the task asked for a pipeline or an Optional chain?
3. Can you explain out loud why max() and min() return an Optional while count() does not?
4. Is it clear why Arrays.asList(new int[]{...}) has size 1, and how to get a list of four elements instead?
5. Can you name the difference between orElse and orElseGet on the spot, with an example where the choice affects performance?