В чем разница между вариантами преобразования stream в List?

# Разница между вариантами преобразования Stream в List

Основные способы

В Java есть несколько способов преобразовать Stream в List. Каждый имеет свои особенности:

1. collect(Collectors.toList())

List<Integer> list = stream.collect(Collectors.toList());

Характеристики:

• Возвращает изменяемый список (ArrayList по умолчанию)
• Можно добавлять/удалять элементы
• Позволяет null значения
• Самый универсальный способ

List<String> names = Stream.of("Alice", "Bob")
    .collect(Collectors.toList());
names.add("Charlie"); // OK, изменяемый список

2. collect(Collectors.toUnmodifiableList()) (Java 10+)

List<Integer> list = stream.collect(Collectors.toUnmodifiableList());

Характеристики:

• Возвращает неизменяемый список
• Попытка добавить/удалить элемент вызывает UnsupportedOperationException
• Не допускает null значения
• Оптимизирован по памяти
• Потокобезопасен

List<String> names = Stream.of("Alice", "Bob")
    .collect(Collectors.toUnmodifiableList());
names.add("Charlie"); // ❌ UnsupportedOperationException

3. List.copyOf() (Java 10+)

List<Integer> list = List.copyOf(stream.collect(Collectors.toList()));

Характеристики:

• Создаёт неизменяемую копию
• Не допускает null значения
• Удобен для уже имеющихся коллекций
• Требует промежуточного toList()

List<String> names = List.copyOf(
    Stream.of("Alice", "Bob")
        .collect(Collectors.toList())
);

4. stream.toList() (Java 16+, рекомендуется)

List<Integer> list = stream.toList();

Характеристики:

• Самый удобный и современный способ
• Возвращает неизменяемый список
• Не допускает null значения
• Более эффективен чем toUnmodifiableList()
• Разработан специально для Stream API

List<String> names = Stream.of("Alice", "Bob").toList();
// ✅ Ясная, лаконичная запись

5. collect(Collectors.toCollection(ArrayList::new))

List<Integer> list = stream.collect(
    Collectors.toCollection(ArrayList::new)
);

Характеристики:

• Контролируемый выбор реализации List
• Всегда возвращает изменяемый список
• Позволяет использовать другие реализации (LinkedList и т.д.)

List<String> names = Stream.of("Alice", "Bob")
    .collect(Collectors.toCollection(LinkedList::new));

6. stream.toArray() + Arrays.asList()

List<Integer> list = Arrays.asList(
    stream.toArray(Integer[]::new)
);

Характеристики:

• Старый подход (до Java 10)
• Arrays.asList возвращает фиксированный размер списка, привязанный к массиву
• Нельзя добавлять/удалять элементы
• Можно изменять существующие элементы

Integer[] arr = {1, 2, 3};
List<Integer> list = Arrays.asList(arr);
list.add(4); // ❌ UnsupportedOperationException
list.set(0, 10); // ✅ OK, изменяет массив
arr[0]; // 10

Сравнительная таблица

Практические примеры

public class StreamToListExample {
    public static void main(String[] args) {
        // ✅ Правильно — Java 16+
        List<Integer> numbers = Stream.of(1, 2, 3)
            .filter(n -> n > 1)
            .toList(); // Неизменяемый, безопасный

        // ✅ Альтернатива для Java 10-15
        List<Integer> numbers2 = Stream.of(1, 2, 3)
            .filter(n -> n > 1)
            .collect(Collectors.toUnmodifiableList());

        // ✅ Если нужен изменяемый список
        List<Integer> numbers3 = Stream.of(1, 2, 3)
            .filter(n -> n > 1)
            .collect(Collectors.toList());
        numbers3.add(4); // OK

        // ❌ Не используй в новом коде
        // List<Integer> numbers4 = Arrays.asList(
        //     stream.toArray(Integer[]::new));
    }
}

Ключевые выводы

1. Java 16+: используй stream.toList() — это новый стандарт
2. Java 10-15: используй toUnmodifiableList() если нужна неизменяемость
3. Изменяемый список: используй Collectors.toList()
4. Специальная реализация: используй toCollection(LinkedList::new) и т.д.
5. Избегай: Arrays.asList() с потоками — это старый подход
6. Null: помни, что неизменяемые методы не допускают null

Почему это важно

• Неизменяемые списки безопаснее в многопоточности
• Правильный выбор влияет на производительность
• Разные методы предназначены для разных сценариев
• Java эволюционирует, новые методы лучше документированы и оптимизированы