Kotlin Academy · Lezione

Raggruppamento e partizionamento

Organizzi i dati

Raggruppamento e partizionamento è 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.

Organizzazione dei dati

A volte è necessario suddividere una raccolta in categorie. Kotlin mette a disposizione groupBy per raggruppare gli elementi in base a una chiave e partition per suddividerli in due liste in base a una condizione.

La funzione partition

partition suddivide una raccolta in una Pair composta da due liste: gli elementi che soddisfano il predicato e quelli che non lo soddisfano.

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5, 6)
    val (even, odd) = numbers.partition { it % 2 == 0 }
    println("Even: $even")
    println("Odd: $odd")
}

Destrutturare la Pair

Poiché partition restituisce una Pair, è possibile destrutturarla direttamente in due variabili denominate, come mostrato sopra. È anche possibile accedere a .first e .second.

fun main() {
    val result = listOf(10, -5, 3, -8).partition { it >= 0 }
    println(result.first)
    println(result.second)
}

La funzione groupBy

groupBy crea una Map in cui ogni chiave viene prodotta dal selettore e il valore è la lista degli elementi che condividono quella chiave.

fun main() {
    val words = listOf("apple", "banana", "avocado", "cherry")
    val byFirstLetter = words.groupBy { it.first() }
    println(byFirstLetter)
}

Raggruppare per una chiave calcolata

La chiave può essere un valore calcolato qualsiasi, ad esempio la lunghezza di una stringa o un resto.

fun main() {
    val numbers = listOf(1, 2, 3, 4, 5, 6, 7)
    val byRemainder = numbers.groupBy { it % 3 }
    println(byRemainder)
}

groupBy con una trasformazione dei valori

groupBy accetta una seconda lambda che trasforma ogni valore prima che venga inserito nel gruppo.

fun main() {
    val words = listOf("red", "rose", "blue", "berry")
    val grouped = groupExample(words)
    println(grouped)
}

fun groupExample(words: List<String>) =
    words.groupBy({ it.first() }, { it.uppercase() })

Iterare sui gruppi

Poiché groupBy restituisce una Map, è possibile iterare sulle sue voci per elaborare ogni gruppo.

fun main() {
    val animals = listOf("cat", "cow", "dog", "duck")
    val groups = animals.groupBy { it.first() }
    for ((letter, list) in groups) {
        println("$letter -> $list")
    }
}

Contare con groupingBy

Per contare gli elementi per chiave, usare groupingBy seguito da eachCount è una soluzione efficiente e chiara.

fun main() {
    val letters = listOf("a", "b", "a", "c", "b", "a")
    val counts = letters.groupingBy { it }.eachCount()
    println(counts)
}

partition rispetto a filter

Quando servono solo gli elementi corrispondenti, usare filter. Quando servono SIA gli elementi corrispondenti SIA quelli non corrispondenti, partition esegue l'operazione in un'unica passata e restituisce entrambe le liste.

fun main() {
    val ages = listOf(15, 22, 17, 30, 12)
    val (adults, minors) = ages.partition { it >= 18 }
    println("Adults: $adults, Minors: $minors")
}

Scegliere tra groupBy e partition

Usare partition per ottenere esattamente due gruppi definiti da una condizione sì/no. Usare groupBy quando possono esserci molti gruppi, identificati da una proprietà.

Raggruppamento pratico

Il raggruppamento e la suddivisione sostituiscono i lunghi cicli manuali con mappe e liste. Esprimono chiaramente l'intento e riducono gli errori nella gestione dei dati.

Verifica rapida

Che cosa restituisce partition?

Riepilogo

Ha imparato a usare partition per suddividere gli elementi in due liste in base a una condizione e groupBy per raggrupparli in una mappa in base a una chiave, oltre a groupingBy().eachCount() per eseguire conteggi. Nel prossimo passaggio ridurrà le raccolte a singoli valori tramite l'aggregazione.

Domande Frequenti

La lezione «Raggruppamento e partizionamento» è gratuita?

Sì — il testo completo di «Raggruppamento e partizionamento» è 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 «Raggruppamento e partizionamento»?

Organizzi i dati 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 «Raggruppamento e partizionamento»?

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