В чем разница между List и Sequence?

Разница между List и Sequence в Kotlin

List — Eager (Нетерпеливая) коллекция

List — это коллекция, которая вычисляет все элементы сразу при создании и хранит их в памяти.

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

• Все операции выполняются немедленно
• Результаты сохраняются в памяти
• Доступ по индексу O(1)
• Возможна итерация несколько раз

val list = listOf(1, 2, 3, 4, 5)
    .filter { it > 2 }      // Вычисляется сразу
    .map { it * 2 }         // Вычисляется сразу
    // [6, 8, 10]

Sequence — Lazy (Ленивая) коллекция

Sequence — это коллекция, которая вычисляет элементы по требованию (на лету), один за другим.

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

• Операции выполняются отложенно (lazy)
• Элементы не сохраняются в промежуточных коллекциях
• Обработка от элемента к элементу
• Нельзя обращаться по индексу

val sequence = sequenceOf(1, 2, 3, 4, 5)
    .filter { it > 2 }      // Не выполняется
    .map { it * 2 }         // Не выполняется
    .toList()               // Теперь выполняются!
    // [6, 8, 10]

Пример работы

// List — eager
val list = listOf(1, 2, 3, 4, 5)
val result = list
    .filter { println("filter: $it"); it > 2 }
    .map { println("map: $it"); it * 2 }

Сравнение

List вычисляет все элементы сразу:

• filter: 1, 2, 3, 4, 5
• map: 3, 4, 5

Sequence вычисляет по требованию:

• filter: 1 (нет), 2 (нет), 3 (да) → map: 3
• filter: 4 (да) → map: 4
• filter: 5 (да) → map: 5

Когда использовать?

List если:

• Маленькая коллекция (< 100 элементов)
• Нужен доступ по индексу
• Будете итерировать несколько раз
• Нужна максимальная скорость

Sequence если:

• Большая коллекция
• Много операций фильтрации и преобразования
• Нужна лишь часть результата
• Важна экономия памяти и процессорного времени

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

// List — обрабатывает всё
val bigList = (1..1_000_000).toList()
    .filter { it % 2 == 0 }  // Проверяет 500k элементов
    .map { it * 2 }          // Преобразует 500k
    .take(10)                // Берёт только 10!

// Sequence — обрабатывает нужное
val bigSequence = (1..1_000_000).asSequence()
    .filter { it % 2 == 0 }  // Проверяет до 20
    .map { it * 2 }          // Преобразует до 10
    .take(10)                // Останавливается после 10

Sequence значительно эффективнее для больших данных и цепочек операций.