¿Cómo puedo crear una secuencia desde una matriz?

Actualmente, cada vez que necesito crear una secuencia desde una matriz, lo hago

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

¿Hay alguna forma directa de crear una secuencia desde una matriz?

Puedes usar Arrays.stream Eg

Arrays.stream(array);

También puede usar Stream.ofcomo lo menciona @fge, que se ve así

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

Pero note Stream.of(intArray)volverá Stream<int[]>mientras Arrays.stream(intArr)que regresará IntStreamsiempre que pase una matriz de tipos int[]. Entonces, en pocas palabras para los tipos primitivos, puede observar la diferencia entre 2 métodos

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

IntStream stream2 = Arrays.stream(arr); 

Cuando pasa matriz primitiva a Arrays.stream, se invoca el siguiente código

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

y cuando pasa matriz primitiva al Stream.ofsiguiente código se invoca

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

Por lo tanto, obtienes resultados diferentes.

Actualizado : como lo menciona el comentario de Stuart Marks. La sobrecarga de subrango de Arrays.streames preferible a usar Stream.of(array).skip(n).limit(m)porque la primera da como resultado una secuencia TAMAÑO mientras que la segunda no. La razón es que limit(m)no sabe si el tamaño es m o menor que m, mientras Arrays.streamque comprueba el rango y conoce el tamaño exacto de la secuencia. Puede leer el código fuente para la implementación de la secuencia devuelta Arrays.stream(array,start,end) aquí , mientras que para la implementación de la secuencia devuelta Stream.of(array).skip().limit()es dentro de este método .

Alternativa a la solución de @ sol4me:

Stream.of(theArray)

De la diferencia entre esto y Arrays.stream(): hace una diferencia si su matriz es de un tipo primitivo. Por ejemplo, si haces:

Arrays.stream(someArray)

donde someArrayes a long[], devolverá unLongStream . Stream.of(), por otro lado, devolverá un Stream<long[]>con un solo elemento.

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

O, si ya tiene una matriz, también puede hacer

Stream.of(array) 

Para tipos primitivos use IntStream.ofo LongStream.ofetc.

También puede hacerlo mediante un método de bajo nivel que tiene una opción paralela:

Actualización: Use full array.length (no length - 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)

Puedes usar Arrays.stream:

Arrays.stream (matriz); 

Esto asegura el tipo de retorno de vapor basado en el tipo de entrada de su matriz si String []luego se devuelve Stream<String>, siint [] luego regresaIntStream

Cuando ya conoces la matriz de tipo de entrada, entonces es bueno usar una específica como tipo de entrada int[]

 IntStream.of (matriz); 

Esto devuelve Intstream.

En el primer ejemplo, Java usa un método overloadingpara encontrar un método específico basado en tipos de entrada, mientras que en el segundo ya conoce el tipo de entrada y el método específico de llamada.

rara vez visto, pero esta es la forma más directa

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