Java Academy · Aula

Gerando streams de tipos primitivos

iterate e generate.

Gerando streams de tipos primitivos é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 4 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

Fluxos infinitos precisam de limites

iterate e generate criam fluxos potencialmente infinitos. Você deve adicionar limit (ou um predicado) para torná-los 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);
    }
}

iterate com uma semente

iterate(seed, next) começa pela semente e aplica repetidamente a função ao 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);
    }
}

iterate com um predicado

O iterate(seed, hasNext, next) de três argumentos para automaticamente quando o predicado é falso, como um laço 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);
    }
}

generate com um fornecedor

generate recebe um IntSupplier que produz cada elemento de forma independente, sem depender do 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);
    }
}

Gerando números aleatórios

Um fornecedor de generate pode chamar uma fonte de aleatoriedade. Aqui, cada elemento é o resultado independente de um lançamento de 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);
    }
}

iterate versus generate

Diferença fundamental:

iterate: cada valor é derivado do anterior (sequências).
generate: cada valor é produzido de forma independente (constantes, valores aleatórios).

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);
    }
}

Agregando fluxos gerados

Depois de limitados, os fluxos gerados aceitam todas as agregações usuais.

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 com iterate em um fluxo de objetos

Para sequências com estado, como Fibonacci, use Stream.iterate sobre um par de vetores e depois converta novamente para 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);
    }
}

Construindo um vetor a partir de um gerador

Combine um gerador com toArray para construir proceduralmente um vetor 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));
    }
}

A avaliação tardia economiza trabalho

Os fluxos são avaliados de forma tardia: com limit, somente os elementos necessários são gerados, mesmo a partir de uma fonte 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);
    }
}

Prefira a forma com predicado

O iterate baseado em predicado costuma ser mais claro que iterate(...).limit(...), pois a condição de parada fica junto da lógica de geração.

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);
    }
}

Verificação rápida

O que acontece se você chamar generate sem um limit e depois uma operação terminal, como forEach?

Recapitulação

Você gerou fluxos de tipos primitivos:

iterate deriva cada valor do anterior.
generate produz valores de forma independente a partir de um fornecedor.
Ambos são infinitos; limite-os com limit ou com a forma de iterate que usa um predicado.
A avaliação tardia significa que somente os elementos necessários são calculados.

Perguntas Frequentes

A aula “Gerando streams de tipos primitivos” é grátis?

Sim — o texto completo de “Gerando streams de tipos primitivos” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “Gerando streams de tipos primitivos”?

iterate e generate. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 4 de 4.

Quanto tempo leva a aula “Gerando streams de tipos primitivos”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Java Academy