Kotlin Academy · Lekcja

filter, map i find dla kolekcji

Zastosuj lambdy do przekształcania i filtrowania kolekcji za pomocą funkcji biblioteki standardowej.

filter, map i find dla kolekcji to bezpłatna lekcja Kotlin Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Kotlin Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Kotlin Academy zawiera 4 lekcji w sumie.

Trzy najważniejsze funkcje

filter zachowuje elementy spełniające predykat. map przekształca każdy element. find zwraca pierwszy pasujący element (lub null). Razem obejmują większość operacji przetwarzania kolekcji.

Podstawy filter

filter zwraca nową listę zawierającą tylko elementy, dla których predykat ma wartość true.

fun main() {
    val nums = listOf(1, 2, 3, 4, 5, 6)
    val evens = nums.filter { it % 2 == 0 }
    println(evens) // [2, 4, 6]
}

Podstawy map

map zwraca nową listę o tym samym rozmiarze, w której każdy element jest przekształcany przez lambdę.

fun main() {
    val nums = listOf(1, 2, 3)
    val squares = nums.map { it * it }
    println(squares) // [1, 4, 9]
}

Podstawy find

find zwraca pierwszy element spełniający predykat lub null, jeśli żaden element go nie spełnia.

fun main() {
    val words = listOf("apple", "banana", "cherry")
    val match = words.find { it.startsWith("b") }
    println(match) // banana
}

Łączenie filter i map

Połącz je za pomocą składni kropkowej, aby tworzyć czytelne potoki przetwarzania.

fun main() {
    val nums = listOf(1, 2, 3, 4, 5)
    val result = nums.filter { it % 2 == 1 }.map { it * 10 }
    println(result) // [10, 30, 50]
}

Filtrowanie instancji data class

filter i map świetnie sprawdzają się w przypadku kolekcji instancji data class.

data class User(val name: String, val age: Int)
fun main() {
    val users = listOf(User("Ana", 17), User("Ben", 25), User("Cal", 31))
    val adultNames = users.filter { it.age >= 18 }.map { it.name }
    println(adultNames) // [Ben, Cal]
}

find a first

find zwraca wartość nullable, a first { ... } zgłasza wyjątek, jeśli nie znajdzie dopasowania. Używaj find w przypadku opcjonalnych dopasowań.

fun main() {
    val nums = listOf(1, 2, 3)
    println(nums.find { it > 10 })  // null
    // nums.first { it > 10 }       // throws NoSuchElementException
    println(nums.firstOrNull { it > 10 }) // null (alias of find)
}

filterNot i filterNotNull

filterNot odwraca predykat. filterNotNull usuwa elementy null z listy wartości nullable.

fun main() {
    val nums = listOf(1, 2, 3, 4)
    println(nums.filterNot { it % 2 == 0 }) // [1, 3]
    val maybe: List<String?> = listOf("a", null, "b", null, "c")
    println(maybe.filterNotNull()) // [a, b, c]
}

mapNotNull

mapNotNull najpierw przekształca elementy, a następnie usuwa wartości null — jest przydatne podczas parsowania.

fun main() {
    val raw = listOf("1", "two", "3", "four")
    val numbers = raw.mapNotNull { it.toIntOrNull() }
    println(numbers) // [1, 3]
}

Potok z praktycznego przykładu

Niewielki przykład łączący filter, map i końcową redukcję.

data class Product(val name: String, val price: Double, val inStock: Boolean)
fun main() {
    val products = listOf(
        Product("Pen", 1.0, true),
        Product("Book", 12.0, false),
        Product("Lamp", 25.0, true)
    )
    val total = products
        .filter { it.inStock }
        .map { it.price }
        .sum()
    println("Available total: $total") // 26.0
}

Wybór między operacjami

Użyj filter, gdy chcesz uzyskać podzbiór, map, aby przekształcać elementy, find, aby znaleźć jedno opcjonalne dopasowanie, a w razie potrzeby łącz je w potoki.

fun main() {
    val words = listOf("alpha", "beta", "gamma", "delta")
    println(words.filter { it.length == 5 })       // [alpha, gamma, delta]
    println(words.map { it.uppercase() })           // [ALPHA, BETA, GAMMA, DELTA]
    println(words.find { it.endsWith("ta") })       // beta
}

Szybkie sprawdzenie

Która funkcja zwraca nową kolekcję z elementami przekształconymi przez lambdę?

Podsumowanie

filter wybiera elementy, map je przekształca, a find znajduje pierwsze dopasowanie (lub null). Możesz swobodnie łączyć je w potokach; po mapNotNull i filterNotNull sięgaj podczas obsługi wartości opcjonalnych.

Często zadawane pytania

Czy lekcja „filter, map i find dla kolekcji” jest bezpłatna?

Tak — pełny tekst „filter, map i find dla kolekcji” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Kotlin Academy, przejdź na CoddyKit PRO. Kurs Kotlin Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „filter, map i find dla kolekcji”?

Zastosuj lambdy do przekształcania i filtrowania kolekcji za pomocą funkcji biblioteki standardowej. Ćwiczysz Kotlin Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Kotlin Academy?

Nie wymagamy żadnego doświadczenia. Kotlin Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „filter, map i find dla kolekcji”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Kotlin Academy?

Tak. Każda lekcja Kotlin Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

← Powrót do Kotlin Academy