Stream API в Java: обработка данных с примерами. Практические Задания

Запустите одну строку: Arrays.asList(new int[]{1, 2, 3}).size(). Ожидаете 3, а получаете 1. Компилятор молчит, тест падает, и полчаса уходит на поиски того, чего нет. Это задание №4 на этой странице — и таких мест в Stream API и Optional хватает.

Здесь собраны девять практических заданий по Java Stream API, Optional и Collectors: от простого пайплайна filter → map → collect до группировки с downstream-коллекторами и цепочек Optional без единого if. Задания идут по нарастающей сложности, поэтому выполняйте их по порядку: каждое следующее опирается на приёмы предыдущих. Сначала пишите код сами, и только потом сверяйтесь с разбором.

Что повторить перед началом

Каждое задание опирается на конкретный урок модуля. Если условие кажется непонятным — вернитесь к соответствующей теории, а не подглядывайте сразу в решение.

Уроки про Optional и Collectors выходят в ближайшее время — ссылки уже ведут на будущие адреса, добавьте их в закладки.

1. Базовый пайплайн: filter, map, collect

Дан список названий фильмов. Соберите новый список, в который попадут только названия длиннее 10 символов, приведённые к верхнему регистру. Исходный список изменять нельзя. Решите задачу одним пайплайном, без циклов for и без промежуточных переменных.

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

public class Task1 {
    public static void main(String[] args) {
        List<String> movies = List.of(
                "Интерстеллар", "Мгла", "Начало",
                "Список Шиндлера", "Джанго", "Побег из Шоушенка");

        List<String> result = /* ваш код */;

        System.out.println(result);
        // Ожидаемый вывод:
        // [ИНТЕРСТЕЛЛАР, СПИСОК ШИНДЛЕРА, ПОБЕГ ИЗ ШОУШЕНКА]
    }
}

Усложнение: отсортируйте результат по длине названия по убыванию, не добавляя новых промежуточных коллекций.

2. Бесконечный поток и limit

Потоки бывают не только из коллекций. Напишите два метода, каждый из которых возвращает List<Long>, построенный на бесконечном источнике, ограниченном limit():

1. powersOfTwo(int n) — первые n степеней двойки, начиная с 1 (то есть 2⁰).
2. fibonacci(int n) — первые n чисел Фибоначчи, начиная с 0 и 1.

Для второго метода пригодится приём с «состоянием из двух элементов»: в качестве значения потока используется пара соседних чисел, а наружу отдаётся только первое из них.

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

public class Task2 {

    public static List<Long> powersOfTwo(int n) {
        return Stream.iterate(1L, /* ваш код */)
                .limit(n)
                /* ваш код */;
    }

    public static List<Long> fibonacci(int n) {
        return Stream.iterate(new long[]{0, 1}, pair -> new long[]{/* ваш код */})
                /* ваш код */;
    }

    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]
    }
}

Вопрос на понимание: что произойдёт, если в fibonacci убрать limit()? Ответьте до запуска, потом проверьте.

3. Терминальные операции: reduce, min, max

Задание из двух частей.

1. Методом reduce() посчитайте произведение всех чисел списка. Для пустого списка результат должен быть 1.
2. Найдите самое длинное и самое короткое слово в списке, используя max() и min() с Comparator. Оба метода возвращают Optional — разберитесь, почему, и обработайте пустой случай явно.

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

public class Task3 {

    public static int product(List<Integer> numbers) {
        return /* ваш код: reduce */;
    }

    public static String longest(List<String> words) {
        return /* ваш код: max + Comparator, пустой список -> "" */;
    }

    public static String shortest(List<String> words) {
        return /* ваш код: min + Comparator, пустой список -> "" */;
    }

    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("кот", "собака", "як")));  // собака
        System.out.println(shortest(List.of("кот", "собака", "як"))); // як
    }
}

4. Массив в список и обратно

Реализуйте четыре преобразования и проверьте одно распространённое заблуждение:

1. int[] → List<Integer>;
2. int[] → ArrayList<Integer> явно (чтобы список гарантированно был изменяемым — добавьте в него элемент и убедитесь, что исключения нет);
3. List<Integer> → int[];
4. выведите размер Arrays.asList(numbers), где numbers — это int[], и объясните полученное число.

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 = /* ваш код */;
        ArrayList<Integer> arrayList = /* ваш код */;
        arrayList.add(42);
        int[] back = /* ваш код */;

        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()); // сколько здесь будет?
    }
}

5. Группировка через Collectors.groupingBy

Дан список сотрудников (запись Employee с полями name, department, salary). Напишите два метода:

1. countByDepartment — Map<String, Long>: сколько сотрудников в каждом отделе (groupingBy + counting());
2. averageSalaryByDepartment — Map<String, Double>: средняя зарплата по отделу (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 /* ваш код */;
    }

    public static Map<String, Double> averageSalaryByDepartment(List<Employee> employees) {
        return /* ваш код */;
    }

    public static void main(String[] args) {
        List<Employee> employees = List.of(
                new Employee("Анна", "IT", 3000),
                new Employee("Борис", "IT", 5000),
                new Employee("Вера", "HR", 2000),
                new Employee("Глеб", "HR", 2500),
                new Employee("Дина", "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}
    }
}

Усложнение: сделайте так, чтобы результат возвращался в виде TreeMap с отделами по алфавиту. Подсказка: у groupingBy есть перегрузка с фабрикой map.

6. Разделение на две группы: partitioningBy

Дан список результатов экзамена. Разделите студентов на сдавших (балл 60 и выше) и не сдавших, используя Collectors.partitioningBy. Затем выведите количество в каждой группе, не создавая отдельного потока для подсчёта.

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("Анна", 91),
                new Result("Борис", 45),
                new Result("Вера", 60),
                new Result("Глеб", 59));

        Map<Boolean, List<Result>> byPassed = /* ваш код */;
        Map<Boolean, Long> counts = /* ваш код: partitioningBy + counting */;

        System.out.println(byPassed.get(true));  // [Result[student=Анна, score=91], Result[student=Вера, score=60]]
        System.out.println(byPassed.get(false)); // [Result[student=Борис, score=45], Result[student=Глеб, score=59]]
        System.out.println(counts);              // {false=2, true=2}
    }
}

Вопрос на понимание: чем partitioningBy отличается от groupingBy(r -> r.score() >= 60)? Ответ проверьте на пустом списке — разница будет видна сразу.

7. Сборка строки через Collectors.joining

Соберите из списка товаров одну строку: элементы через запятую с пробелом, вся строка в квадратных скобках. Названия приведите к формату «первая буква заглавная», пустые и пробельные названия отбросьте.

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

public class Task7 {

    public static String format(List<String> products) {
        return products.stream()
                /* ваш код: отбросить пустые, нормализовать регистр */
                .collect(Collectors.joining(/* разделитель, префикс, суффикс */));
    }

    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 вместо null при поиске

Есть хранилище пользователей на основе Map<Long, User>. Напишите метод findById(long id), который возвращает Optional<User> и никогда не возвращает null. На его основе реализуйте два сценария вызова:

1. getOrThrow(long id) — бросает собственное исключение UserNotFoundException через orElseThrow();
2. getOrGuest(long id) — возвращает «гостевого» пользователя через orElseGet(), причём объект-заглушка должен создаваться только тогда, когда пользователь действительно не найден.

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("Пользователь не найден: id=" + id);
        }
    }

    private static final Map<Long, User> USERS = Map.of(
            1L, new User(1, "Анна"),
            2L, new User(2, "Борис"));

    public static Optional<User> findById(long id) {
        return /* ваш код */;
    }

    public static User getOrThrow(long id) {
        return /* ваш код: orElseThrow */;
    }

    public static User getOrGuest(long id) {
        return /* ваш код: orElseGet */;
    }

    public static void main(String[] args) {
        System.out.println(findById(1)); // Optional[User[id=1, name=Анна]]
        System.out.println(findById(99)); // Optional.empty
        System.out.println(getOrGuest(99)); // User[id=-1, name=Гость]
        System.out.println(getOrThrow(99)); // UserNotFoundException
    }
}

9. Цепочка Optional без проверок на null

Метод получает строку, которая может быть null. Нужно вернуть длину строки, если она не null и не состоит из одних пробелов, иначе — 0. Запрещено использовать if и тернарный оператор: соберите цепочку Optional.ofNullable → filter → map → orElse.

Вторая часть — эксперимент. Реализуйте lengthOrElse и lengthOrElseGet, где значение по умолчанию вычисляется методом с побочным эффектом (печатью в консоль), и запустите оба варианта на непустой строке. Посчитайте, сколько раз напечатается сообщение в каждом случае, и объясните результат.

import java.util.Optional;

public class Task9 {

    public static int length(String text) {
        return Optional.ofNullable(text)
                /* ваш код: filter + map */
                .orElse(0);
    }

    static int expensiveDefault() {
        System.out.println("Считаем значение по умолчанию...");
        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");     // сколько строк напечатается?
        lengthOrElseGet("Java");  // а здесь?
    }
}

Проверьте себя перед тем как смотреть решения

Пройдитесь по списку до того, как открывать разбор. Если хотя бы один пункт вызывает сомнение — вернитесь к соответствующему заданию.

1. Весь ли ваш код компилируется и выдаёт ровно тот вывод, который указан в комментариях к заданиям?
2. Остались ли где-то циклы for или проверки if (x != null) там, где условие требовало пайплайна или цепочки Optional?
3. Можете ли вы объяснить вслух, почему max() и min() возвращают Optional, а count() — нет?
4. Понятно ли, почему Arrays.asList(new int[]{...}) даёт размер 1, и как получить список из четырёх элементов?
5. Сможете ли вы сходу назвать разницу между orElse и orElseGet и привести пример, где выбор влияет на производительность?