Associazione e flattening
associate e flatMap
Associazione e flattening è 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.
Associare e appiattire
Esistono altri due potenti strumenti per lavorare con le raccolte: le funzioni della famiglia associate costruiscono mappe a partire da una lista, mentre flatMap e flatten trasformano raccolte annidate in un'unica raccolta piatta.
La funzione associateWith
associateWith usa ogni elemento come chiave e calcola il relativo valore tramite una lambda, producendo una Map.
fun main() {
val words = listOf("a", "bb", "ccc")
val lengths = words.associateWith { it.length }
println(lengths)
}La funzione associateBy
associateBy fa l'opposto: calcola la chiave a partire da ogni elemento, mantenendo l'elemento come valore.
data class User(val id: Int, val name: String)
fun main() {
val users = listOf(User(1, "Ann"), User(2, "Bob"))
val byId = users.associateBy { it.id }
println(byId[2]?.name)
}La funzione associate
La funzione generale associate consente di costruire contemporaneamente chiave e valore, restituendo una Pair per ogni elemento.
fun main() {
val names = listOf("Ann", "Bob", "Cy")
val map = names.associate { it to it.length }
println(map)
}Chiavi duplicate
Se due elementi producono la stessa chiave in una funzione associate, prevale l'ultimo elemento. Mantenere le chiavi univoche quando è necessario conservare ogni elemento.
fun main() {
val words = listOf("apple", "ant", "bee")
val byFirst = words.associateBy { it.first() }
println(byFirst)
}La funzione flatten
flatten prende una raccolta di raccolte e le unisce in un'unica lista piatta.
fun main() {
val nested = listOf(listOf(1, 2), listOf(3, 4), listOf(5))
val flat = nested.flatten()
println(flat)
}La funzione flatMap
flatMap associa a ogni elemento una raccolta e poi appiattisce tutte queste raccolte in un'unica lista. È l'equivalente di map più flatten in un solo passaggio.
fun main() {
val words = listOf("hi", "ok")
val chars = words.flatMap { it.toList() }
println(chars)
}flatMap sui dati annidati
flatMap è ideale per espandere strutture annidate in un'unica sequenza di elementi.
data class Team(val members: List<String>)
fun main() {
val teams = listOf(Team(listOf("Ann", "Bob")), Team(listOf("Cy")))
val everyone = teams.flatMap { it.members }
println(everyone)
}flatMap rispetto a map
Usare map quando ogni elemento produce esattamente un risultato. Usare flatMap quando ogni elemento produce una raccolta e si desidera combinarle tutte in un'unica lista piatta.
fun main() {
val numbers = listOf(1, 2, 3)
val mapped = numbers.map { listOf(it, it * 10) }
val flat = numbers.flatMap { listOf(it, it * 10) }
println("map: $mapped")
println("flatMap: $flat")
}Combinare associate e flatMap
Questi strumenti vengono spesso usati insieme nelle pipeline di dati: si appiattiscono i dati annidati e poi li si associa a una mappa di ricerca per accedervi rapidamente.
data class Order(val items: List<String>)
fun main() {
val orders = listOf(Order(listOf("pen", "ink")), Order(listOf("pen")))
val counts = orders.flatMap { it.items }.groupingBy { it }.eachCount()
println(counts)
}Quando usare ciascuna funzione
Scegliere associateBy o associateWith per costruire mappe di ricerca rapide a partire da liste, e flatMap o flatten per ridurre le raccolte annidate. Queste funzioni rendono conciso e chiaro il lavoro con i dati strutturati.
Verifica rapida
Che cosa fa flatMap?
Riepilogo
Ha imparato a costruire mappe con associate, associateBy e associateWith, dove prevale l'ultima chiave duplicata, e a eliminare l'annidamento con flatten e flatMap. Queste funzioni completano il set di strumenti per trasformare, organizzare, aggregare e ristrutturare i dati.
Impara Kotlin con un tutor IA — gratis
Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.
- Corsi
- 51
- Lezioni
- 203
Domande Frequenti
La lezione «Associazione e flattening» è gratuita?
Sì — il testo completo di «Associazione e flattening» è 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 «Associazione e flattening»?
associate e flatMap 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 «Associazione e flattening»?
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
- Filtraggio e mapping
- Raggruppamento e partizionamento
- Aggregazione
- Associazione e flattening