0Pricing
Java Academy · Leçon

Flux infinis avec iterate et generate

Créez des flux infinis avec Stream.iterate et Stream.generate, puis utilisez une limite ou take-while pour les arrêter.

Flux infinis avec iterate et generate est une leçon Java 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 Java Academy, et ta progression se synchronise sur le web et l'application CoddyKit. Le cours Java Academy comprend 4 leçons au total.

Que sont les flux infinis ?

Les flux Java peuvent être infinis : ils produisent des éléments à la demande, sans fin. Ils doivent être arrêtés par une opération de limitation (limit, takeWhile, findFirst, etc.) pour éviter une exécution sans fin.

Stream.iterate : séquences initialisées

Stream.iterate(seed, f) génère un flux infini en appliquant f à plusieurs reprises à la valeur précédente. Le premier élément est la valeur initiale.

// Infinite even numbers: 0, 2, 4, 6, 8, ...
Stream.iterate(0, n -> n + 2)
    .limit(10)
    .forEach(System.out::println);

iterate avec un prédicat (Java 9+)

Stream.iterate(seed, predicate, f) ajoute une condition d’arrêt, comme une boucle for avec une condition. Le flux s’arrête lorsque le prédicat est faux.

// Equivalent to: for (int i = 1; i <= 100; i *= 2)
Stream.iterate(1, n -> n <= 100, n -> n * 2)
    .forEach(System.out::println); // 1 2 4 8 16 32 64

Stream.generate : générateur sans état

Stream.generate(Supplier) appelle le fournisseur pour chaque élément. Le fournisseur peut être sans état (nombres aléatoires) ou avec état (en utilisant un compteur externe).

// Infinite random doubles between 0.0 and 1.0:
Stream.generate(Math::random)
    .limit(5)
    .forEach(System.out::println);

Générer des UUID

Utilisez generate avec UUID::randomUUID pour créer un flux d’identifiants uniques destiné à la génération d’ID par lots.

List<String> ids = Stream.generate(() -> UUID.randomUUID().toString())
    .limit(100)
    .collect(Collectors.toList());
System.out.println(ids.size()); // 100

Fibonacci avec iterate

Générez les nombres de Fibonacci à l’aide d’un état constitué d’une paire. La version à deux arguments de iterate de Java 9 rend cette approche élégante.

Stream.iterate(new long[]{0, 1}, p -> new long[]{p[1], p[0]+p[1]})
    .limit(10)
    .map(p -> p[0])
    .forEach(System.out::println); // 0 1 1 2 3 5 8 13 21 34

takeWhile et dropWhile (Java 9+)

takeWhile(predicate) prend les éléments tant que le prédicat est vérifié, puis s’arrête. dropWhile ignore les éléments jusqu’à ce que le prédicat soit faux, puis prend le reste.

// takeWhile stops at the first element where predicate is false:
Stream.iterate(1, n -> n + 1)
    .takeWhile(n -> n < 10)
    .forEach(System.out::println); // 1 2 3 4 5 6 7 8 9

Flux infinis pour l’interrogation périodique

Modélisez une boucle d’interrogation périodique avec generate : générez les résultats des vérifications, appliquez takeWhile tant que la condition n’est pas remplie, puis prenez le premier succès.

Optional<String> result = Stream.generate(() -> checkJobStatus(jobId))
    .takeWhile(status -> status.equals("PENDING"))
    .findFirst();
// When job completes, takeWhile stops and findFirst gets "DONE"

IntStream.range et rangeClosed

Pour les suites entières finies, IntStream.range(start, end) et rangeClosed(start, end) sont plus efficaces que iterate.

// Sum 1 to 1000:
int sum = IntStream.rangeClosed(1, 1000).sum();
System.out.println(sum); // 500500

LongStream.iterate pour les suites de type long

Utilisez LongStream.iterate pour les suites de type long afin d’éviter le surcoût de la conversion automatique en objets de Stream<Long>.

long sumOfPrimes = LongStream.iterate(2, n -> n + 1)
    .filter(n -> isPrime(n))
    .limit(1000)
    .sum();

Les flux infinis sont paresseux

Les flux infinis ne précalculent pas les éléments. Chaque élément est généré uniquement lorsque l’opération terminale le demande. Cette évaluation différée rend les flux infinis pratiques.

Vérification rapide

Quel mécanisme d’arrêt est requis lors de l’utilisation d’un flux infini ?

Récapitulatif

iterate(seed, f) pour les séquences, generate(supplier) pour générer des éléments indépendants. Ajoutez toujours une opération terminale à court-circuit (limit, takeWhile, findFirst). Les flux infinis sont paresseux : ils ne sont matérialisés qu’à la demande.

Questions Fréquemment Posées

La leçon « Flux infinis avec iterate et generate » est-elle gratuite ?

Oui — le texte complet de « Flux infinis avec iterate et generate » 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 Java Academy, passe à CoddyKit PRO. Le cours Java Academy comprend 4 leçons au total.

Qu'est-ce que j'apprendrai dans « Flux infinis avec iterate et generate » ?

Créez des flux infinis avec Stream.iterate et Stream.generate, puis utilisez une limite ou take-while pour les arrêter. Tu pratiques Java 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 Java Academy ?

Aucune expérience préalable n'est requise. Java 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 « Flux infinis avec iterate et generate » ?

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 Java Academy ?

Oui. Chaque leçon Java 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

  1. flatMap pour les collections imbriquées
  2. Flux parallèles : performances et pièges
  3. Spliterator : division pour le parallélisme
  4. Flux infinis avec iterate et generate
← Retour à Java Academy