Kotlin Academy · Aula

Por que Usar Sequências

Avaliação tardia

Por que Usar Sequências é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 1 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Kotlin Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Kotlin Academy inclui 4 aulas no total.

O que são sequências?

Uma Sequence é semelhante a uma coleção, mas processa os elementos de forma preguiçosa. As operações não são executadas até que uma operação terminal solicite os resultados, e os elementos percorrem toda a cadeia um de cada vez.

Coleções com avaliação imediata

As operações padrão de coleções são imediatas: cada etapa (filter, map) processa completamente a lista e cria uma nova lista intermediária antes do início da etapa seguinte.

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

O custo das listas intermediárias

Com grandes volumes de dados, o processamento imediato aloca uma nova lista a cada etapa. Com muitas operações ou milhões de elementos, isso desperdiça memória e tempo.

Sequências preguiçosas

Uma sequência processa cada elemento por todo o fluxo de processamento antes de passar ao próximo. Nenhuma lista intermediária é criada. Converta os dados com asSequence().

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

Observando a ordem de execução

Adicionar instruções de impressão revela a diferença. Com uma sequência, cada elemento passa por mapear e depois filtrar antes que o próximo elemento comece a ser processado.

fun main() {
    listOf(1, 2, 3).asSequence()
        .map { println("map $it"); it * 2 }
        .filter { println("filter $it"); it > 2 }
        .toList()
}

Ordem de execução imediata

Compare com uma lista normal: o mapeamento é executado primeiro para ALL os elementos, e depois a filtragem é executada para todos eles.

fun main() {
    listOf(1, 2, 3)
        .map { println("map $it"); it * 2 }
        .filter { println("filter $it"); it > 2 }
}

Interrupção antecipada

A avaliação preguiçosa permite a interrupção antecipada: operações como first ou find param assim que um resultado é encontrado, evitando trabalho com o restante.

fun main() {
    val firstBig = (1..1000000).asSequence()
        .map { it * 2 }
        .first { it > 10 }
    println(firstBig)
}

Operações intermediárias versus terminais

As operações de sequência são divididas em dois tipos:

Intermediárias (map, filter, take): preguiçosas, retornam outra sequência.
Terminais (toList, sum, first): acionam o cálculo e produzem um valor.

Nada acontece sem uma operação terminal

Uma cadeia apenas de operações intermediárias não executa nenhum código. Até que uma operação terminal seja chamada, as lambdas nunca são executadas.

fun main() {
    val seq = listOf(1, 2, 3).asSequence()
        .map { println("processing $it"); it }
    println("Nothing printed yet")
    seq.toList()
}

Quando as sequências são úteis

As sequências são especialmente úteis com grandes conjuntos de dados, cadeias longas de operações ou quando você precisa apenas de parte do resultado, como a primeira correspondência. Para listas pequenas, as coleções comuns são mais simples e igualmente rápidas.

Uma representação mental

Imagine uma coleção processando dados em camadas horizontais (todos os elementos em cada etapa) e uma sequência processando-os em fluxos verticais (um elemento passando por todas as etapas). É por isso que as sequências evitam listas intermediárias.

Verificação rápida

Por que as sequências podem ser mais eficientes do que as coleções?

Recapitulação

As sequências processam os dados de forma preguiçosa, elemento por elemento, por meio de uma cadeia de operações intermediárias, com o cálculo acionado apenas por uma operação terminal. Isso evita listas intermediárias e permite interrupções antecipadas. Em seguida, você aprenderá a criar sequências.

Perguntas Frequentes

A aula “Por que Usar Sequências” é grátis?

Sim — o texto completo de “Por que Usar Sequências” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Kotlin Academy, atualize para CoddyKit PRO. O curso de Kotlin Academy inclui 4 aulas no total.

O que vou aprender em “Por que Usar Sequências”?

Avaliação tardia Você pratica Kotlin Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Kotlin Academy?

Nenhuma experiência prévia é necessária. Kotlin Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 1 de 4.

Quanto tempo leva a aula “Por que Usar Sequências”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Kotlin Academy?

Sim. Cada aula de Kotlin Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Kotlin Academy