Base de conocimientosCentro de exámenes
ESEspañol
Elegir idioma13

CKTIS / Java

Operaciones numéricas con IntStream

Crea y filtra flujos de valores primitivos `int`. Distingue los tipos de resultado y qué ocurre al contar, sumar o calcular la media de un flujo vacío.

Versión: Java SE 21

Sintaxis

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()

En Java SE 21, java.util.stream.IntStream procesa valores primitivos int en lugar de objetos Integer. El método de fábrica estático IntStream.of tiene dos sobrecargas: of(int) crea un flujo secuencial de un solo elemento y of(int...) crea un flujo secuencial en el orden en que se pasan los valores. La segunda sobrecarga también admite un array int[] o ningún argumento, en cuyo caso el flujo queda vacío.

IntStream.filter(IntPredicate) es una operación intermedia de evaluación diferida. Devuelve un flujo que solo contiene los elementos para los que el predicado devuelve true. El predicado no debe modificar el origen ni depender de un estado que cambie durante el procesamiento. En n -> n % 2 == 0, % calcula el resto de la división entre 2 y == 0 comprueba si ese resto es cero.

Las operaciones terminales devuelven tipos distintos: IntStream.count() devuelve el número de elementos como long, mientras que IntStream.sum() devuelve la suma como int. Ambas devuelven cero si el flujo está vacío. La suma puede desbordar el rango de int sin lanzar una excepción; asignarla a una variable long no evita el desbordamiento. IntStream.average() devuelve la media aritmética en un OptionalDouble, que está vacío si no hay elementos. Usa orElse(...) para elegir un valor alternativo explícito.

Una operación terminal consume la cadena de operaciones. Para hacer otro cálculo independiente con los mismos datos, crea un flujo nuevo a partir del origen. Reutilizar un flujo no está permitido y, si se detecta, puede provocar una IllegalStateException.

Ejemplos

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 comienza con una nueva llamada a `IntStream.of(values)`. El filtro de pares conserva `2` y `10`. El filtro de negativos no conserva nada, por lo que `NaN` procede del valor alternativo explícito y no de `average()`.

Lecciones relacionadas

  • Java · Lección 46 · Intermedio · Versión: 2

Fuentes