PricingLoginStart free
Kotlin Academy · Pelajaran

Operator Flow: map, filter, transform, dan take

Terapkan operator perantara untuk mengubah dan membatasi emisi Flow.

Pelajaran 1 dari 413 langkah

Operator Flow: map, filter, transform, dan take adalah pelajaran Kotlin Academy gratis di CoddyKit. Ini adalah pelajaran 1 dari 4. Kamu bisa membaca pelajaran lengkapnya di bawah secara gratis — lalu praktikkan langsung di browser dengan editor kode bawaan dan tutor AI 24/7. Ini adalah bagian dari jalur belajar Kotlin Academy, dan progresmu tersinkronisasi di web dan aplikasi CoddyKit. Kursus Kotlin Academy mencakup 4 pelajaran total.

Apa Itu Aliran?

Flow adalah aliran asinkron yang dingin. Operator perantara seperti map, filter, dan transform bersifat malas—operator tersebut hanya dijalankan saat aliran dikumpulkan.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun numbers(): Flow<Int> = flow {
    repeat(5) { emit(it + 1) }
}
fun main() = runBlocking {
    numbers().collect { println(it) }
}

Operator Pemetaan

map mengubah setiap nilai yang dipancarkan. Ini adalah transformasi satu-ke-satu yang diterapkan secara malas.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    (1..5).asFlow()
        .map { it * it }
        .collect { println(it) } // 1 4 9 16 25
}

Operator Penyaringan

filter hanya meneruskan elemen yang sesuai dengan predikat dan membuang sisanya.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    (1..10).asFlow()
        .filter { it % 2 == 0 }
        .collect { println(it) } // 2 4 6 8 10
}

Operator Transformasi

transform adalah operator paling umum: Anda dapat memancarkan nol, satu, atau banyak nilai untuk setiap elemen masukan.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    (1..3).asFlow()
        .transform { n ->
            emit("Item $n")
            emit("Done $n")
        }
        .collect { println(it) }
}

Operator Pengambilan

take(n) hanya mengambil n elemen pertama lalu membatalkan aliran sumber setelahnya.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    flow {
        repeat(100) { emit(it) }
    }.take(3)
     .collect { println(it) } // 0 1 2
}

Pengambilan Selama dan Pembuangan Selama

takeWhile mengambil elemen selama predikat bernilai benar; dropWhile membuang elemen sampai predikat bernilai salah.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    (1..10).asFlow()
        .takeWhile { it < 5 }
        .collect { println(it) } // 1 2 3 4

    (1..10).asFlow()
        .dropWhile { it < 5 }
        .collect { println(it) } // 5 6 7 8 9 10
}

Merangkai Operator

Operator dapat dikomposisikan: setiap operator mengembalikan Flow baru, sehingga memungkinkan alur deklaratif.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    (1..20).asFlow()
        .filter { it % 3 == 0 }
        .map { it * 2 }
        .take(4)
        .collect { println(it) } // 6 12 18 24
}

mapNotNull

mapNotNull memetakan hasil dan membuang hasil null dalam satu langkah—setara dengan map + filter { it != null }.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    flowOf("1", "two", "3", "four", "5")
        .mapNotNull { it.toIntOrNull() }
        .collect { println(it) } // 1 3 5
}

flatMapConcat

flatMapConcat memetakan setiap elemen menjadi aliran lalu menggabungkan hasilnya secara berurutan.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    (1..3).asFlow()
        .flatMapConcat { n -> flowOf("$n-a", "$n-b") }
        .collect { println(it) }
}

onEach untuk Efek Samping

onEach melakukan efek samping pada setiap elemen tanpa mengubah aliran—cocok untuk pencatatan atau analitik dalam alur.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    (1..5).asFlow()
        .onEach { println("Processing: $it") }
        .filter { it % 2 == 0 }
        .collect { println("Collected: $it") }
}

Aliran Bersifat Dingin

Setiap pemanggilan collect memulai ulang aliran dari awal. Tidak ada elemen yang dipancarkan atau diubah sampai operator akhir memicu pengumpulan.

import kotlinx.coroutines.*
import kotlinx.coroutines.flow.*
fun main() = runBlocking {
    val flow = (1..3).asFlow().map { println("map $it"); it * 2 }
    println("Before collect")
    flow.collect { println("got $it") }
    println("Second collect:")
    flow.collect { println("got $it") }  // runs again
}

Pemeriksaan Singkat

Operator mana yang memancarkan nol, satu, atau banyak nilai untuk setiap elemen dari aliran sumber?

Jawab di pelajaran interaktif

Ringkasan

pemetaan mengubah nilai secara satu-ke-satu; penyaringan membuang elemen; transformasi memancarkan jumlah berapa pun; pengambilan membatasi jumlah. Rangkai semuanya secara deklaratif—aliran bersifat dingin dan hanya berjalan saat dikumpulkan.

Gratis untuk memulai

Belajar Kotlin dengan tutor AI — gratis

Tulis dan jalankan kode asli di browser kamu, dapatkan bantuan instan dari tutor AI 24/7, dan lanjutkan di mana kamu tinggalkan di web atau aplikasi.

Kursus
51
Pelajaran
203
Mulai belajar gratisLihat kursus lengkapnya

Pertanyaan yang Sering Diajukan

Apakah pelajaran “Operator Flow: map, filter, transform, dan take” gratis?

Ya — teks lengkap “Operator Flow: map, filter, transform, dan take” gratis dibaca di sini di web. Untuk praktiknya secara interaktif (editor kode bawaan dan tutor AI 24/7) dan buka sisa kursus Kotlin Academy, upgrade ke CoddyKit PRO. Kursus Kotlin Academy mencakup 4 pelajaran total.

Apa yang akan aku pelajari di “Operator Flow: map, filter, transform, dan take”?

Terapkan operator perantara untuk mengubah dan membatasi emisi Flow. Kamu berlatih Kotlin Academy dengan kode praktik yang langsung kamu jalankan di browser, dan tutor AI 24/7 menjawab pertanyaanmu saat kamu mengerjakan pelajaran ini.

Apakah aku perlu pengalaman untuk memulai Kotlin Academy?

Tidak diperlukan pengalaman sebelumnya. Kotlin Academy di CoddyKit dirancang untuk pemula hingga pelajar tingkat lanjut, jadi kamu bisa memulai di sini atau dari awal dan belajar sesuai kecepatan kamu sendiri. Ini adalah pelajaran 1 dari 4.

Berapa lama pelajaran “Operator Flow: map, filter, transform, dan take” memakan waktu?

Sebagian besar pelajaran CoddyKit memakan waktu sekitar 5–10 menit. Setiap pelajaran ringkas dan interaktif, jadi kamu membuat kemajuan stabil dan melanjutkan dari tempat kamu tinggalkan di web dan aplikasi.

Bisakah aku menulis dan menjalankan kode dalam pelajaran Kotlin Academy ini?

Ya. Setiap pelajaran Kotlin Academy menyertakan editor kode bawaan, jadi kamu menulis dan menjalankan kode nyata langsung di browser dan mendapatkan umpan balik AI instan — tidak diperlukan penyiapan lokal.

Semua pelajaran dalam kursus ini

  1. Operator Flow: map, filter, transform, dan take
  2. catch dan onCompletion: Penanganan Error dalam Flow
  3. combine dan zip: Menggabungkan Beberapa Flow
  4. flowOn dan buffer: Context dan Backpressure
← Kembali ke Kotlin Academy