0Pricing
Java Academy · Lección

Generación de streams de tipos primitivos

iterate y generate

Generación de streams de tipos primitivos 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.

Los streams infinitos necesitan límites

iterate y generate crean streams potencialmente infinitos. Debe añadir limit (o un predicado) para hacerlos finitos.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        IntStream.iterate(1, n -> n + 1)
            .limit(5)
            .forEach(System.out::println);
    }
}

Iterar con una semilla

iterate(seed, next) comienza con la semilla y aplica repetidamente la función al valor anterior.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        IntStream.iterate(2, n -> n * 2)
            .limit(5)
            .forEach(System.out::println);
    }
}

Iterar con un predicado

La versión de tres argumentos iterate(seed, hasNext, next) se detiene automáticamente cuando el predicado es falso, como un bucle for funcional.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        IntStream.iterate(1, n -> n <= 100, n -> n * 3)
            .forEach(System.out::println);
    }
}

Generar con un proveedor

generate recibe un IntSupplier que produce cada elemento de forma independiente, sin depender del valor anterior.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        IntStream.generate(() -> 7)
            .limit(3)
            .forEach(System.out::println);
    }
}

Generar números aleatorios

El proveedor de generate puede llamar a una fuente aleatoria. Aquí, cada elemento es el resultado independiente de lanzar un dado.

import java.util.Random;
import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        Random rnd = new Random(42);
        IntStream.generate(() -> rnd.nextInt(6) + 1)
            .limit(5)
            .forEach(System.out::println);
    }
}

Iterar frente a generar

Diferencia clave:

  • iterate: cada valor se deriva del anterior (secuencias).
  • generate: cada valor se produce de forma independiente (constantes, valores aleatorios).
import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        int sum = IntStream.iterate(1, n -> n + 1).limit(10).sum();
        System.out.println(sum);
    }
}

Agregar streams generados

Una vez limitados, los streams generados admiten todas las operaciones de agregación habituales.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        long count = IntStream.iterate(0, n -> n + 2)
            .limit(50)
            .filter(n -> n % 3 == 0)
            .count();
        System.out.println(count);
    }
}

Fibonacci con iterate en un stream de objetos

Para secuencias con estado, como Fibonacci, use Stream.iterate sobre un par de elementos en un array y, después, vuelva a convertirlos a int.

import java.util.stream.Stream;

public class Main {
    public static void main(String[] args) {
        Stream.iterate(new int[]{0, 1}, p -> new int[]{p[1], p[0] + p[1]})
            .limit(8)
            .mapToInt(p -> p[0])
            .forEach(System.out::println);
    }
}

Construir un array a partir de un generador

Combine un generador con toArray para construir mediante un procedimiento un array de tipos primitivos.

import java.util.Arrays;
import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        int[] squares = IntStream.iterate(1, n -> n + 1)
            .limit(5)
            .map(n -> n * n)
            .toArray();
        System.out.println(Arrays.toString(squares));
    }
}

La evaluación diferida ahorra trabajo

Los streams son perezosos: con limit, solo se generan los elementos necesarios, incluso a partir de una fuente infinita.

import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        int first = IntStream.iterate(10, n -> n + 10)
            .filter(n -> n > 25)
            .findFirst()
            .getAsInt();
        System.out.println(first);
    }
}

Prefiera la forma con predicado

El iterate basado en un predicado suele ser más claro que iterate(...).limit(...), porque la condición de detención se encuentra junto a la lógica de generación.

import java.util.stream.LongStream;

public class Main {
    public static void main(String[] args) {
        long product = LongStream.iterate(1, n -> n <= 5, n -> n + 1)
            .reduce(1, (a, b) -> a * b);
        System.out.println(product);
    }
}

Comprobación rápida

¿Qué ocurre si llama a generate sin un limit y, después, a una operación terminal como forEach?

Resumen

Ha generado streams de tipos primitivos:

  • iterate deriva cada valor del anterior.
  • generate produce valores de forma independiente a partir de un proveedor.
  • Ambos son infinitos; limítelos con limit o con la forma de iterate que usa un predicado.
  • La evaluación diferida significa que solo se calculan los elementos necesarios.

Preguntas frecuentes

¿La lección «Generación de streams de tipos primitivos» es gratis?

Sí — el texto completo de «Generación de streams de tipos primitivos» 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 «Generación de streams de tipos primitivos»?

iterate y generate 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 «Generación de streams de tipos primitivos»?

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

  1. IntStream y LongStream
  2. Operaciones de rango y agregación
  3. Mapeo hacia y desde streams de objetos
  4. Generación de streams de tipos primitivos
← Volver a Java Academy