Для чего нужен метод collect в Stream API?

# Для чего нужен метод collect в Stream API?

Метод collect() в Stream API — это terminal operation (терминальная операция), которая преобразует результаты потока в новую структуру данных. Это один из самых мощных и часто используемых методов в Stream API.

Определение

collect() — это метод, который:

• Завершает stream обработку (terminal operation)
• Аккумулирует элементы потока в результирующую структуру
• Применяет Collector для трансформации элементов
• Возвращает финальный результат (не Stream)

Сигнатура метода

// Базовая форма
<R> R collect(Collector<? super T, A, R> collector);

// Полная форма (используется редко)
<R> R collect(
    Supplier<R> supplier,
    BiConsumer<R, ? super T> accumulator,
    BiConsumer<R, R> combiner
);

Основные применения

1. Преобразование в List

// Самое частое использование
List<String> names = users.stream()
    .map(User::getName)
    .collect(Collectors.toList());

// Или неизменяемый список
List<String> immutableNames = users.stream()
    .map(User::getName)
    .collect(Collectors.toUnmodifiableList());

2. Преобразование в Set

// Удаление дубликатов
Set<String> uniqueEmails = users.stream()
    .map(User::getEmail)
    .collect(Collectors.toSet());

// Неизменяемый Set
Set<String> immutableEmails = users.stream()
    .map(User::getEmail)
    .collect(Collectors.toUnmodifiableSet());

3. Преобразование в Map

// Создание Map по ID
Map<Long, User> usersById = users.stream()
    .collect(Collectors.toMap(
        User::getId,      // key function
        Function.identity() // value function
    ));

// Map с вычисляемым значением
Map<String, Integer> emailToAge = users.stream()
    .collect(Collectors.toMap(
        User::getEmail,
        User::getAge
    ));

// Map с разрешением дубликатов
Map<String, User> usersByName = users.stream()
    .collect(Collectors.toMap(
        User::getName,
        Function.identity(),
        (existing, replacement) -> existing  // keep first
    ));

4. Группировка элементов (groupingBy)

// Группировка по возрасту
Map<Integer, List<User>> usersByAge = users.stream()
    .collect(Collectors.groupingBy(User::getAge));
// Результат: {25: [User1, User3], 30: [User2, User4]}

// Группировка с подсчетом
Map<String, Long> countByDepartment = users.stream()
    .collect(Collectors.groupingBy(
        User::getDepartment,
        Collectors.counting()
    ));
// {"IT": 5, "HR": 3, "Finance": 2}

// Вложенная группировка
Map<String, Map<Integer, List<User>>> usersByDeptAndAge = users.stream()
    .collect(Collectors.groupingBy(
        User::getDepartment,
        Collectors.groupingBy(User::getAge)
    ));

5. Разбиение элементов (partitioningBy)

// Разделение на две группы по условию
Map<Boolean, List<User>> seniors = users.stream()
    .collect(Collectors.partitioningBy(
        user -> user.getAge() >= 65
    ));
// {true: [senior_users], false: [junior_users]}

// С дополнительным collector
Map<Boolean, Long> countByAge = users.stream()
    .collect(Collectors.partitioningBy(
        user -> user.getAge() >= 65,
        Collectors.counting()
    ));
// {true: 2, false: 8}

6. Подсчет и статистика

// Подсчет элементов
long count = users.stream()
    .collect(Collectors.counting());

// Минимум/максимум
Optional<User> oldest = users.stream()
    .collect(Collectors.maxBy(
        Comparator.comparingInt(User::getAge)
    ));

// Суммирование
int totalAge = users.stream()
    .collect(Collectors.summingInt(User::getAge));

// Среднее значение
Double averageAge = users.stream()
    .collect(Collectors.averagingInt(User::getAge));

// Статистика
IntSummaryStatistics stats = users.stream()
    .collect(Collectors.summarizingInt(User::getAge));
// count, sum, min, max, average

7. Объединение строк (joining)

// Простое объединение
String names = users.stream()
    .map(User::getName)
    .collect(Collectors.joining(", "));
// "John, Jane, Bob"

// С префиксом и суффиксом
String csv = users.stream()
    .map(User::getName)
    .collect(Collectors.joining(
        ",",        // delimiter
        "[Name]: ",  // prefix
        ""           // suffix
    ));
// "[Name]: John,Jane,Bob"

8. Mapping и filtering в collect

// Трансформация при сборке
List<String> userEmails = users.stream()
    .collect(Collectors.mapping(
        User::getEmail,
        Collectors.toList()
    ));

// Фильтрация при сборке
Map<String, Long> deptCounts = users.stream()
    .collect(Collectors.groupingBy(
        User::getDepartment,
        Collectors.filtering(
            user -> user.getAge() > 25,  // filter
            Collectors.counting()
        )
    ));

Поток данных: от Stream к Result

Входные данные (List<User>):
[User1(id=1, name="John", age=25),
 User2(id=2, name="Jane", age=30),
 User3(id=3, name="Bob", age=25)]
        ↓
   Stream operations:
   .filter(), .map(), etc.
        ↓
   .collect(Collectors.toList())
   TERMINAL OPERATION
        ↓
Вывод (List<String>):
["John", "Jane", "Bob"]

Полная форма collect() с Supplier, Accumulator, Combiner

// Создание кастомного результата
List<String> names = users.stream()
    .collect(
        // 1. Supplier: создает пустой контейнер
        ArrayList::new,
        
        // 2. Accumulator: добавляет элемент в контейнер
        (list, user) -> list.add(user.getName()),
        
        // 3. Combiner: объединяет результаты (параллельный поток)
        (list1, list2) -> list1.addAll(list2)
    );

Это эквивалентно:

List<String> names = users.stream()
    .map(User::getName)
    .collect(Collectors.toList());

Пример: Сложный collect() запрос

public class StreamCollectExample {
    
    static class User {
        Long id;
        String name;
        String department;
        Integer age;
        Double salary;
        
        // constructor, getters
    }
    
    public static void main(String[] args) {
        List<User> users = Arrays.asList(
            new User(1L, "Alice", "IT", 28, 5000.0),
            new User(2L, "Bob", "HR", 32, 4000.0),
            new User(3L, "Charlie", "IT", 26, 4500.0),
            new User(4L, "Diana", "Finance", 35, 6000.0),
            new User(5L, "Eve", "IT", 29, 5500.0)
        );
        
        // 1. Групповая статистика по отделам
        Map<String, DoubleSummaryStatistics> salaryByDept = users.stream()
            .collect(Collectors.groupingBy(
                User::getDepartment,
                Collectors.summarizingDouble(User::getSalary)
            ));
        
        System.out.println("Salary stats by dept:");
        salaryByDept.forEach((dept, stats) ->
            System.out.printf("%s: avg=%.2f, sum=%.2f, count=%d%n",
                dept, stats.getAverage(), stats.getSum(), stats.getCount())
        );
        // IT: avg=5000.00, sum=15000.00, count=3
        // HR: avg=4000.00, sum=4000.00, count=1
        // Finance: avg=6000.00, sum=6000.00, count=1
        
        // 2. Имена по отделам
        Map<String, List<String>> namesByDept = users.stream()
            .collect(Collectors.groupingBy(
                User::getDepartment,
                Collectors.mapping(
                    User::getName,
                    Collectors.toList()
                )
            ));
        
        System.out.println("\nNames by dept:");
        namesByDept.forEach((dept, names) ->
            System.out.println(dept + ": " + names)
        );
        // IT: [Alice, Charlie, Eve]
        // HR: [Bob]
        // Finance: [Diana]
        
        // 3. Разбиение по возрасту (молодежь и старики)
        Map<Boolean, List<String>> byAge = users.stream()
            .collect(Collectors.partitioningBy(
                user -> user.age < 30,
                Collectors.mapping(
                    User::getName,
                    Collectors.toList()
                )
            ));
        
        System.out.println("\nYoung (< 30): " + byAge.get(true));
        System.out.println("Senior (>= 30): " + byAge.get(false));
        // Young (< 30): [Alice, Charlie]
        // Senior (>= 30): [Bob, Diana, Eve]
    }
}

Различие между обычными операциями и collect()

// БЕЗ collect() - промежуточные операции
Stream<String> names = users.stream()
    .map(User::getName);
// Результат: Stream (ленивый, не выполняется)

// С collect() - терминальная операция
List<String> names = users.stream()
    .map(User::getName)
    .collect(Collectors.toList());
// Результат: List (выполнено, готово к использованию)

Performance: collect() и параллельные потоки

// Последовательный поток
List<String> sequential = users.stream()
    .collect(Collectors.toList());

// Параллельный поток
List<String> parallel = users.parallelStream()
    .collect(Collectors.toList());
// Combiner автоматически объединяет результаты разных потоков

Best Practices

1. Выбирай правильный Collector

// ✅ Хорошо
List<String> names = users.stream()
    .map(User::getName)
    .collect(Collectors.toList());

// ❌ Плохо (ненужная компликация)
List<String> names = users.stream()
    .map(User::getName)
    .collect(Collectors.toCollection(ArrayList::new));

2. Используй неизменяемые структуры где возможно

// ✅ Лучше (неизменяемый список)
List<String> names = users.stream()
    .map(User::getName)
    .collect(Collectors.toUnmodifiableList());

// Если нужно изменять
List<String> mutable = users.stream()
    .map(User::getName)
    .collect(Collectors.toCollection(ArrayList::new));

3. Комбинируй collect с filter и map

// ✅ Правильный порядок
List<String> seniorNames = users.stream()
    .filter(user -> user.age >= 30)  // filter первым
    .map(User::getName)              // потом map
    .collect(Collectors.toList());   // потом collect

// ❌ Менее эффективно (filter в collector)
List<String> names = users.stream()
    .collect(Collectors.filtering(
        user -> user.age >= 30,
        Collectors.mapping(
            User::getName,
            Collectors.toList()
        )
    ));

4. Обработка Optional в collect

// Фильтрация Optional значений
List<String> emails = users.stream()
    .map(User::getOptionalEmail)      // Optional<String>
    .flatMap(Optional::stream)        // Stream<String>
    .collect(Collectors.toList());

Заключение

Метод collect() нужен для:

1. Преобразования Stream в структуры данных (List, Set, Map)
2. Группировки и агрегирования данных (groupingBy, partitioningBy)
3. Статистики и подсчета (counting, summingInt, averaging)
4. Трансформации и фильтрации во время сборки
5. Создания финального результата из потока

Это terminal operation, которая завершает обработку stream и возвращает конкретный результат, готовый к использованию.