Base de conhecimentoCentro de Exames
PT · PTPortuguês (Portugal)
Escolher idioma13

CKTIS / Java

Arrays.stream(T[]): criar um fluxo a partir de um array

Usa um array de elementos de tipo referência como origem de um fluxo sequencial, filtra os elementos e guarda o resultado num array do tipo adequado.

Versão: Java SE 21

Sintaxe

public static <T> Stream<T> stream(T[] array)

Arrays.stream(T[]) é um método estático de java.util.Arrays, disponível desde o Java 8. Usa um array de elementos de tipo referência como origem de um fluxo sequencial java.util.stream.Stream<T>, por ordem de índice. Por exemplo, um String[] dá origem a um Stream<String>. O método não copia o array de origem; passar uma referência de array null lança NullPointerException.

As operações intermédias como filter são avaliadas de forma diferida: o processamento começa quando se chama uma operação terminal como toArray(). Não alteres o array de origem durante o processamento. Não reutilizes o mesmo fluxo após uma operação terminal. Para processares novamente o array, cria um novo fluxo.

A sobrecarga com intervalo, Arrays.stream(array, startInclusive, endExclusive), inclui o índice inicial e exclui o índice final. Exige 0 <= startInclusive <= endExclusive <= array.length; limites inválidos provocam ArrayIndexOutOfBoundsException. As sobrecargas para int[], long[] e double[] devolvem, respetivamente, IntStream, LongStream e DoubleStream. Não existe uma sobrecarga direta para outros arrays unidimensionais de tipos primitivos, como boolean[].

Num Stream<T>, o método sem argumentos toArray() tem como tipo de retorno declarado Object[], mas o Java SE 21 não especifica a classe exata do array devolvido em tempo de execução. Não faças um cast do resultado para String[]; se precisares de um String[], usa toArray(String[]::new) num fluxo de cadeias de caracteres.

Ao usar reflexão, podes passar o Object[] resultante a Constructor.newInstance(Object...). Os seus elementos tornam-se, por ordem, os argumentos do construtor selecionado. O número, a ordem e os tipos dos argumentos têm de corresponder aos parâmetros do construtor, tendo em conta as conversões permitidas. Um número incorreto de argumentos ou um tipo incompatível provoca IllegalArgumentException.

Exemplos

import java.util.Arrays;

public class Main {
    public record Pair(String first, String second) {}

    public static void main(String[] args) throws ReflectiveOperationException {
        String[] input = {"Ada", " ", "Lin"};
        Object[] arguments = Arrays.stream(input)
                .filter(name -> !name.isBlank())
                .toArray();

        Pair pair = Pair.class.getConstructor(String.class, String.class)
                .newInstance(arguments);

        System.out.println(Arrays.toString(arguments));
        System.out.println(pair.first() + " / " + pair.second());
    }
}

Resultado

[Ada, Lin]
Ada / Lin

`filter` exclui a cadeia que contém apenas um espaço. `toArray()` coloca `Ada` e `Lin` num `Object[]` por essa ordem, e `newInstance` passa-os como dois argumentos ao construtor de `Pair`.

Lições relacionadas

  • Java · Lição 59 · Avançado · Versão: 2
  • Java · Lição 63 · Básico · Versão: 2

Fontes