0Pricing
Kotlin Academy · Lezione

filter, filterNot e partition

Divida e selezioni gli elementi usando funzioni basate su predicati.

filter, filterNot e partition è una lezione Kotlin Academy gratuita su CoddyKit. Questa è la lezione 2 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Kotlin Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Kotlin Academy include 4 lezioni in totale.

Operazioni di selezione

filter conserva gli elementi che soddisfano un predicato. filterNot conserva quelli che NON lo soddisfano. partition divide la raccolta in due liste in un'unica operazione.

filter di base

filter { ... } restituisce una nuova lista contenente solo gli elementi per i quali il predicato è vero.

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 { ... } è l'operazione inversa: conserva gli elementi per i quali il predicato è falso. Il risultato è lo stesso dell'inversione del predicato, ma l'intento è più chiaro.

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 restituisce un Pair: prima gli elementi corrispondenti, poi quelli non corrispondenti. Evita due passaggi sui dati.

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 con una classe dati

Divida una lista di record in due gruppi in un unico passaggio.

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

Il predicato riceve sia l'indice sia il valore, una caratteristica utile quando la posizione è importante.

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

filterIsInstance

Conserva solo gli elementi di un tipo specifico: all'interno vengono applicati gli smart cast.

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

filterNotNull

Rimuove gli elementi null da una lista di valori nullable e restituisce una lista di elementi non null.

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

Concatenare filter e map

Combini filter e map per creare pipeline di selezione e trasformazione.

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]
}

Negare con filterNot per maggiore chiarezza

A volte filterNot { it.isActive } è più leggibile di 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 restituisce liste

Il Pair restituito da partition contiene due normali List: può destrutturarle oppure accedervi tramite .first e .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 o due chiamate a filter

Se sono necessari entrambi i sottoinsiemi, partition è più veloce: esegue un solo passaggio invece di due.

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")
}

Verifica rapida

Quale funzione restituisce SIA gli elementi corrispondenti SIA quelli non corrispondenti in un unico passaggio?

Riepilogo

filter seleziona le corrispondenze; filterNot seleziona gli elementi non corrispondenti; partition restituisce entrambi i gruppi in un unico passaggio. Utilizzi filterIsInstance per conservare gli elementi di un determinato tipo e filterNotNull per eliminare i valori null. Lo concateni con map per eseguire selezione e trasformazione.

Domande Frequenti

La lezione «filter, filterNot e partition» è gratuita?

Sì — il testo completo di «filter, filterNot e partition» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Kotlin Academy, passa a CoddyKit PRO. Il corso Kotlin Academy include 4 lezioni in totale.

Cosa imparerò in «filter, filterNot e partition»?

Divida e selezioni gli elementi usando funzioni basate su predicati. Eserciti Kotlin Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Kotlin Academy?

Non è richiesta alcuna esperienza precedente. Kotlin Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 2 di 4.

Quanto tempo richiede la lezione «filter, filterNot e partition»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Kotlin Academy?

Sì. Ogni lezione Kotlin Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. map e flatMap: trasformare ogni elemento
  2. filter, filterNot e partition
  3. fold, reduce e runningFold
  4. Concatenare pipeline ed evitare liste intermedie con Sequence
← Torna a Kotlin Academy