0Pricing
Kotlin Academy · Lekcja

filter, filterNot i partition

Dziel i wybieraj elementy za pomocą funkcji opartych na predykatach.

filter, filterNot i partition to bezpłatna lekcja Kotlin Academy na CoddyKit. To lekcja 2 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.

Operacje wyboru

filter zachowuje elementy spełniające predykat. filterNot zachowuje te, które go NIE spełniają. partition jednocześnie dzieli kolekcję na dwie listy.

Podstawowe filter

filter { ... } zwraca nową listę zawierającą tylko te 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]
}

filterNot

filterNot { ... } działa odwrotnie: zachowuje elementy, dla których predykat ma wartość false. Daje taki sam wynik jak odwrócenie predykatu, ale wyraża intencję w czytelniejszy sposób.

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

partition

partition zwraca obiekt Pair: najpierw elementy spełniające warunek, a następnie niespełniające go. Pozwala uniknąć dwóch przejść po danych.

fun main() {
    val nums = listOf(1, 2, 3, 4, 5, 6)
    val (evens, odds) = nums.partition { it % 2 == 0 }
    println("evens=$evens odds=$odds")
}

partition z klasą danych

Dzieli listę rekordów na dwie grupy w jednym przejściu.

data class User(val name: String, val active: Boolean)
fun main() {
    val users = listOf(User("Ada", true), User("Ben", false), User("Cal", true))
    val (active, inactive) = users.partition { it.active }
    println("active=${active.map { it.name }}")
    println("inactive=${inactive.map { it.name }}")
}

filterIndexed

Predykat otrzymuje zarówno indeks, jak i wartość — jest to przydatne, gdy znaczenie ma pozycja elementu.

fun main() {
    val nums = listOf(10, 20, 30, 40, 50)
    val every2nd = nums.filterIndexed { i, _ -> i % 2 == 0 }
    println(every2nd) // [10, 30, 50]
}

filterIsInstance

Zachowuje tylko elementy określonego typu — wewnątrz są dostępne smart casty.

fun main() {
    val mixed: List<Any> = listOf(1, "hello", 2.0, "world", 3)
    val onlyStrings = mixed.filterIsInstance<String>()
    println(onlyStrings) // [hello, world]
}

filterNotNull

Usuwa elementy null z listy wartości dopuszczających null — zwraca listę elementów niebędących null.

fun main() {
    val mixed: List<String?> = listOf("a", null, "b", null, "c")
    val nonNull = mixed.filterNotNull()
    println(nonNull) // [a, b, c]
}

Łączenie filter i map

Połączenie filter i map pozwala tworzyć potoki wyboru i przekształcania.

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 availableNames = products.filter { it.inStock }.map { it.name }
    println(availableNames) // [Pen, Lamp]
}

Negowanie za pomocą filterNot dla większej czytelności

Czasami filterNot { it.isActive } jest czytelniejsze niż filter { !it.isActive }.

data class Task(val title: String, val done: Boolean)
fun main() {
    val tasks = listOf(Task("Email", true), Task("Lunch", false), Task("Code", true))
    val pending = tasks.filterNot { it.done }
    println(pending) // [Task(title=Lunch, done=false)]
}

partition zwraca listy

Obiekt Pair zwracany przez partition zawiera dwie zwykłe listy — można je rozpakować albo uzyskać do nich dostęp za pomocą .first / .second.

fun main() {
    val nums = (1..10).toList()
    val result = nums.partition { it > 5 }
    println("above 5: ${result.first}")
    println("below 6: ${result.second}")
}

partition a dwa wywołania filter

Jeśli potrzebne są oba podzbiory, partition jest wydajniejsze — wykonuje jedno przejście zamiast dwóch.

fun main() {
    val nums = (1..10).toList()
    // Two passes:
    val a = nums.filter { it > 5 }
    val b = nums.filter { it <= 5 }
    // One pass:
    val (c, d) = nums.partition { it > 5 }
    println("$a $b")
    println("$c $d")
}

Szybkie sprawdzenie

Która funkcja zwraca ZARÓWNO elementy spełniające warunek, jak i te, które go nie spełniają, w jednym przejściu?

Podsumowanie

filter wybiera pasujące elementy; filterNot wybiera niepasujące; partition zwraca obie grupy w jednym przejściu. filterIsInstance służy do zachowania elementów określonego typu, a filterNotNull do usuwania wartości null. Można łączyć je z map, tworząc potoki wyboru i przekształcania.

Często zadawane pytania

Czy lekcja „filter, filterNot i partition” jest bezpłatna?

Tak — pełny tekst „filter, filterNot i partition” 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, filterNot i partition”?

Dziel i wybieraj elementy za pomocą funkcji opartych na predykatach. Ć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 2 z 4.

Ile czasu zajmuje lekcja „filter, filterNot i partition”?

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

  1. map i flatMap: przekształcanie każdego elementu
  2. filter, filterNot i partition
  3. fold, reduce i runningFold
  4. Łańcuchy potoków i unikanie list pośrednich za pomocą Sequence
← Powrót do Kotlin Academy