Что такое терминальные операции в Stream API?

Терминальные операции в Stream API

Терминальная операция (Terminal Operation) — это операция в Java Stream API, которая завершает обработку потока данных и возвращает конечный результат. После выполнения терминальной операции поток закрывается и больше не может использоваться. Это отличает её от промежуточных операций (intermediate operations), которые возвращают новый поток для дальнейшей обработки.

Основные концепции

Характеристики терминальных операций:

• Завершение потока — закрывает поток после выполнения
• Возврат конечного результата — не возвращает Stream
• Инициация вычислений — запускает ленивые вычисления промежуточных операций
• Одиночное использование — есть одна на конце цепочки
• Различные типы результатов — могут возвращать значение, объект или void

Категории терминальных операций

1. Операции сбора данных (Collection)

import java.util.*;
import java.util.stream.Stream;
import java.util.stream.Collectors;

public class CollectionTerminalOperations {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        
        // collect() - собрать элементы в коллекцию
        List<Integer> doubled = numbers.stream()
            .map(n -> n * 2)
            .collect(Collectors.toList());
        System.out.println("Удвоенные: " + doubled); // [2, 4, 6, 8, 10]
        
        // toArray() - преобразовать в массив
        Object[] array = numbers.stream()
            .filter(n -> n > 2)
            .toArray();
        System.out.println("Массив: " + Arrays.toString(array));
        
        // Collect в Set
        Set<Integer> uniqueNumbers = numbers.stream()
            .collect(Collectors.toSet());
        System.out.println("Набор: " + uniqueNumbers);
        
        // Collect в Map
        Map<Integer, String> map = numbers.stream()
            .limit(3)
            .collect(Collectors.toMap(
                n -> n,
                n -> "Число " + n
            ));
        System.out.println("Карта: " + map);
    }
}

2. Операции поиска и проверки

import java.util.*;
import java.util.stream.Stream;

public class SearchTerminalOperations {
    public static void main(String[] args) {
        List<String> words = Arrays.asList("Java", "Stream", "API", "Processing");
        
        // findFirst() - найти первый элемент
        Optional<String> first = words.stream()
            .filter(w -> w.length() > 3)
            .findFirst();
        System.out.println("Первое слово > 3 букв: " + 
            first.orElse("Не найдено"));
        
        // findAny() - найти любой элемент (в параллельных потоках предпочтительнее)
        Optional<String> any = words.stream()
            .filter(w -> w.startsWith("S"))
            .findAny();
        System.out.println("Какое-то слово с S: " + 
            any.orElse("Не найдено"));
        
        // anyMatch() - проверить, есть ли элемент, соответствующий условию
        boolean hasLongWord = words.stream()
            .anyMatch(w -> w.length() > 5);
        System.out.println("Есть слово > 5 букв: " + hasLongWord);
        
        // allMatch() - проверить, все ли элементы соответствуют условию
        boolean allLongerThanTwo = words.stream()
            .allMatch(w -> w.length() > 2);
        System.out.println("Все слова > 2 букв: " + allLongerThanTwo);
        
        // noneMatch() - проверить, что ни один элемент не соответствует условию
        boolean noDigits = words.stream()
            .noneMatch(w -> w.matches(".*\\d.*"));
        System.out.println("Без цифр: " + noDigits);
    }
}

3. Операции редукции

import java.util.*;
import java.util.stream.Stream;

public class ReductionTerminalOperations {
    public static void main(String[] args) {
        List<Integer> numbers = Arrays.asList(1, 2, 3, 4, 5);
        
        // reduce() - свернуть поток в одно значение
        Optional<Integer> sum = numbers.stream()
            .reduce((a, b) -> a + b); // a=1, b=2, затем a=3, b=3 и т.д.
        System.out.println("Сумма: " + sum.orElse(0)); // 15
        
        // reduce() с начальным значением
        Integer product = numbers.stream()
            .reduce(1, (a, b) -> a * b); // 1 * 1 * 2 * 3 * 4 * 5 = 120
        System.out.println("Произведение: " + product);
        
        // max() - найти максимальный элемент
        Optional<Integer> max = numbers.stream()
            .max(Integer::compare);
        System.out.println("Максимум: " + max.orElse(null));
        
        // min() - найти минимальный элемент
        Optional<Integer> min = numbers.stream()
            .min(Integer::compare);
        System.out.println("Минимум: " + min.orElse(null));
        
        // count() - подсчитать количество элементов
        long count = numbers.stream()
            .filter(n -> n > 2)
            .count();
        System.out.println("Элементов > 2: " + count);
    }
}

4. Операции перебора

import java.util.*;

public class IterationTerminalOperations {
    public static void main(String[] args) {
        List<String> fruits = Arrays.asList("Яблоко", "Груша", "Апельсин");
        
        // forEach() - выполнить операцию для каждого элемента
        System.out.println("Фрукты:");
        fruits.stream()
            .forEach(fruit -> System.out.println("  - " + fruit));
        
        // forEachOrdered() - гарантирует порядок обработки
        System.out.println("\nОтсортированные фрукты:");
        fruits.parallelStream()
            .sorted()
            .forEachOrdered(fruit -> System.out.println("  - " + fruit));
    }
}

5. Специализированные операции для чисел

import java.util.*;
import java.util.stream.IntStream;

public class NumericTerminalOperations {
    public static void main(String[] args) {
        // Использование IntStream для примитивных int
        IntStream numbers = IntStream.rangeClosed(1, 5);
        
        // sum() - сумма всех элементов
        int sum = numbers.sum();
        System.out.println("Сумма 1-5: " + sum); // 15
        
        // average() - среднее арифметическое
        double avg = IntStream.rangeClosed(1, 5)
            .average()
            .orElse(0.0);
        System.out.println("Среднее: " + avg); // 3.0
        
        // summaryStatistics() - статистика по всем элементам
        var stats = IntStream.rangeClosed(1, 5)
            .summaryStatistics();
        System.out.println("Минимум: " + stats.getMin());
        System.out.println("Максимум: " + stats.getMax());
        System.out.println("Среднее: " + stats.getAverage());
        System.out.println("Сумма: " + stats.getSum());
        System.out.println("Количество: " + stats.getCount());
    }
}

6. Сложный пример с несколькими операциями

import java.util.*;
import java.util.stream.Collectors;

public class ComplexStreamExample {
    
    static class Person {
        String name;
        int age;
        
        Person(String name, int age) {
            this.name = name;
            this.age = age;
        }
        
        @Override
        public String toString() {
            return name + " (" + age + ")";
        }
    }
    
    public static void main(String[] args) {
        List<Person> people = Arrays.asList(
            new Person("Иван", 25),
            new Person("Мария", 30),
            new Person("Петр", 35),
            new Person("Анна", 28)
        );
        
        // Комплексная обработка с терминальной операцией
        Map<String, List<Person>> groupedByAgeRange = people.stream()
            .collect(Collectors.groupingBy(person -> 
                person.age < 30 ? "До 30" : "От 30"
            ));
        
        System.out.println("Группировка по возрасту:");
        groupedByAgeRange.forEach((range, persons) -> {
            System.out.println(range + ": " + persons);
        });
        
        // Статистика по возрасту
        double averageAge = people.stream()
            .mapToInt(p -> p.age)
            .average()
            .orElse(0.0);
        System.out.println("\nСредний возраст: " + averageAge);
        
        // Самый старший человек
        Optional<Person> eldest = people.stream()
            .max(Comparator.comparing(p -> p.age));
        System.out.println("Самый старший: " + 
            eldest.map(p -> p.name).orElse("Нет данных"));
    }
}

Таблица основных терминальных операций

Когда использовать терминальные операции

• Получение результата — когда нужен конечный результат
• Сторонний эффект — когда нужно что-то сделать с каждым элементом
• Проверки — логические проверки наличия элементов
• Статистика — подсчёты и агрегирование
• Сохранение — сохранение результата в коллекцию

Терминальные операции — необходимая часть Stream API для получения конечных результатов обработки данных.