Kotlin Academy · Leçon

Séquences ou collections

Dans quels cas chacune est préférable

Séquences ou collections est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 4 sur 4. Tu peux lire la leçon complète ci-dessous gratuitement — puis la pratiquer en direct dans le navigateur avec un éditeur de code intégré et un tuteur IA 24/7. Elle fait partie du parcours d'apprentissage Kotlin Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Kotlin Academy comprend 4 leçons au total.

Séquences et collections

Les séquences et les collections proposent les mêmes opérations fonctionnelles, mais elles sont évaluées différemment. Savoir dans quels cas chacune est avantageuse vous aide à écrire du code performant et lisible.

Récapitulatif des collections à évaluation immédiate

Les collections sont à évaluation immédiate : chaque opération traite tous les éléments et produit immédiatement une nouvelle collection. Cette approche est simple et rapide pour les petits volumes de données.

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

Récapitulatif des séquences paresseuses

Les séquences sont paresseuses : les opérations construisent une chaîne de traitement qui s’exécute élément par élément uniquement lors de la consommation, ce qui évite les collections intermédiaires.

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

Quand les collections sont avantageuses

Pour les petites collections et les chaînes courtes, les collections sont généralement plus rapides et plus claires. Les séquences ajoutent un surcoût par élément, dû aux appels de l’itérateur, qui peut dépasser leurs avantages sur de très petits volumes de données.

Quand les séquences sont avantageuses

Les séquences sont avantageuses lorsque les données sont volumineuses, que la chaîne est longue ou que vous n’avez besoin que d’une partie du résultat, comme la première correspondance ou les N premiers éléments. Elles évitent de construire de grandes listes intermédiaires et s’arrêtent prématurément.

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

Mesurer la différence

Cet exemple utilisant une grande plage montre comment une séquence évite de produire une liste intermédiaire d’un million d’éléments que la version à évaluation immédiate aurait créée.

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

Empreinte mémoire

Les chaînes à évaluation immédiate gardent simultanément chaque liste intermédiaire en mémoire. Les séquences ne conservent que l’élément courant qui transite, si bien que la mémoire maximale reste faible pour les longues chaînes de traitement.

Avantage de l’arrêt anticipé

Si une opération terminale peut se terminer prématurément, comme first, find ou any, les séquences ignorent les éléments restants, tandis que les collections à évaluation immédiate les auraient déjà tous traités.

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

Attention aux opérations avec état

Les opérations comme sorted, distinct et groupBy ont besoin de tous les éléments, ce qui réduit la paresse. Une chaîne de traitement dominée par ces opérations pourrait ne pas bénéficier d’une séquence.

Un conseil pratique

En règle générale, privilégiez les collections pour leur clarté. Passez à une séquence lorsque vous traitez de grandes quantités de données, enchaînez de nombreuses opérations ou n’avez besoin que d’une petite partie du résultat. Mesurez toujours les performances si elles sont essentielles.

Même interface de programmation, moteur différent

Comme les deux partagent les mêmes noms d’opérations, vous pouvez généralement passer de l’une à l’autre en ajoutant ou en supprimant asSequence() et une opération terminale toList(). Cela permet d’expérimenter les performances avec peu de risques.

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)
}

Vérification rapide

Dans quelle situation une séquence a-t-elle le plus de chances d’être plus performante qu’une collection ?

Récapitulatif

Les collections sont à évaluation immédiate et conviennent mieux aux petits volumes de données et à la clarté ; les séquences sont paresseuses et conviennent mieux aux grandes quantités de données, aux longues chaînes ou aux résultats partiels, grâce à l’absence de listes intermédiaires et à l’arrêt anticipé. Faites attention aux opérations avec état. Elles partagent la même interface de programmation, ce qui facilite le passage de l’une à l’autre. Cette leçon termine le cours sur les séquences.

Questions Fréquemment Posées

La leçon « Séquences ou collections » est-elle gratuite ?

Oui — le texte complet de « Séquences ou collections » est gratuit à lire ici sur le web. Pour la pratiquer de manière interactive (un éditeur de code intégré et un tuteur IA 24/7) et déverrouiller le reste du cours Kotlin Academy, passe à CoddyKit PRO. Le cours Kotlin Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Séquences ou collections » ?

Dans quels cas chacune est préférable Tu pratiques Kotlin Academy avec du code pratique que tu exécutes directement dans le navigateur, et un tuteur IA 24/7 répond à tes questions au fur et à mesure que tu avances dans la leçon.

Dois-je avoir de l'expérience pour commencer Kotlin Academy ?

Aucune expérience préalable n'est requise. Kotlin Academy sur CoddyKit est structuré pour les débutants jusqu'aux apprenants avancés, donc tu peux commencer ici ou depuis le début et avancer à ton rythme. Ceci est la leçon 4 sur 4.

Combien de temps prend la leçon « Séquences ou collections » ?

La plupart des leçons CoddyKit prennent environ 5–10 minutes. Chacune est courte et interactive, tu progresses régulièrement et tu repiques exactement où tu t'es arrêté sur le web et l'app.

Peux-tu écrire et exécuter du code dans cette leçon Kotlin Academy ?

Oui. Chaque leçon Kotlin Academy inclut un éditeur de code intégré, tu écris et exécutes du vrai code directement dans ton navigateur et tu reçois des retours IA instantanés — aucune configuration locale requise.

Toutes les leçons de ce cours

← Retour à Kotlin Academy