Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / Java

Operações numéricas com IntStream

Cria e filtra fluxos de valores primitivos `int` e distingue os tipos devolvidos e o comportamento da contagem, da soma e da média num fluxo vazio.

Versão: Java SE 21

Sintaxe

import java.util.OptionalDouble;
import java.util.function.IntPredicate;
import java.util.stream.IntStream;

// IntStream method signatures
static IntStream of(int t)
static IntStream of(int... values)
IntStream filter(IntPredicate predicate)
long count()
int sum()
OptionalDouble average()

Em Java SE 21, java.util.stream.IntStream processa valores primitivos int em vez de objetos Integer. O método de fábrica estático IntStream.of tem duas sobrecargas: of(int) cria um fluxo sequencial com um só elemento e of(int...) cria um fluxo sequencial pela ordem dos valores fornecidos. A segunda sobrecarga também aceita um array int[] ou nenhum argumento, caso em que o fluxo fica vazio.

IntStream.filter(IntPredicate) é uma operação intermédia de avaliação adiada. Devolve um fluxo que só contém os elementos para os quais o predicado devolve true. O predicado não deve modificar a origem nem depender de um estado que se altere durante o processamento. Em n -> n % 2 == 0, % calcula o resto da divisão por 2 e == 0 verifica se esse resto é zero.

As operações terminais devolvem tipos diferentes: IntStream.count() devolve a contagem de elementos como long, enquanto IntStream.sum() devolve a soma como int. Ambas devolvem zero se o fluxo estiver vazio. A soma pode exceder o intervalo de int sem lançar uma exceção; atribuir o resultado a um long não evita o transbordo. IntStream.average() devolve a média aritmética num OptionalDouble, que fica vazio se não houver elementos. Usa orElse(...) para escolher explicitamente um valor alternativo.

Uma operação terminal consome a cadeia de operações. Para fazer outro cálculo independente sobre os mesmos dados, cria um novo fluxo a partir da origem. Não é permitido reutilizar um fluxo e, se a reutilização for detetada, pode ser lançada uma IllegalStateException.

Exemplos

import java.util.OptionalDouble;
import java.util.stream.IntStream;

public class Main {
    public static void main(String[] args) {
        int[] values = {2, 3, 7, 10};

        long count = IntStream.of(values).count();
        int sum = IntStream.of(values).sum();
        OptionalDouble average = IntStream.of(values).average();
        int evenSum = IntStream.of(values).filter(n -> n % 2 == 0).sum();
        OptionalDouble negativeAverage = IntStream.of(values)
                .filter(n -> n < 0)
                .average();

        System.out.println("count = " + count);
        System.out.println("sum = " + sum);
        System.out.println("average = " + average.orElse(Double.NaN));
        System.out.println("even sum = " + evenSum);
        System.out.println("negative average = " + negativeAverage.orElse(Double.NaN));
    }
}

Resultado

count = 4
sum = 22
average = 5.5
even sum = 12
negative average = NaN

Cada cálculo começa com uma nova chamada a `IntStream.of(values)`. O filtro dos números pares mantém `2` e `10`. O filtro dos números negativos não mantém nenhum elemento, pelo que `NaN` vem do valor alternativo explícito, não de `average()`.

Lições relacionadas

  • Java · Lição 46 · Intermédio · Versão: 2

Fontes