Comment puis-je créer un flux à partir d'un tableau?

Actuellement, chaque fois que j'ai besoin de créer un flux à partir d'un tableau, je le fais

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

Existe-t-il un moyen direct de créer un flux à partir d'un tableau?

Vous pouvez utiliser Arrays.stream Eg

Arrays.stream(array);

Vous pouvez également utiliser Stream.ofcomme mentionné par @fge, qui ressemble à

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

Mais note Stream.of(intArray)retournera Stream<int[]>alors que Arrays.stream(intArr)retournera à IntStreamcondition que vous passiez un tableau de type int[]. Donc, en un mot pour le type primitif, vous pouvez observer la différence entre 2 méthodes Eg

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

IntStream stream2 = Arrays.stream(arr); 

Lorsque vous passez un tableau primitif à Arrays.stream, le code suivant est appelé

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

et lorsque vous passez un tableau primitif au Stream.ofcode suivant, il est appelé

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

Par conséquent, vous obtenez des résultats différents.

Mise à jour : comme mentionné par le commentaire de Stuart Marks La surcharge de sous-plage de Arrays.streamest préférable à l'utilisation Stream.of(array).skip(n).limit(m)car la première donne un flux SIZED alors que la seconde ne le fait pas. La raison est que limit(m)ne sait pas si la taille est m ou inférieur à m, alors Arrays.streamne vérifie gamme et connaît la taille exacte du flux Vous pouvez lire le code source pour la mise en œuvre de flux retourné par Arrays.stream(array,start,end) ici , alors que pour la mise en œuvre flux retourné par Stream.of(array).skip().limit()est - dans cette méthode .

Alternative à la solution de @ sol4me:

Stream.of(theArray)

De la différence entre ceci et Arrays.stream(): cela fait une différence si votre tableau est de type primitif. Par exemple, si vous faites:

Arrays.stream(someArray)

où someArrayest a long[], il retournera a LongStream. Stream.of(), d'autre part, retournera un Stream<long[]>avec un seul élément.

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

Ou, si vous possédez déjà un tableau, vous pouvez également faire

Stream.of(array) 

Pour les types primitifs, utilisez IntStream.ofou LongStream.ofetc.

Vous pouvez également le faire par une méthode de bas niveau qui a l'option parallèle:

Mise à jour: utilisez full array.length (pas 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)

Vous pouvez utiliser Arrays.stream:

Arrays.stream (tableau); 

Cela garantit le type de retour de vapeur en fonction de votre type d'entrée de tableau si son String []retourne alors Stream<String>, si int []alors retourneIntStream

Lorsque vous connaissez déjà le tableau de type d'entrée, il est bon d'en utiliser un spécifique comme pour le type d'entrée int[]

 IntStream.of (tableau); 

Cela renvoie Intstream.

Dans le premier exemple, Java utilise la méthode overloadingpour rechercher une méthode spécifique en fonction des types d'entrée, tandis que dans le second, vous connaissez déjà le type d'entrée et l'appel d'une méthode spécifique.

rarement vu, mais c'est le moyen le plus direct

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