Como posso criar um fluxo a partir de uma matriz?

Atualmente, sempre que preciso criar fluxo a partir de uma matriz, eu faço

String[] array = {"x1", "x2"};
Arrays.asList(array).stream();

Existe alguma maneira direta de criar fluxo a partir de uma matriz?

Você pode usar Arrays.stream Eg

Arrays.stream(array);

Você também pode usar Stream.ofcomo mencionado pelo @fge, que parece

public static<T> Stream<T> of(T... values) {
    return Arrays.stream(values);
}

Mas note Stream.of(intArray)que retornará Stream<int[]>enquanto Arrays.stream(intArr)retornará, IntStreamdesde que você passe uma matriz do tipo int[]. Então, em poucas palavras, para o tipo de primitivos, você pode observar a diferença entre 2 métodos.

int[] arr = {1, 2};
Stream<int[]> arr1 = Stream.of(arr);

IntStream stream2 = Arrays.stream(arr); 

Quando você passa a matriz primitiva para Arrays.stream, o código a seguir é chamado

public static IntStream stream(int[] array) {
    return stream(array, 0, array.length);
}

e quando você passa a matriz primitiva para Stream.ofo código a seguir, é chamado

 public static<T> Stream<T> of(T t) {
     return StreamSupport.stream(new Streams.StreamBuilderImpl<>(t), false);
 }

Portanto, você obtém resultados diferentes.

Atualizado : como mencionado por Stuart Marks comment A sobrecarga de subintervalos Arrays.streamé preferível ao uso, Stream.of(array).skip(n).limit(m)porque o primeiro resulta em um fluxo SIZED, enquanto o último não. O motivo é que limit(m)não se sabe se o tamanho é m ou menor que m, enquanto Arrays.streamo range verifica e sabe o tamanho exato do fluxo Você pode ler o código-fonte para a implementação do fluxo retornado por Arrays.stream(array,start,end) aqui , enquanto que para a implementação do fluxo retornado por Stream.of(array).skip().limit()é dentro deste método .

Alternativa à solução da @ sol4me:

Stream.of(theArray)

Da diferença entre this e Arrays.stream(): faz diferença se sua matriz é de um tipo primitivo. Por exemplo, se você fizer:

Arrays.stream(someArray)

onde someArrayé a long[], retornará a LongStream. Stream.of(), por outro lado, retornará a Stream<long[]>com um único elemento.

Stream.of("foo", "bar", "baz")

Ou, se você já possui uma matriz, também pode fazer

Stream.of(array) 

Para tipos primitivos, use IntStream.ofou LongStream.ofetc.

Você pode fazer isso também pelo método de baixo nível, que tem a opção paralela:

Atualização: Use array.length completo (não comprimento - 1).

/** 
 * Creates a new sequential or parallel {@code Stream} from a
 * {@code Spliterator}.
 *
 * <p>The spliterator is only traversed, split, or queried for estimated
 * size after the terminal operation of the stream pipeline commences.
 *
 * @param <T> the type of stream elements
 * @param spliterator a {@code Spliterator} describing the stream elements
 * @param parallel if {@code true} then the returned stream is a parallel
 *        stream; if {@code false} the returned stream is a sequential
 *        stream.
 * @return a new sequential or parallel {@code Stream}
 *
 * <T> Stream<T> stream(Spliterator<T> spliterator, boolean parallel)
 */

StreamSupport.stream(Arrays.spliterator(array, 0, array.length), true)

Você pode usar Arrays.stream:

Arrays.stream (matriz); 

Isso garante o tipo de retorno de vapor com base no tipo de entrada do seu array, se String []então retornar Stream<String>, se int []retornarIntStream

Quando você já conhece a matriz de tipos de entrada, é bom usar uma matriz específica, como para o tipo de entrada int[]

 IntStream.of (matriz); 

Isso retorna o Intstream.

No primeiro exemplo, Java usa o método overloadingpara localizar um método específico com base nos tipos de entrada, enquanto no segundo você já conhece o tipo de entrada e chama o método específico.

raramente visto, mas esta é a maneira mais direta

Stream.Builder<String> builder = Stream.builder();
for( int i = 0; i < array.length; i++ )
  builder.add( array[i] );
Stream<String> stream = builder.build();