Kotlin Academy · Leçon

Pourquoi utiliser des séquences

Évaluation paresseuse

Pourquoi utiliser des séquences est une leçon Kotlin Academy gratuite sur CoddyKit. Ceci est la leçon 1 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.

Que sont les séquences ?

Une Sequence ressemble à une collection, mais traite les éléments paresseusement. Les opérations ne sont exécutées que lorsqu’une opération terminale demande les résultats, et les éléments parcourent toute la chaîne un par un.

Collections à évaluation stricte

Les opérations standard sur les collections sont strictes : chaque étape (filter, map) traite entièrement la liste et crée une nouvelle liste intermédiaire avant le début de l’étape suivante.

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

Le coût des listes intermédiaires

Avec de grandes quantités de données, le traitement strict alloue une nouvelle liste à chaque étape. Lorsque de nombreuses opérations ou des millions d’éléments sont concernés, cela gaspille de la mémoire et du temps.

Séquences paresseuses

Une séquence fait passer chaque élément dans toute la chaîne de traitement avant de passer au suivant. Aucune liste intermédiaire n’est créée. Effectuez la conversion avec asSequence().

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

Observer l’ordre d’exécution

L’ajout d’affichages permet de révéler la différence. Avec une séquence, chaque élément passe par map puis par filter avant que l’élément suivant ne commence son parcours.

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

Ordre d’exécution strict

Comparez avec une liste normale : map s’exécute d’abord pour ALL les éléments, puis filter s’exécute pour tous les éléments.

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

Court-circuitage

L’évaluation paresseuse permet le court-circuitage : les opérations comme first ou find s’arrêtent dès qu’un résultat est trouvé, ce qui évite de traiter le reste.

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

Opérations intermédiaires et terminales

Les opérations sur les séquences se divisent en deux catégories :

Intermédiaires (map, filter, take) : paresseuses, elles renvoient une autre séquence.
Terminales (toList, sum, first) : elles déclenchent le calcul et produisent une valeur.

Rien ne se passe sans opération terminale

Une chaîne d’opérations intermédiaires seule n’exécute aucun code. Tant qu’aucune opération terminale n’est appelée, les lambdas ne s’exécutent jamais.

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

Quand les séquences sont utiles

Les séquences sont particulièrement utiles avec de grands ensembles de données, de longues chaînes d’opérations ou lorsque vous n’avez besoin que d’une partie du résultat, comme la première correspondance. Pour les petites listes, les collections classiques sont plus simples et tout aussi rapides.

Une représentation mentale

Imaginez qu’une collection traite les données en couches horizontales (tous les éléments à chaque étape), tandis qu’une séquence les traite en flux verticaux (un élément à travers toutes les étapes). C’est pourquoi les séquences évitent les listes intermédiaires.

Vérification rapide

Pourquoi les séquences peuvent-elles être plus efficaces que les collections ?

Récapitulatif

Les séquences traitent les données paresseusement, élément par élément, à travers une chaîne d’opérations intermédiaires, le calcul n’étant déclenché que par une opération terminale. Cela évite les listes intermédiaires et permet le court-circuitage. Vous allez maintenant apprendre à créer des séquences.

Questions Fréquemment Posées

La leçon « Pourquoi utiliser des séquences » est-elle gratuite ?

Oui — le texte complet de « Pourquoi utiliser des séquences » 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 « Pourquoi utiliser des séquences » ?

Évaluation paresseuse 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 1 sur 4.

Combien de temps prend la leçon « Pourquoi utiliser des séquences » ?

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