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