Base de connaissancesCentre d’examen
FRFrançais
Choisir la langue13

CKTIS / Java

Opérations numériques sur IntStream

Créez et filtrez des flux de valeurs primitives `int`, puis distinguez les types retournés et le comportement du comptage, de la somme et de la moyenne sur un flux vide.

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

Dans Java SE 21, java.util.stream.IntStream traite des valeurs primitives int, et non des objets Integer. La méthode de fabrique statique IntStream.of a deux surcharges : of(int) crée un flux séquentiel à un élément, tandis que of(int...) crée un flux séquentiel dans l’ordre des valeurs fournies. Cette seconde surcharge accepte aussi un tableau int[] ou aucun argument, auquel cas le flux est vide.

IntStream.filter(IntPredicate) est une opération intermédiaire à évaluation différée. Le flux obtenu ne contient que les éléments pour lesquels le prédicat renvoie true. Le prédicat ne doit ni modifier la source ni dépendre d’un état qui change pendant le traitement. Dans n -> n % 2 == 0, % calcule le reste de la division par 2 et == 0 vérifie que ce reste vaut zéro.

Les opérations terminales ont des types de retour différents : IntStream.count() renvoie le nombre d’éléments sous forme de long, et IntStream.sum() renvoie la somme sous forme de int. Sur un flux vide, les deux renvoient zéro. La somme peut dépasser la capacité d’un int sans lever d’exception ; l’affecter à une variable long ne prévient pas le débordement. IntStream.average() renvoie la moyenne arithmétique dans un OptionalDouble, vide si le flux ne contient aucun élément. Utilisez orElse(...) pour choisir explicitement une valeur de repli.

Une opération terminale consomme la chaîne d’opérations. Pour effectuer un autre calcul indépendant sur les mêmes données, créez un nouveau flux à partir de la source. Il est interdit de réutiliser le flux ; si cette réutilisation est détectée, une IllegalStateException peut être levée.

Exemples

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

Résultat

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

Chaque calcul commence par un nouvel appel à `IntStream.of(values)`. Le filtre des nombres pairs conserve `2` et `10`. Le filtre des nombres négatifs ne conserve rien : `NaN` vient donc de la valeur de repli explicite, et non de `average()`.

Leçons associées

  • Java · Leçon 46 · Intermédiaire · Version : 2

Sources