როგორ მუშაობთ Kotlin- ში ნაკადებთან (streams)?

კოტლინში მონაცემთა ნაკადებთან (Java 8 Streams API-ის ანალოგი) მუშაობისთვის გამოიყენება გაფართოების ფუნქციები კოლექციებისთვის, რომლებიც მიწოდებულია სტანდარტული ფუნქციათა ბიბლიოთეკით. ეს არ არის ცალკე API, არამედ მეთოდების ნაკრები 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
საპასუხისმგებლოობა	არაპირდაპირი სასპანსოობა შუალედურ ოპერაციებზე, მაგრამ ტერმინალური ოპერაცია მთლიანად აგრძელებს ჯაჭვს	პირდაპირი სასპანსოობა: ოპერაციები შესრულდება ელემენტზე ელემენტზე საჭიროების მიხედვით
ეფექტურობა	შეიძლება იყოს ნაკლებეფექტიანი დიდი კოლექციებისთვის და გრძელი ოპერაციების ჯაჭვების გამო	უფრო ეფექტიანი დიდი კოლექციებისთვის და გრძელი ჯაჭვების ოპერაციებისათვის
გამოყენება	შესაფერისია მცირე და საშუალო კოლექციებისთვის	შესაფერისია დიდი კოლექციებისთვის ან ოპერაციებისათვის, რომლებიც შეიძლება ადრე შეჩერდეს (take, find, first, any, all, none)

სტანდარტული ფუნქციების გამოყენება კოლექციებზე ხშირად საკმარისია და უფრო მოკლეა. Sequences რეკომენდებულია, როდესაც საჭიროა გამოხატული სასპანსოობა ოპტიმიზაციისთვის დიდი მონაცემების სამუშაოსას।