java - studio - ¿Cómo puedo crear una secuencia desde una matriz?

matriz cuadrada java

Question

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?

Answer 1

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 someArray es un long[] , devolverá un LongStream . Stream.of() , por otro lado, devolverá un Stream<long[]> con un solo elemento.

Answer 2

Puedes usar Arrays.stream Eg

Arrays.stream(array);

También puede usar Stream.of como lo menciona @fge, que parece

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

Pero tenga en cuenta Stream.of(intArray) devolverá Stream<int[]> mientras que Arrays.stream(intArr) devolverá IntStream siempre que pase una matriz de tipo int[] . En pocas palabras, para el tipo de primitivas, puede observar la diferencia entre 2 métodos, por ejemplo

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

IntStream stream2 = Arrays.stream(arr); 

Cuando pasa una 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 a Stream.of del siguiente 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.stream es preferible a usar Stream.of(array).skip(n).limit(m) porque el primero da como resultado un flujo TAMAÑO mientras que el segundo no. La razón es que el limit(m) no sabe si el tamaño es m o menor que m, mientras que Arrays.stream realiza comprobaciones de rango y conoce el tamaño exacto de la secuencia. Puede leer el código fuente para la implementación de la secuencia devuelta por las Arrays.stream(array,start,end) here , mientras que para la implementación de stream devuelta por Stream.of(array).skip().limit() está dentro de este método .

Answer 3

Puedes usar Arrays.stream:

Arrays.stream(array);

Esto garantiza el tipo de retorno de vapor basado en el tipo de entrada de su matriz si es String [] luego devuelve Stream<String> , si int [] devuelve IntStream

Cuando ya conoces el tipo de entrada, entonces es bueno usar uno específico como el tipo de entrada int[]

IntStream.of(array);

Esto devuelve Intstream.

En el primer ejemplo, Java utiliza la overloading métodos para encontrar métodos específicos basados ​​en tipos de entrada, mientras que en el segundo ya conoce el tipo de entrada y el método específico de llamada.

Answer 4

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

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

Answer 5

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

Answer 6

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

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

Stream.of(array) 

Para tipos primitivos, use IntStream.of o LongStream.of etc.