Kotlin Academy · Lezione

filter, map e find sulle collezioni

Applichi le lambda per trasformare e filtrare le collezioni usando le funzioni della libreria standard.

filter, map e find sulle collezioni è una lezione Kotlin Academy gratuita su CoddyKit. Questa è la lezione 4 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.

Tre funzioni fondamentali

filter mantiene gli elementi che corrispondono a un predicato. map trasforma ogni elemento. find restituisce il primo elemento corrispondente (oppure null). Insieme coprono la maggior parte delle operazioni sulle collezioni.

Nozioni di base su filter

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

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

Nozioni di base su map

map restituisce una nuova lista della stessa dimensione, in cui ogni elemento viene trasformato dalla lambda.

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

Nozioni di base su find

find restituisce il primo elemento che corrisponde al predicato, oppure null se non ci sono corrispondenze.

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

Concatenare filter e map

Li combini con la sintassi a punti per creare pipeline espressive.

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

Filtrare le data class

filter e map danno il meglio con collezioni di istanze di 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 rispetto a first

find restituisce un valore nullable; first { ... } genera un'eccezione se non trova corrispondenze. Usi find per le corrispondenze opzionali.

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 e filterNotNull

filterNot inverte il predicato. filterNotNull rimuove le voci null da una lista di valori 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 trasforma i valori e poi rimuove i null: è utile per l'analisi dei dati.

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

Pipeline del mondo reale

Un piccolo esempio che combina filter, map e una riduzione finale.

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
}

Scegliere tra le operazioni

Usi filter quando desidera un sottoinsieme, map per trasformare, find per una singola corrispondenza opzionale e le concateni quando necessario.

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
}

Verifica rapida

Quale funzione restituisce una nuova collezione con gli elementi trasformati da una lambda?

Riepilogo

filter seleziona, map trasforma, find individua la prima corrispondenza (oppure null). Li combini liberamente nelle pipeline; usi mapNotNull e filterNotNull quando gestisce valori opzionali.

Domande Frequenti

La lezione «filter, map e find sulle collezioni» è gratuita?

Sì — il testo completo di «filter, map e find sulle collezioni» è 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, map e find sulle collezioni»?

Applichi le lambda per trasformare e filtrare le collezioni usando le funzioni della libreria standard. 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 4 di 4.

Quanto tempo richiede la lezione «filter, map e find sulle collezioni»?

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

← Torna a Kotlin Academy