Kotlin Academy · Lezione

Creazione di sequence

A partire da collezioni e generatori

Creazione di sequence è 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.

Creare sequence

Esistono diversi modi per creare una Sequence: a partire da raccolte esistenti o da elementi, con una funzione generatrice oppure con un builder. Questa lezione li illustra tutti.

Da una raccolta con asSequence

Il metodo più comune consiste nel chiamare asSequence() su una raccolta esistente per elaborarla in modo lazy.

fun main() {
    val seq = listOf(1, 2, 3, 4).asSequence()
    val result = seq.map { it * 2 }.toList()
    println(result)
}

Da elementi con sequenceOf

sequenceOf crea direttamente una sequence a partire da un insieme fisso di valori.

fun main() {
    val seq = sequenceOf("a", "b", "c")
    seq.forEach { println(it) }
}

Sequence infinite con generateSequence

generateSequence costruisce una sequence, eventualmente infinita, a partire da un valore iniziale e da una funzione che calcola l'elemento successivo. Per limitarla, usarla insieme a take.

fun main() {
    val powers = generateSequence(1) { it * 2 }
    val first5 = powers.take(5).toList()
    println(first5)
}

Fermare generateSequence

Se la funzione che calcola l'elemento successivo restituisce null, la sequence termina. Ciò consente di generare elementi fino al verificarsi di una condizione.

fun main() {
    val countdown = generateSequence(5) { if (it > 1) it - 1 else null }
    println(countdown.toList())
}

generateSequence senza valore iniziale

È possibile passare una singola lambda produttrice che restituisce il valore successivo oppure null. Questa soluzione è utile per leggere in modo lazy i flussi di input.

fun main() {
    var n = 0
    val seq = generateSequence { if (n < 3) n++ else null }
    println(seq.toList())
}

Il builder sequence

Il builder sequence { } consente di produrre elementi in modo imperativo usando yield, per un singolo valore, e yieldAll, per più valori.

fun main() {
    val seq = sequence {
        yield(1)
        yield(2)
        yieldAll(listOf(3, 4))
    }
    println(seq.toList())
}

Produzione lazy con yield

Anche il builder è lazy: il codice tra due yield viene eseguito solo quando gli elementi vengono richiesti. In combinazione con take, è possibile descrivere in sicurezza generatori infiniti.

fun main() {
    val naturals = sequence {
        var i = 1
        while (true) {
            yield(i)
            i++
        }
    }
    println(naturals.take(4).toList())
}

Fibonacci con generateSequence

Un esempio classico consiste nel generare in modo lazy i numeri di Fibonacci usando una Pair come stato.

fun main() {
    val fib = generateSequence(Pair(0, 1)) { Pair(it.second, it.first + it.second) }
        .map { it.first }
    println(fib.take(8).toList())
}

Riconvertire in una raccolta

Una sequence diventa una raccolta concreta solo quando si chiama un'operazione terminale come toList(), toSet() o toMutableList().

fun main() {
    val set = sequenceOf(1, 2, 2, 3).toSet()
    println(set)
}

Scegliere il metodo di creazione

Usare asSequence() per dati esistenti, sequenceOf per valori fissi, generateSequence per serie calcolate e il builder sequence { } per una generazione imperativa personalizzata.

Verifica rapida

Come fa generateSequence a sapere quando fermarsi?

Riepilogo

È possibile creare sequence con asSequence(), sequenceOf, generateSequence, usando un valore iniziale e un elemento successivo e terminando con null, e con il builder sequence { } insieme a yield e yieldAll. Nel prossimo passaggio vedrà come le operazioni lazy evitano le liste intermedie.

Domande Frequenti

La lezione «Creazione di sequence» è gratuita?

Sì — il testo completo di «Creazione di sequence» è 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 «Creazione di sequence»?

A partire da collezioni e generatori 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 «Creazione di sequence»?

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