Відповіді:
Ви можете використовувати Arrays.stream Npr
Arrays.stream(array);
Ви також можете використовувати, Stream.of
як згадує @fge, як виглядає
public static<T> Stream<T> of(T... values) {
return Arrays.stream(values);
}
Але примітка Stream.of(intArray)
повернеться, Stream<int[]>
тоді як Arrays.stream(intArr)
повернеться, IntStream
якщо ви передасте масив типу int[]
. Тож у двох словах для примітивів типу можна спостерігати різницю між двома методами Напр
int[] arr = {1, 2};
Stream<int[]> arr1 = Stream.of(arr);
IntStream stream2 = Arrays.stream(arr);
Коли ви Arrays.stream
передаєте примітивний масив до , викликається наступний код
public static IntStream stream(int[] array) {
return stream(array, 0, array.length);
}
і при передачі примітивного масиву Stream.of
викликається наступний код
public static<T> Stream<T> of(T t) {
return StreamSupport.stream(new Streams.StreamBuilderImpl<>(t), false);
}
Отже, ви отримуєте різні результати.
Оновлено : Як зазначає коментар Stuart Marks . Перегрупування піддіапазону Arrays.stream
бажано використовувати, Stream.of(array).skip(n).limit(m)
оскільки перше призводить до розміру потоку SIZED, тоді як останнього немає. Причина полягає в тому, що limit(m)
не знає , є чи розмір м або менше , ніж т, в той час як Arrays.stream
робить перевірку діапазону і знає точний розмір потоку Ви можете прочитати вихідний код для реалізації потоку повернутої Arrays.stream(array,start,end)
тут , в той час як для потоку реалізація повертається Stream.of(array).skip().limit()
IS в рамках цього методу .
Stream.of
може принести вам кілька сюрпризів (наприклад, коли ви дзвоните Arrays.asList
з примітивним масивом і коли люди очікують List<Integer>
зворотного зв'язку) :-)
Arrays.stream
підтримує потокове діапазон масиву, який IntStream.of
не відповідає. На відміну від цього , Stream.of
є найкращим вибором , якщо ви хочетеStream<int[]>
розміру 1
...
Arrays.stream
бажано використовувати, Stream.of(array).skip(n).limit(m)
оскільки перше призводить до розміру потоку SIZED, тоді як останнього немає. Причина полягає в тому, що limit(m)
невідомо, розмір m
чи менший m
, тоді як Arrays.stream
діапазон перевіряє і знає точний розмір потоку.
Arrays.stream(array,start,end)
повертає Stream
реалізацію, реалізація якої знаходиться тут , тоді як Stream.of(array).skip().limit()
повертає Stream
реалізацію, реалізація якої знаходиться в рамках цього методу .
Альтернатива рішення @ sol4me:
Stream.of(theArray)
З різниці між цим і Arrays.stream()
: це має значення, якщо ваш масив примітивного типу. Наприклад, якщо ви робите:
Arrays.stream(someArray)
де someArray
є long[]
, воно поверне a LongStream
. Stream.of()
з іншого боку, поверне a Stream<long[]>
з одним елементом.
Arrays.stream()
працює і для цього
*Stream.of()
коли ви маєте Arrays.stream()
справу з примітивними масивами. А що стосується того, що масиви не є реальними об'єктами, ну це - Java, так це вже з 1.0, і так справляйтеся з цим; замислюватися над цим нічого не допомагає
Arrays.stream()
не зручно, я вважаю це зручним. Достатньо сказано.
*Stream.of()
зручніше бути помилковим; тому що це питання уподобань . Я віддаю перевагу Arrays.stream()
таким випадкам, що робить це неправильним як загальне правило, яке Stream.of()
є більш зручним (алгебра Пеано).
Stream.of("foo", "bar", "baz")
Або, якщо у вас вже є масив, ви також можете це зробити
Stream.of(array)
Для примітивних типів використовують IntStream.of
або LongStream.of
ін.
int[]
можна передати метод, що приймає varargs, чому б не Stream.of(intArray)
створити Stream<Integer>
замість Stream<int[]>
? Також, чи є якісь технічні міркування, чому існують спеціалізовані класи Stream для примітивів?
int[]
не так, як інші масиви. Це не підклас Object[]
, але це підклас Object
. Отже, коли ви передаєте його Stream.of
, він приймається як Object
параметр, і ви отримуєте потік int[]
. Це одна з причин мати спеціалізовані класи для примітивних - якби ви не створювали потоки з примітивних масивів, було б досить болісно. Інша причина полягає в тому, що спеціалізовані заняття є більш ефективними, тому що не потрібно вимагати Object
накладних витрат від боксу (перетворюючись int
на те, Integer
щоб це виглядало як звичайні об'єкти).
int[]
це є Object
, він би відповідав перевантаженому методу, of(T t)
а значить, він повертається Stream<int[]>
. Отже, теоретично, якби цей метод не був доступний, ми отримали б Stream<Integer>
взамін? а може, це призводить до помилки компіляції, оскільки він не зміг знайти метод відповідності? тобто int[]
не можна трактувати якT...
Stream<Integer>
, тому Stream.of(t ... T)
що все одно збігались би так само.
Ви можете зробити це також методом низького рівня, який має паралельний варіант:
/**
* 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:
Arrays.stream (масив);
Це забезпечує тип повернення пари на основі типу вхідного масиву, якщо його String []
потім повернути Stream<String>
, якщо int []
потім повернутиIntStream
Коли ви вже знаєте масив типу введення, тоді добре використовувати конкретний тип, наприклад для типу введення int[]
IntStream.of (масив);
Це повертає Intstream.
У першому прикладі Java використовує метод overloading
для пошуку конкретного методу на основі типів введення, тоді як, як і у другому, ви вже знаєте тип введення та викликаєте конкретний метод.
Arrays.stream
є всі перевантажені випадки для примітивних масивів. ТобтоStream.of(new int[]{1,2,3})
дасть вам,Stream<int[]>
тоді якArrays.stream
поверне вамIntStream
, мабуть, те, що ви хочете. Тож +1