CKTIS / Java
Stream — pipelines de traitement des éléments
Stream<T> traite des références d’objets au moyen d’un pipeline paresseux. Découvrez la création de flux, les tableaux de résultats, les conversions vers des types primitifs et les garanties liées à l’ordre de rencontre.
Version : Java SE 21; repository runtime, production runtime not attested
Syntaxe
Stream.of(values).mapToInt(mapper)
Stream.of(values).mapToLong(mapper)
Stream.of(values).toArray()
Stream.of(values).toArray(String[]::new)
Stream.of(values).forEachOrdered(action)java.util.stream.Stream<T> décrit le traitement d’éléments, et non une collection qui stocke des données. Un pipeline comprend une source, des opérations intermédiaires et une opération terminale. Les opérations intermédiaires sont paresseuses : l’opération terminale déclenche le traitement.
Stream.of(T) crée un flux à un seul élément ; Stream.of(T... values) crée un flux séquentiel et ordonné des valeurs fournies. Ne réutilisez pas un flux consommé ; créez-en un nouveau pour un autre calcul. Les fonctions de mappage ne devraient ni modifier la source ni dépendre d’un état mutable.
Stream.toArray() termine le pipeline et renvoie Object[]. La surcharge Stream.toArray(String[]::new) crée un String[] ; un type d’élément incompatible provoque ArrayStoreException. Stream.mapToInt et Stream.mapToLong sont des opérations intermédiaires qui renvoient respectivement IntStream et LongStream. Leurs méthodes toArray() renvoient respectivement int[] et long[], et non des tableaux d’objets enveloppes.
Stream.forEachOrdered termine le pipeline en exécutant les actions dans l’ordre de rencontre, lorsqu’il est défini, y compris pendant un traitement parallèle. Cette méthode ne trie pas les données et ne garantit pas qu’un seul thread exécute les actions. En revanche, forEach en parallèle ne garantit pas l’ordre.
Périmètre de la documentation : Java SE 21, version utilisée dans l’environnement d’exécution du dépôt. L’environnement d’exécution de production n’est pas attesté.
Exemples
import java.util.Arrays;
import java.util.stream.Stream;
public class Main {
public static void main(String[] args) {
String[] words = Stream.of("sun", "moon").toArray(String[]::new);
int[] lengths = Stream.of(words).mapToInt(String::length).toArray();
long[] sizes = Stream.of(words).mapToLong(s -> (long) s.length()).toArray();
System.out.println(Arrays.toString(words));
System.out.println(Arrays.toString(lengths));
System.out.println(Arrays.toString(sizes));
Stream.of(words).parallel().forEachOrdered(System.out::println);
}
}Résultat
[sun, moon] [3, 4] [3, 4] sun moon
Le code affiché et le résultat déclaré ont été vérifiés dans un environnement isolé selon la méthode consignée dans la preuve de vérification de cette version exacte.