Come posso creare uno stream da un array?

Attualmente, ogni volta che devo creare un flusso da un array, lo faccio

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

Esiste un modo diretto per creare stream da un array?

Puoi usare Arrays.stream ad es

Arrays.stream(array);

Puoi anche usare Stream.ofcome indicato da @fge, che sembra

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

Ma la nota Stream.of(intArray)verrà restituita Stream<int[]>mentre Arrays.stream(intArr)verrà restituita IntStreamfornendo una matrice di tipo int[]. Quindi, in breve, per il tipo di primitive è possibile osservare la differenza tra 2 metodi, ad es

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

IntStream stream2 = Arrays.stream(arr); 

Quando si passa alla matrice primitiva Arrays.stream, viene richiamato il seguente codice

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

e quando si passa la matrice primitiva al Stream.ofseguente codice viene richiamato

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

Quindi ottieni risultati diversi.

Aggiornato : come menzionato dal commento di Stuart MarksArrays.stream È preferibile utilizzare Stream.of(array).skip(n).limit(m)il sovraccarico subrange perché il primo risulta in un flusso SIZED mentre il secondo no. Il motivo è che limit(m)non sa se la dimensione è m o inferiore a m, mentre Arrays.streamcontrolla gli intervalli e conosce la dimensione esatta del flusso È possibile leggere il codice sorgente per l'implementazione del flusso restituito Arrays.stream(array,start,end) qui , mentre per l'implementazione del flusso restituito Stream.of(array).skip().limit()è all'interno di questo metodo .

Alternativa alla soluzione di @ sol4me:

Stream.of(theArray)

Della differenza tra questo e Arrays.stream(): fa la differenza se l'array è di tipo primitivo. Ad esempio, se lo fai:

Arrays.stream(someArray)

dove someArrayè a long[], restituirà a LongStream. Stream.of(), d'altra parte, restituirà a Stream<long[]>con un singolo elemento.

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

Oppure, se hai già un array, puoi anche farlo

Stream.of(array) 

Per tipi primitivi usare IntStream.ofo LongStream.ofecc.

Puoi farlo anche con un metodo di basso livello che ha un'opzione parallela:

Aggiornamento: usa array.length completo (non lunghezza - 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)

Puoi usare Arrays.stream:

Arrays.stream (array); 

Ciò garantisce il tipo di ritorno di vapore in base al tipo di input dell'array se String []poi ritorna Stream<String>, se int []poi ritornaIntStream

Quando conosci già l'array del tipo di input, allora è bene usarne uno specifico come per il tipo di input int[]

 IntStream.of (array); 

Questo restituisce Intstream.

Nel primo esempio, Java utilizza il metodo overloadingper trovare un metodo specifico basato sui tipi di input, mentre come nel secondo si conosce già il tipo di input e il metodo specifico di chiamata.

raramente visto, ma questo è il modo più diretto

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