Znalostní bázeCentrum zkoušek
CSČeština
Vybrat jazyk13

CKTIS / Java

Číselné operace s IntStream

Vytvářej a filtruj proudy primitivních hodnot `int` a rozlišuj návratové typy i chování při počítání prvků, sčítání a výpočtu průměru prázdného proudu.

Verze: Java SE 21

Syntaxe

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

V Java SE 21 zpracovává java.util.stream.IntStream primitivní hodnoty int, nikoli objekty Integer. Statická tovární metoda IntStream.of má dvě přetížení: of(int) vytvoří sekvenční proud s jedním prvkem a of(int...) vytvoří sekvenční proud v pořadí zadaných hodnot. Druhé přetížení přijímá také pole int[] nebo žádné argumenty, což vytvoří prázdný proud.

IntStream.filter(IntPredicate) je mezilehlá operace s odloženým vyhodnocením. Vrací proud obsahující jen prvky, pro které predikát vrátí true. Predikát nesmí měnit zdroj ani záviset na stavu, který se může během zpracování měnit. Ve výrazu n -> n % 2 == 0 vypočítá % zbytek po dělení číslem 2 a == 0 ověří, zda je tento zbytek nulový.

Koncové operace mají různé návratové typy: IntStream.count() vrací počet prvků jako long, zatímco IntStream.sum() vrací součet jako int. U prázdného proudu vrátí obě nulu. Součet může přetéct bez vyvolání výjimky; přiřazení výsledku do proměnné typu long přetečení int nezabrání. IntStream.average() vrací aritmetický průměr v OptionalDouble, který je prázdný, pokud proud neobsahuje žádné prvky. Pomocí orElse(...) výslovně určíš náhradní hodnotu.

Koncová operace spotřebuje celý řetězec operací. Pro další nezávislý výpočet nad stejnými daty vytvoř ze zdroje nový proud. Opakované použití proudu není povoleno a při jeho zjištění může nastat IllegalStateException.

Příklady

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

Výsledek

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

Každý výpočet začíná novým voláním `IntStream.of(values)`. Filtr sudých čísel ponechá `2` a `10`. Filtr záporných čísel neponechá nic, takže `NaN` pochází z výslovně zvolené náhradní hodnoty, nikoli z `average()`.

Související lekce

  • Java · Lekce 46 · Středně pokročilá · Verze: 2

Zdroje