Как работать с потоками (streams) в Kotlin?

В Kotlin для работы с потоками данных (аналог Java 8 Streams API) используются функции-расширения для коллекций, предоставляемые библиотекой стандартных функций. Это не отдельный API, а набор методовTransform kotlin.collections.

Основные операции с потоками делятся на:

• Промежуточные (Intermediate operations): Возвращают новую коллекцию и являются "ленивыми" (выполняются только при вызове терминальной операции). Примеры: filter, map, flatMap, distinct, sorted, take, drop.
• Терминальные (Terminal operations): Завершают последовательность операций и возвращают результат (не коллекцию). Триггерют выполнение всех промежуточных операций. Примеры: forEach, reduce, fold, count, sum, average, min, max, toList, toSet, toMap.

Также существует концепция последовательных потоков (sequences), которая обеспечивает явную ленивость. Sequences обрабатывают элементы по одному по мере необходимости, что может быть более эффективным для больших коллекций или длинных цепочек операций:

• Создание последовательности: collection.asSequence()
• Преобразование обратно в коллекцию: sequence.toList()

// Пример использования стандартных функций для потоковой обработки
fun processCollection() {
    val numbers = listOf(1, 2, 3, 4, 5, 6, 7, 8, 9, 10)

    val evenSquares = numbers
        .filter { it % 2 == 0 } // Промежуточная операция: фильтруем четные числа
        .map { it * it }     // Промежуточная операция: возводим в квадрат

    println(evenSquares) // Терминальная операция: выводим коллекцию (выполняет фильтрацию и map)

    val sumOfOdd = numbers
        .filter { it % 2 != 0 } // Промежуточная
        .sum()                // Терминальная (вычисляет сумму нечетных)

    println(sumOfOdd)
}

// Пример использования последовательностей
fun processSequence() {
    val largeCollection = (1..1_000_000).toList()

    // С коллекциями (не лениво): filter и map выполнятся для всех элементов сразу
    val resultCollection = largeCollection
        .filter { it % 2 == 0 }
        .map { it * 2 }
        .take(10) // take(10) выполняется после фильтрации и map для всех

    println("Result Collection size: ${resultCollection.size}")

    // С последовательностями (лениво): filter, map и take выполняются поэлементно
    val resultSequence = largeCollection.asSequence()
        .filter { it % 2 == 0 } // filter выполняется для каждого элемента по очереди
        .map { it * 2 }     // map выполняется для каждого прошедшего фильтр элемента
        .take(10)         // take(10) останавливает обработку после 10 элементов

    println("Result Sequence size: ${resultSequence.toList().size}") // toList() триггерит выполнение последовательности
}

fun main() {
    processCollection()
    processSequence()
}

Таблица сравнения стандартных функций и sequences в отношении ленивости:

Использование стандартных функций на коллекциях чаще всего достаточно и более лаконично. Sequences рекомендуются, когда нужна явная ленивость для оптимизации производительности при работе с большими объемами данных.