Streams infinitos con iterate y generate
Cree streams infinitos con Stream.iterate y Stream.generate, y después use limit o take-while para detenerlos.
Streams infinitos con iterate y generate es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 4 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Java Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Java Academy incluye 4 lecciones en total.
¿Qué son los streams infinitos?
Los streams de Java pueden ser infinitos: producen elementos bajo demanda y no tienen fin. Deben terminar con una operación limitadora (limit, takeWhile, findFirst, etc.) para evitar que se ejecuten indefinidamente.
Stream.iterate: secuencias con semilla
Stream.iterate(seed, f) genera un stream infinito aplicando repetidamente f al valor anterior. El primer elemento es la semilla.
// Infinite even numbers: 0, 2, 4, 6, 8, ...
Stream.iterate(0, n -> n + 2)
.limit(10)
.forEach(System.out::println);iterate con Predicate (Java 9+)
Stream.iterate(seed, predicate, f) añade una condición de parada, como un bucle for con una condición. El stream se detiene cuando el predicado es falso.
// 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 64Stream.generate: generador sin estado
Stream.generate(Supplier) llama al proveedor para cada elemento. El proveedor puede no tener estado (números aleatorios) o tenerlo (mediante un contador externo).
// Infinite random doubles between 0.0 and 1.0:
Stream.generate(Math::random)
.limit(5)
.forEach(System.out::println);Generar UUID
Use generate con UUID::randomUUID para crear un stream de identificadores únicos destinado a generar ID por lotes.
List<String> ids = Stream.generate(() -> UUID.randomUUID().toString())
.limit(100)
.collect(Collectors.toList());
System.out.println(ids.size()); // 100Fibonacci con iterate
Genere números de Fibonacci mediante un par como estado. El método iterate de dos argumentos de Java 9 hace que esto resulte elegante.
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 34takeWhile y dropWhile (Java 9+)
takeWhile(predicate) toma elementos mientras se cumple el predicado y después se detiene. dropWhile omite elementos hasta que el predicado deja de cumplirse y, a continuación, toma el resto.
// 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 9Streams infinitos para hacer polling de reintentos
Modele un bucle de polling con generate: genere resultados de comprobación, use takeWhile mientras no se cumpla la condición y, después, tome el primer resultado correcto.
Optional<String> result = Stream.generate(() -> checkJobStatus(jobId))
.takeWhile(status -> status.equals("PENDING"))
.findFirst();
// When job completes, takeWhile stops and findFirst gets "DONE"IntStream.range y rangeClosed
Para secuencias enteras finitas, IntStream.range(start, end) y rangeClosed(start, end) son más eficientes que iterate.
// Sum 1 to 1000:
int sum = IntStream.rangeClosed(1, 1000).sum();
System.out.println(sum); // 500500LongStream.iterate para secuencias long
Use LongStream.iterate para secuencias de tipo long y evite la sobrecarga del autoboxing de Stream<Long>.
long sumOfPrimes = LongStream.iterate(2, n -> n + 1)
.filter(n -> isPrime(n))
.limit(1000)
.sum();Los streams infinitos son perezosos
Los streams infinitos no calculan previamente los elementos. Cada elemento se genera únicamente cuando la operación terminal lo solicita. Esta evaluación perezosa hace que los streams infinitos sean prácticos.
Comprobación rápida
¿Qué mecanismo de parada es necesario al trabajar con un stream infinito?
Repaso
iterate(seed, f) para secuencias y generate(supplier) para generar elementos independientes. Añada siempre una operación terminal de cortocircuito (limit, takeWhile, findFirst). Los streams infinitos son perezosos: solo se materializan bajo demanda.
Preguntas frecuentes
¿La lección «Streams infinitos con iterate y generate» es gratis?
Sí — el texto completo de «Streams infinitos con iterate y generate» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Java Academy, actualiza a CoddyKit PRO. El curso de Java Academy incluye 4 lecciones en total.
¿Qué aprenderé en «Streams infinitos con iterate y generate»?
Cree streams infinitos con Stream.iterate y Stream.generate, y después use limit o take-while para detenerlos. Practicas Java Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.
¿Necesito experiencia previa para empezar Java Academy?
No se requiere experiencia previa. Java Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 4 de 4.
¿Cuánto tiempo toma la lección «Streams infinitos con iterate y generate»?
La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.
¿Puedo escribir y ejecutar código en esta lección de Java Academy?
Sí. Cada lección de Java Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.
Todas las lecciones de este curso
- flatMap para colecciones anidadas
- Streams paralelos: rendimiento y dificultades
- Spliterator: división para el paralelismo
- Streams infinitos con iterate y generate