Как да работите с потоци (streams) в Kotlin?

В Kotlin за работа с потоци от данни (аналог Java 8 Streams API) се използват разширителни функции за колекции, предоставени от стандартната библиотека. Това не е отделен API, а набор от методи от kotlin.collections.

Основните операции с потоци са разделени на:

• Промеждни (Intermediate) операции: Връщат нова колекция и са "мързеливи" (изпълняват се само при извикване на терминална операция). Примери: filter, map, flatMap, distinct, sorted, take, drop.
• Терминални (Terminal) операции: Завършват последователността от операции и връщат резултат (не колекция). Тригерират изпълнението на всички междинни операции. Примери: 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
Ленивост	Неявна ленивост за междинните операции, но терминалната операция обработва цялата верига	Явна ленивост: операциите се изпълняват по един елемент при необходимост
Ефективност	Може да бъде по-малко ефективна за големи колекции и дълги вериги поради междинните колекции	По-ефективна за големи колекции и дълги вериги от операции
Приложение	Подходяща за малки и средни колекции	Подходяща за големи колекции или операции, които могат да бъдат прекъснати рано (take, find, first, any, all, none)

Използването на стандартните функции върху колекции е по-често достатъчно и по-кратко. Sequences се препоръчват, когато е необходима явна ленивост за оптимизация на производителността при работа с големи обеми данни.