Kotlin Academy · Leçon

Opérations paresseuses

Éviter les listes intermédiaires

Opérations paresseuses est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 3 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.

Opérations paresseuses

La puissance des séquences vient des opérations paresseuses. Les opérations intermédiaires construisent une chaîne de traitement sans l’exécuter, et seule une opération terminale fait transiter les éléments. Cela évite les listes intermédiaires.

Aucune liste intermédiaire

Avec les collections, chaque map et filter alloue une nouvelle liste. Avec les séquences, les éléments transitent par toutes les étapes sans créer ces listes temporaires.

fun main() {
    val result = (1..6).asSequence()
        .map { it * it }
        .filter { it % 2 == 0 }
        .toList()
    println(result)
}

Observer l’évaluation paresseuse

Sans opération terminale, aucune fonction lambda ne s’exécute. La chaîne de traitement n’est qu’une recette jusqu’à sa consommation.

fun main() {
    val pipeline = (1..3).asSequence()
        .map { println("map $it"); it }
    println("Built pipeline, nothing ran")
    pipeline.toList()
}

take limite le travail

take(n) est une opération intermédiaire paresseuse. Associée à un générateur infini, elle s’arrête après avoir produit n éléments.

fun main() {
    val firstThree = generateSequence(1) { it + 1 }
        .map { it * 10 }
        .take(3)
        .toList()
    println(firstThree)
}

first effectue un arrêt anticipé

Les opérations terminales comme first s’arrêtent dès qu’elles disposent de ce dont elles ont besoin, en ignorant complètement les éléments restants.

fun main() {
    val result = (1..1000).asSequence()
        .map { println("processing $it"); it }
        .first { it > 3 }
    println("Found $result")
}

Traitement élément par élément

Dans une séquence, l’élément 1 passe par map, puis par filter, suivi de l’élément 2, et ainsi de suite. Cet ordre permet l’arrêt anticipé et évite de mettre tous les résultats en mémoire tampon.

fun main() {
    listOf(1, 2, 3, 4).asSequence()
        .filter { println("filter $it"); it % 2 == 0 }
        .map { println("map $it"); it * 10 }
        .toList()
}

takeWhile et dropWhile

takeWhile produit des éléments jusqu’à ce que le prédicat échoue ; dropWhile ignore les éléments initiaux tant que le prédicat est vérifié. Les deux opérations sont paresseuses.

fun main() {
    val nums = generateSequence(1) { it + 1 }
    println(nums.takeWhile { it < 5 }.toList())
}

Éviter les calculs inutiles

Comme rien ne s’exécute avant la consommation et que celle-ci peut s’arrêter prématurément, les transformations coûteuses ne sont appliquées qu’aux éléments qui atteignent effectivement une opération terminale.

fun main() {
    val result = (1..100).asSequence()
        .map { it * 2 }
        .filter { it > 10 }
        .take(2)
        .toList()
    println(result)
}

Réutiliser les séquences

La plupart des séquences peuvent être parcourues plusieurs fois, la chaîne de traitement étant réexécutée à chaque fois. En revanche, les séquences provenant de sources à usage unique, comme un itérateur, ne peuvent être consommées qu’une seule fois. Soyez attentif à la source.

fun main() {
    val seq = sequenceOf(1, 2, 3).map { it * 2 }
    println(seq.toList())
    println(seq.sum())
}

Opérations avec état et sans état

La plupart des opérations sont sans état : elles traitent un élément à la fois. Certaines, comme sorted ou distinct, conservent un état et doivent mettre en mémoire tampon ou parcourir tous les éléments, ce qui réduit le bénéfice de l’évaluation paresseuse.

fun main() {
    val result = sequenceOf(3, 1, 2, 1).distinct().sorted().toList()
    println(result)
}

Les bénéfices de l’évaluation paresseuse

Les opérations paresseuses économisent de la mémoire en évitant les listes intermédiaires et du temps grâce à l’arrêt anticipé. Plus les données sont volumineuses et plus l’opération terminale est sélective, plus le bénéfice est important.

Vérification rapide

Quand les fonctions lambda d’une chaîne d’opérations sur une séquence s’exécutent-elles réellement ?

Récapitulatif

Les opérations paresseuses construisent une chaîne de traitement qui ne s’exécute que lorsqu’une opération terminale la consomme, ce qui évite les listes intermédiaires et permet l’arrêt anticipé avec first, take et takeWhile. Faites attention aux opérations avec état comme sorted. Vous allez maintenant déterminer quand les séquences sont plus avantageuses que les collections.

Questions Fréquemment Posées

La leçon « Opérations paresseuses » est-elle gratuite ?

Oui — le texte complet de « Opérations paresseuses » 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 « Opérations paresseuses » ?

Éviter les listes intermédiaires 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 3 sur 4.

Combien de temps prend la leçon « Opérations paresseuses » ?

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