Bir diziden nasıl akış oluşturabilirim?

Şu anda bir diziden akış oluşturmam gerektiğinde,

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

Bir diziden akış oluşturmanın doğrudan bir yolu var mı?

Arrays.stream Eg kullanabilirsiniz.

Arrays.stream(array);

Ayrıca Stream.of, @fge tarafından belirtildiği gibi kullanabilirsiniz.

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

Ama dikkat Stream.of(intArray)dönecektir Stream<int[]>oysa Arrays.stream(intArr)dönecektir IntStreamEğer türü bir dizi geçmesi sağlayarak int[]. Yani ilkel tip için bir özetle, 2 yöntem arasındaki farkı gözlemleyebilirsiniz.

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

IntStream stream2 = Arrays.stream(arr); 

İlkel diziyi Arrays.streamilettiğinizde, aşağıdaki kod çağrılır

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

ve ilkel diziyi geçirdiğinizde Stream.ofaşağıdaki kod çağrılır

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

Böylece farklı sonuçlar elde edersiniz.

Güncellendi : Stuart Marks yorumunda belirtildiği gibi, alt Arrays.streamöğesinin aşırı yüklenmesinin kullanılması tercih edilir, Stream.of(array).skip(n).limit(m)çünkü eski boyutlar SIZED akışıyla sonuçlanırken ikincisi bunu yapmaz. Bunun nedeni ise limit(m), oysa boyut m veya daha az m'den olup olmadığını bilmiyor Arrays.streamaralık kontrolleri yapar ve Sen tarafından döndürülen akış uygulaması için kaynak kodunu okuyabilir akışının tam boyutunu bilir Arrays.stream(array,start,end) burada akışı için uygulama tarafından döndürülen oysa Stream.of(array).skip().limit()DİR bu yöntem dahilinde .

@ Sol4me'nin çözümüne alternatif:

Stream.of(theArray)

Bu ve arasındaki farkın Arrays.stream(): Bu mu senin dizi ilkel türden olduğu takdirde bir fark yaratır. Örneğin, şunları yaparsanız:

Arrays.stream(someArray)

nerede someArraya long[], geri dönecektir a LongStream. Stream.of(), diğer taraftan, Stream<long[]>tek bir öğeyle birlikte a döndürür .

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

Veya zaten bir diziniz varsa,

Stream.of(array) 

İlkel tip kullanım için IntStream.ofya da LongStream.ofvs.

Paralel seçeneğe sahip düşük seviyeli yöntemle de yapabilirsiniz:

Güncelleme: Tam array.length kullanın (uzunluk - 1 değil).

/** 
 * 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)

Arrays.stream komutunu kullanabilirsiniz:

(Dizi) Arrays.stream; 

Bu, dizi giriş türünüze göre geri dönüş buhar türünü sağlarsa, String []geri dönerse Stream<String>, int []geri dönerseIntStream

Giriş türü dizisini zaten biliyorsanız, giriş türü gibi belirli bir tür kullanmak iyi int[]

 IntStream.of (dizi); 

Bu, Intstream değerini döndürür.

İlk örnekte, Java overloading, girdi türlerine göre belirli bir yöntemi bulmak için yöntemi kullanır , ikinci sırada ise girdi türünü ve belirli yöntemi çağırmayı zaten biliyorsunuzdur.

nadiren görülür, ancak bu en doğrudan yoldur

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