Base di conoscenzaCentro esami
ITItaliano
Scegli la lingua13

CKTIS / Java

Stream — pipeline di elaborazione degli elementi

Stream<T> elabora riferimenti a oggetti attraverso un pipeline lazy. Scopri come creare stream, ottenere array di risultati, mappare a tipi primitivi e quali garanzie offre l’ordine di incontro.

Versione: Java SE 21; repository runtime, production runtime not attested

Sintassi

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> descrive l’elaborazione degli elementi, non una raccolta che memorizza dati. Un pipeline comprende una sorgente, operazioni intermedie e un’operazione terminale. Le operazioni intermedie sono lazy: è l’operazione terminale ad avviare l’elaborazione.

Stream.of(T) crea uno stream con un solo elemento; Stream.of(T... values) crea uno stream sequenziale e ordinato dei valori forniti. Non riutilizzare uno stream già consumato; creane uno nuovo per un altro calcolo. Le funzioni di mapping non dovrebbero modificare la sorgente né dipendere da uno stato mutabile.

Stream.toArray() termina il pipeline e restituisce Object[]. L’overload Stream.toArray(String[]::new) crea un String[]; un tipo di elemento incompatibile causa ArrayStoreException. Stream.mapToInt e Stream.mapToLong sono operazioni intermedie che restituiscono rispettivamente IntStream e LongStream. I loro metodi toArray() restituiscono rispettivamente int[] e long[], non array di oggetti wrapper.

Stream.forEachOrdered termina il pipeline ed esegue le azioni nell’ordine di incontro, se definito, anche durante l’elaborazione parallela. Non ordina i dati né garantisce che le azioni siano eseguite da un solo thread. Al contrario, forEach in parallelo non garantisce l’ordine.

Ambito della documentazione: Java SE 21, l’ambiente di esecuzione del repository. L’ambiente di esecuzione in produzione non è attestato.

Esempi

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

Risultato

[sun, moon]
[3, 4]
[3, 4]
sun
moon

Il codice mostrato e il risultato dichiarato sono stati verificati in un ambiente isolato con il metodo registrato nella prova di verifica di questa versione esatta.

Fonti