Kotlin Academy · Aula

Sequências versus Coleções

Saiba quando cada uma é melhor

Sequências versus Coleções é uma aula grátis de Kotlin Academy no CoddyKit. Esta é a aula 4 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.

Sequências versus coleções

Sequências e coleções oferecem as mesmas operações funcionais, mas fazem a avaliação de maneiras diferentes. Saber quando cada uma é melhor ajuda você a escrever código eficiente e legível.

Recapitulação das coleções imediatas

As coleções têm avaliação imediata: cada operação processa todos os elementos e produz imediatamente uma nova coleção. Isso é simples e rápido para dados pequenos.

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

Recapitulação das sequências preguiçosas

As sequências têm avaliação preguiçosa: as operações constroem um fluxo de processamento que é executado elemento a elemento somente quando consumido, evitando coleções intermediárias.

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

Quando as coleções são melhores

Para coleções pequenas e cadeias curtas, as coleções geralmente são mais rápidas e claras. As sequências acrescentam um custo por elemento, devido às chamadas do iterador, que pode superar seus benefícios em dados muito pequenos.

Quando as sequências são melhores

As sequências são melhores quando os dados são grandes, a cadeia é longa ou você precisa apenas de parte do resultado, como a primeira correspondência ou os primeiros N elementos. Elas evitam criar listas intermediárias grandes e param antecipadamente.

fun main() {
    val firstEvenSquare = (1..1000000).asSequence()
        .map { it * it }
        .first { it % 2 == 0 }
    println(firstEvenSquare)
}

Medindo a diferença

Este exemplo com um intervalo grande mostra como uma sequência evita produzir uma lista intermediária com um milhão de elementos, que a versão de avaliação imediata criaria.

fun main() {
    val seqResult = (1..1000).asSequence()
        .filter { it % 2 == 0 }
        .map { it * 3 }
        .take(3)
        .toList()
    println(seqResult)
}

Uso de memória

Cadeias de avaliação imediata mantêm todas as listas intermediárias na memória ao mesmo tempo. As sequências mantêm apenas o elemento atual fluindo pelo processamento, portanto o uso máximo de memória permanece baixo em fluxos de processamento longos.

Vantagem da interrupção antecipada

Se uma operação terminal puder terminar antecipadamente, como first, find ou any, as sequências ignorarão os elementos restantes, enquanto as coleções de avaliação imediata já terão processado tudo.

fun main() {
    val found = (1..100).asSequence()
        .map { println("checking $it"); it }
        .any { it == 3 }
    println("Found: $found")
}

Tenha cuidado com operações que têm estado

Operações como sorted, distinct e groupBy precisam de todos os elementos, portanto reduzem a avaliação preguiçosa. Um fluxo de processamento dominado por essas operações talvez não se beneficie de uma sequência.

Uma orientação prática

Regra geral: prefira coleções por padrão, para manter a clareza. Mude para uma sequência ao processar dados grandes, encadear muitas operações ou precisar apenas de uma pequena parte do resultado. Sempre faça medições se o desempenho for importante.

Mesma API, mecanismo diferente

Como ambas compartilham os mesmos nomes de operações, geralmente você pode alternar adicionando ou removendo asSequence() e uma operação terminal toList(). Isso torna os experimentos de desempenho pouco arriscados.

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

Verificação rápida

Em qual situação é mais provável que uma sequência supere uma coleção em desempenho?

Recapitulação

As coleções têm avaliação imediata e são melhores para dados pequenos e para manter a clareza; as sequências têm avaliação preguiçosa e são melhores para dados grandes, cadeias longas ou resultados parciais, graças à ausência de listas intermediárias e à interrupção antecipada. Tenha cuidado com operações que têm estado. Elas compartilham a mesma API, portanto a troca é fácil. Isso conclui o curso de Sequências.

Perguntas Frequentes

A aula “Sequências versus Coleções” é grátis?

Sim — o texto completo de “Sequências versus Coleções” é 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 “Sequências versus Coleções”?

Saiba quando cada uma é melhor 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 4 de 4.

Quanto tempo leva a aula “Sequências versus Coleções”?

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