Поток (Платформа Java SE 8 b92)

Введите Параметры:

T - тип элементов

Все Известные Подынтерфейсы:

CloseableStream <T>

Все Известные Классы с реализацией:

DelegatingStream
```
public interface Stream<T>
```
Последовательность элементов, поддерживающих последовательные и параллельные объемные операции. Потоки поддерживают ленивые промежуточные операции (преобразовывающий поток к другому потоку) такой как filter и map, и терминальные операции (использующий содержание потока, чтобы привести к результату или побочному эффекту), такой как forEach, findFirst, и iterator. Как только работа была выполнена на потоке, это считают использованным и больше применимым для других операций.
Для последовательных потоковых конвейеров все операции выполняются во встретиться порядке конвейерного источника, если у конвейерного источника есть определенный, встречаются с порядком.
Для параллельных потоковых конвейеров, если иначе не определено, промежуточные операции с потоками сохраняют встретиться порядок своего источника, и терминальные операции уважают встретиться порядок своего источника, если у источника есть встретиться порядок. При условии, что и параметры к операциям с потоками удовлетворяют требования невмешательства, и за исключением различий, являющихся результатом отсутствия определенного, встречаются с порядком, результатом потокового конвейера должна быть конюшня через массовые казни тех же самых операций на том же самом источнике. Однако, синхронизация и поток, в котором происходят побочные эффекты (для тех операций, которым позволяют произвести побочные эффекты, такой как forEach(Consumer)), явно недетерминированы для параллельного выполнения потоковых конвейеров.
Если не указано иное, передача a null параметр любому потоковому методу может привести к a NullPointerException.

Примечание API:

Потоки не являются структурами данных; они не управляют хранением для своих элементов, и при этом они не поддерживают доступ к отдельным элементам. Однако, можно использовать iterator() или spliterator() операции, чтобы выполнить управляемый обход.

С тех пор:

1.8

См. Также:

java.util.stream

Сводка метода

Все Методы Статические Методы Методы экземпляра Абстрактные Методы Методы значения по умолчанию
Модификатор и Тип	Метод и Описание
`boolean`	`allMatch(Predicate<? super T> predicate)` Возвраты, соответствуют ли все элементы этого потока обеспеченный предикат.
`boolean`	`anyMatch(Predicate<? super T> predicate)` Возвраты, соответствуют ли какие-либо элементы этого потока обеспеченный предикат.
`static <T> StreamBuilder<T>`	`builder()` Возвращает разработчика для a `Stream`.
`<R> R`	`collect(Collector<? super T,R> collector)` Выполняет изменчивую работу сокращения на элементах этого потока, используя a `Collector` объект описать сокращение.
`<R> R`	`collect(Supplier<R> resultFactory, BiConsumer<R,? super T> accumulator, BiConsumer<R,R> combiner)` Выполняет изменчивую работу сокращения на элементах этого потока.
`long`	`count()` Возвращает количество элементов в этом потоке.
`Stream<T>`	`distinct()` Возвращает поток, состоящий из отличных элементов (согласно `Object.equals(Object)`) из этого потока.
`static <T> Stream<T>`	`empty()` Возвращает пустое последовательное `Stream`.
`Stream<T>`	`filter(Predicate<? super T> predicate)` Возвращает поток, состоящий из элементов этого потока, которые соответствуют данный предикат.
`Optional<T>`	`findAny()` Возвраты `Optional` описание некоторого элемента потока, или пустого `Optional` если поток пуст.
`Optional<T>`	`findFirst()` Возвраты `Optional` описание первого элемента этого потока (во встретиться порядке), или пустое `Optional` если поток пуст.
`<R> Stream<R>`	`flatMap(Function<? super T,? extends Stream<? extends R>> mapper)` Возвращает поток, состоящий из результатов замены каждого элемента этого потока с содержанием потока, произведенного, применяя обеспеченную функцию отображения к каждому элементу.
`DoubleStream`	`flatMapToDouble(Function<? super T,? extends DoubleStream> mapper)` Возвраты a `DoubleStream` состоя из результатов замены каждого элемента этого потока с содержанием потока, произведенного, применяя обеспеченное отображение, функционирует к каждому элементу.
`IntStream`	`flatMapToInt(Function<? super T,? extends IntStream> mapper)` Возвраты `IntStream` состоя из результатов замены каждого элемента этого потока с содержанием потока, произведенного, применяя обеспеченное отображение, функционирует к каждому элементу.
`LongStream`	`flatMapToLong(Function<? super T,? extends LongStream> mapper)` Возвраты a `LongStream` состоя из результатов замены каждого элемента этого потока с содержанием потока, произведенного, применяя обеспеченное отображение, функционирует к каждому элементу.
`void`	`forEach(Consumer<? super T> action)` Выполняет действие для каждого элемента этого потока.
`void`	`forEachOrdered(Consumer<? super T> action)` Выполняет действие для каждого элемента этого потока, гарантируя, что каждый элемент обрабатывается в, встречаются с порядком на потоки, у которых есть определенный, встречаются с порядком.
`static <T> Stream<T>`	`generate(Supplier<T> s)` Возвращает последовательное `Stream` где каждый элемент сгенерирован a `Supplier`.
`boolean`	`isParallel()` Возвраты, выполнился ли бы этот поток, когда выполняющийся, параллельно (не принимающий дальнейшей модификации потока, такого как добавление дальнейших промежуточных операций или изменение его параллелизма).
`static <T> Stream<T>`	`iterate(T seed, UnaryOperator<T> f)` Возвращает последовательное большое количество `Stream` произведенный итеративным приложением функции `f` к начальному элементу `seed`, создание a `Stream` состоя из `seed`, `f(seed)`, `f(f(seed))`, и т.д..
`Iterator<T>`	`iterator()` Возвращает iterator для элементов этого потока.
`Stream<T>`	`limit(long maxSize)` Возвращает поток, состоящий из элементов этого потока, усеченного, чтобы не быть больше чем `maxSize` в длине.
`<R> Stream<R>`	`map(Function<? super T,? extends R> mapper)` Возвращает поток, состоящий из результатов применения заданной функции к элементам этого потока.
`DoubleStream`	`mapToDouble(ToDoubleFunction<? super T> mapper)` Возвраты a `DoubleStream` состоя из результатов применения заданной функции к элементам этого потока.
`IntStream`	`mapToInt(ToIntFunction<? super T> mapper)` Возвраты `IntStream` состоя из результатов применения заданной функции к элементам этого потока.
`LongStream`	`mapToLong(ToLongFunction<? super T> mapper)` Возвраты a `LongStream` состоя из результатов применения заданной функции к элементам этого потока.
`Optional<T>`	`max(Comparator<? super T> comparator)` Возвращает максимальный элемент этого потока согласно обеспеченному `Comparator`.
`Optional<T>`	`min(Comparator<? super T> comparator)` Возвращает минимальный элемент этого потока согласно обеспеченному `Comparator`.
`boolean`	`noneMatch(Predicate<? super T> predicate)` Возвраты, не соответствуют ли никакие элементы этого потока обеспеченный предикат.
`static <T> Stream<T>`	`of(T... values)` Возвращает последовательный поток, элементы которого являются указанными значениями.
`static <T> Stream<T>`	`of(T t)` Возвращает последовательное `Stream` содержа единственный элемент.
`S`	`parallel()` Возвращает эквивалентный поток, который параллелен.
`Stream<T>`	`peek(Consumer<? super T> consumer)` Возвращает поток, состоящий из элементов этого потока, дополнительно выполняя обеспеченное действие на каждом элементе, поскольку элементы используются от получающегося потока.
`Optional<T>`	`reduce(BinaryOperator<T> accumulator)` Выполняет сокращение на элементах этого потока, используя ассоциативную функцию накопления, и возвращается `Optional` описание уменьшенного значения, если любой.
`T`	`reduce(T identity, BinaryOperator<T> accumulator)` Выполняет сокращение на элементах этого потока, используя обеспеченное значение идентификационных данных и ассоциативную функцию накопления, и возвращает уменьшенное значение.
`<U> U`	`reduce(U identity, BiFunction<U,? super T,U> accumulator, BinaryOperator<U> combiner)` Выполняет сокращение на элементах этого потока, используя обеспеченные идентификационные данные, функцию накопления, и объединяющиеся функции.
`S`	`sequential()` Возвращает эквивалентный поток, который последователен.
`Stream<T>`	`sorted()` Возвращает поток, состоящий из элементов этого потока, сортированного согласно естественному порядку.
`Stream<T>`	`sorted(Comparator<? super T> comparator)` Возвращает поток, состоящий из элементов этого потока, сортированного согласно обеспеченному `Comparator`.
`Spliterator<T>`	`spliterator()` Возвращает spliterator для элементов этого потока.
`Stream<T>`	`substream(long startInclusive)` Возвращает поток, состоящий из остающихся элементов этого потока после индексации `startInclusive` элементы в поток.
`Stream<T>`	`substream(long startInclusive, long endExclusive)` Возвращает поток, состоящий из остающихся элементов этого потока после индексации `startInclusive` элементы в поток и усеченный, чтобы содержать не больше, чем `endExclusive - startInclusive` элементы.
`Объект[]`	`toArray()` Возвращает массив, содержащий элементы этого потока.
`<A> A[]`	`toArray(IntFunction<A[]> generator)` Возвращает массив, содержащий элементы этого потока, используя обеспеченный `generator` функция, чтобы выделить возвращенный массив.
`S`	`unordered()` Возвращает эквивалентный поток, который неупорядочивается.

- Деталь метода
  - фильтр
```
Stream<T> filter(Predicate<? super T> predicate)
```
    Возвращает поток, состоящий из элементов этого потока, которые соответствуют данный предикат.
    Это - промежуточная работа.
    
    Параметры:
    
    predicate - невмешательство, предикат не сохраняющий состояние, чтобы примениться к каждому элементу, чтобы определить, должно ли это быть включено
    
    Возвраты:
    
    новый поток
  - карта
```
<R> Stream<R> map(Function<? super T,? extends R> mapper)
```
    Возвращает поток, состоящий из результатов применения заданной функции к элементам этого потока.
    Это - промежуточная работа.
    
    Введите Параметры:
    
    R - Тип элемента нового потока
    
    Параметры:
    
    mapper - невмешательство, функция не сохраняющая состояние, чтобы примениться к каждому элементу
    
    Возвраты:
    
    новый поток
  - mapToInt
```
IntStream mapToInt(ToIntFunction<? super T> mapper)
```
    Возвраты IntStream состоя из результатов применения заданной функции к элементам этого потока.
    Это - промежуточная работа.
    
    Параметры:
    
    mapper - невмешательство, функция не сохраняющая состояние, чтобы примениться к каждому элементу
    
    Возвраты:
    
    новый поток
  - mapToLong
```
LongStream mapToLong(ToLongFunction<? super T> mapper)
```
    Возвраты a LongStream состоя из результатов применения заданной функции к элементам этого потока.
    Это - промежуточная работа.
    
    Параметры:
    
    mapper - невмешательство, функция не сохраняющая состояние, чтобы примениться к каждому элементу
    
    Возвраты:
    
    новый поток
  - mapToDouble
```
DoubleStream mapToDouble(ToDoubleFunction<? super T> mapper)
```
    Возвраты a DoubleStream состоя из результатов применения заданной функции к элементам этого потока.
    Это - промежуточная работа.
    
    Параметры:
    
    mapper - невмешательство, функция не сохраняющая состояние, чтобы примениться к каждому элементу
    
    Возвраты:
    
    новый поток
  - flatMap
```
<R> Stream<R> flatMap(Function<? super T,? extends Stream<? extends R>> mapper)
```
    Возвращает поток, состоящий из результатов замены каждого элемента этого потока с содержанием потока, произведенного, применяя обеспеченную функцию отображения к каждому элементу. Если результат отображающейся функции null, это обрабатывается, как будто результатом является пустой поток.
    Это - промежуточная работа.
    Примечание API:
    flatMap() работа имеет эффект применения "одного многим" tranformation к элементам потока, и затем выравниванию получающихся элементов в новый поток. Например, если orders поток заказов на поставку, и каждый заказ на поставку содержит набор элементов строки, тогда следующее производит поток элементов строки:
    orderStream.flatMap(order -> order.getLineItems().stream())...
    Введите Параметры:
    
    R - Тип элемента нового потока
    
    Параметры:
    
    mapper - невмешательство, функция не сохраняющая состояние, чтобы примениться к каждому элементу, который производит поток новых значений
    
    Возвраты:
    
    новый поток
  - flatMapToInt
```
IntStream flatMapToInt(Function<? super T,? extends IntStream> mapper)
```
    Возвраты IntStream состоя из результатов замены каждого элемента этого потока с содержанием потока, произведенного, применяя обеспеченное отображение, функционирует к каждому элементу. Если результат отображающейся функции null, это обрабатывается, как будто результатом является пустой поток.
    Это - промежуточная работа.
    
    Параметры:
    
    mapper - невмешательство, функция не сохраняющая состояние, чтобы примениться к каждому элементу, который производит поток новых значений
    
    Возвраты:
    
    новый поток
  - flatMapToLong
```
LongStream flatMapToLong(Function<? super T,? extends LongStream> mapper)
```
    Возвраты a LongStream состоя из результатов замены каждого элемента этого потока с содержанием потока, произведенного, применяя обеспеченное отображение, функционирует к каждому элементу. Если результат отображающейся функции null, это обрабатывается, как будто результатом является пустой поток.
    Это - промежуточная работа.
    
    Параметры:
    
    mapper - невмешательство, функция не сохраняющая состояние, чтобы примениться к каждому элементу, который производит поток новых значений
    
    Возвраты:
    
    новый поток
  - flatMapToDouble
```
DoubleStream flatMapToDouble(Function<? super T,? extends DoubleStream> mapper)
```
    Возвраты a DoubleStream состоя из результатов замены каждого элемента этого потока с содержанием потока, произведенного, применяя обеспеченное отображение, функционирует к каждому элементу. Если результат отображающейся функции null, это обрабатывается, как будто результатом является пустой поток.
    Это - промежуточная работа.
    
    Параметры:
    
    mapper - невмешательство, функция не сохраняющая состояние, чтобы примениться к каждому элементу, который производит поток новых значений
    
    Возвраты:
    
    новый поток
  - отличный
```
Stream<T> distinct()
```
    Возвращает поток, состоящий из отличных элементов (согласно Object.equals(Object)) из этого потока.
    Это - stateful промежуточная работа.
    
    Возвраты:
    
    новый поток
  - сортированный
```
Stream<T> sorted()
```
    Возвращает поток, состоящий из элементов этого потока, сортированного согласно естественному порядку. Если элементы этого потока не Comparable, a java.lang.ClassCastException может быть брошен, когда потоковый конвейер выполняется.
    Это - stateful промежуточная работа.
    
    Возвраты:
    
    новый поток
  - сортированный
```
Stream<T> sorted(Comparator<? super T> comparator)
```
    Возвращает поток, состоящий из элементов этого потока, сортированного согласно обеспеченному Comparator.
    Это - stateful промежуточная работа.
    
    Параметры:
    
    comparator - невмешательство, не сохраняющее состояние Comparator использоваться, чтобы сравнить потоковые элементы
    
    Возвраты:
    
    новый поток
  - быстрый взгляд
```
Stream<T> peek(Consumer<? super T> consumer)
```
    Возвращает поток, состоящий из элементов этого потока, дополнительно выполняя обеспеченное действие на каждом элементе, поскольку элементы используются от получающегося потока.
    Это - промежуточная работа.
    Для параллельных потоковых конвейеров действие можно вызвать в любое время, и в любом потоке элемент делается доступным восходящей работой. Если действие изменяет общее состояние, это ответственно за обеспечение необходимой синхронизации.
    Примечание API:
    Этот метод существует, главным образом, чтобы поддерживать отладку, где Вы хотите видеть элементы, поскольку они текут мимо определенного момента в конвейере:
    list.stream() .filter(filteringFunction) .peek(e -> {System.out.println("Filtered value: " + e); }); .map(mappingFunction) .peek(e -> {System.out.println("Mapped value: " + e); }); .collect(Collectors.intoList());
    Параметры:
    
    consumer - невмешивающееся действие, чтобы выполнить на элементах, поскольку они используются от потока
    
    Возвраты:
    
    новый поток
  - предел
```
Stream<T> limit(long maxSize)
```
    Возвращает поток, состоящий из элементов этого потока, усеченного, чтобы не быть больше чем maxSize в длине.
    Это - замыкание накоротко stateful промежуточная работа.
    
    Параметры:
    
    maxSize - число элементов поток должно быть ограничено
    
    Возвраты:
    
    новый поток
    
    Броски:
    
    IllegalArgumentException - если maxSize отрицательно
  - подпоток
```
Stream<T> substream(long startInclusive)
```
    Возвращает поток, состоящий из остающихся элементов этого потока после индексации startInclusive элементы в поток. Если startInclusive индексируйте находится мимо конца этого потока тогда будет возвращен, пустой поток.
    Это - stateful промежуточная работа.
    
    Параметры:
    
    startInclusive - число ведущих элементов, чтобы пропустить
    
    Возвраты:
    
    новый поток
    
    Броски:
    
    IllegalArgumentException - если startInclusive отрицательно
  - подпоток
```
Stream<T> substream(long startInclusive,
                    long endExclusive)
```
    Возвращает поток, состоящий из остающихся элементов этого потока после индексации startInclusive элементы в поток и усеченный, чтобы содержать не больше, чем endExclusive - startInclusive элементы. Если startInclusive индексируйте находится мимо конца этого потока тогда будет возвращен, пустой поток.
    Это - замыкание накоротко stateful промежуточная работа.
    
    Параметры:
    
    startInclusive - стартовая позиция подпотока, включительно
    
    endExclusive - конечная позиция подпотока, монопольного
    
    Возвраты:
    
    новый поток
    
    Броски:
    
    IllegalArgumentException - если startInclusive или endExclusive отрицательно или startInclusive больше чем endExclusive
  - forEach
```
void forEach(Consumer<? super T> action)
```
    Выполняет действие для каждого элемента этого потока.
    Это - терминальная работа.
    Для параллельных потоковых конвейеров эта работа не гарантирует, что уважала встретиться порядок потока, поскольку выполнение так пожертвовало бы преимуществом параллелизма. Для любого данного элемента действие может быть выполнено в любое время, и в любом потоке выбирает библиотека. Если общее состояние доступов действия, это ответственно за обеспечение необходимой синхронизации.
    
    Параметры:
    
    action - невмешивающееся действие, чтобы выполнить на элементах
  - forEachOrdered
```
void forEachOrdered(Consumer<? super T> action)
```
    Выполняет действие для каждого элемента этого потока, гарантируя, что каждый элемент обрабатывается в, встречаются с порядком на потоки, у которых есть определенный, встречаются с порядком.
    Это - терминальная работа.
    
    Параметры:
    
    action - невмешивающееся действие, чтобы выполнить на элементах
    
    См. Также:
    
    forEach(Consumer)
  - toArray
```
Object[] toArray()
```
    Возвращает массив, содержащий элементы этого потока.
    Это - терминальная работа.
    
    Возвраты:
    
    массив, содержащий элементы этого потока
  - toArray
```
<A> A[] toArray(IntFunction<A[]> generator)
```
    Возвращает массив, содержащий элементы этого потока, используя обеспеченный generator функция, чтобы выделить возвращенный массив.
    Это - терминальная работа.
    
    Введите Параметры:
    
    A - тип элемента получающегося массива
    
    Параметры:
    
    generator - функция, которая производит новый массив требуемого типа и обеспеченной длины
    
    Возвраты:
    
    массив, содержащий элементы в этом потоке
    
    Броски:
    
    ArrayStoreException - если тип времени выполнения массива, возвращенного из генератора массива, не является супертипом типа времени выполнения каждого элемента в этом потоке
  - уменьшить
```
T reduce(T identity,
         BinaryOperator<T> accumulator)
```
    Выполняет сокращение на элементах этого потока, используя обеспеченное значение идентификационных данных и ассоциативную функцию накопления, и возвращает уменьшенное значение. Это эквивалентно:
```
     T result = identity;
     for (T element : this stream)
         result = accumulator.apply(result, element)
     return result;
 
```
    но не ограничивается выполниться последовательно.
    identity значение должно быть идентификационными данными для функции аккумулятора. Это означает это для всех t, accumulator.apply(identity, t) равно t. accumulator функция должна быть ассоциативной функцией.
    Это - терминальная работа.
    Примечание API:
    Сумма, минута, максимальная, средняя, и конкатенация строк является всеми особыми случаями сокращения. Подведение итогов потока чисел может быть выражено как:
    Integer sum = integers.reduce(0, (a, b) -> a+b);
    или более сжато:
    Integer sum = integers.reduce(0, Integer::sum);
    
    В то время как это может казаться более окольным способом выполнить агрегацию по сравнению с простым видоизменением рабочего общего количества в цикле, операции сокращения параллелизируют более корректно, не нуждаясь в дополнительной синхронизации и со значительно уменьшенным риском гонок данных.
    Параметры:
    
    identity - значение идентификационных данных для накапливающейся функции
    
    accumulator - ассоциативный невмешательство, не сохраняющее состояние функционирует для того, чтобы объединить два значения
    
    Возвраты:
    
    результат сокращения
  - уменьшить
```
Optional<T> reduce(BinaryOperator<T> accumulator)
```
    Выполняет сокращение на элементах этого потока, используя ассоциативную функцию накопления, и возвращается Optional описание уменьшенного значения, если любой. Это эквивалентно:
```
     boolean foundAny = false;
     T result = null;
     for (T element : this stream) {
         if (!foundAny) {
             foundAny = true;
             result = element;
         }
         else
             result = accumulator.apply(result, element);
     }
     return foundAny ? Optional.of(result) : Optional.empty();
 
```
    но не ограничивается выполниться последовательно.
    accumulator функция должна быть ассоциативной функцией.
    Это - терминальная работа.
    Параметры:
    
    accumulator - ассоциативный невмешательство, не сохраняющее состояние функционирует для того, чтобы объединить два значения
    
    Возвраты:
    
    результат сокращения
    
    См. Также:
    
    reduce(Object, BinaryOperator), min(java.util.Comparator), max(java.util.Comparator)
  - уменьшить
```
<U> U reduce(U identity,
             BiFunction<U,? super T,U> accumulator,
             BinaryOperator<U> combiner)
```
    Выполняет сокращение на элементах этого потока, используя обеспеченные идентификационные данные, функцию накопления, и объединяющиеся функции. Это эквивалентно:
```
     U result = identity;
     for (T element : this stream)
         result = accumulator.apply(result, element)
     return result;
 
```
    но не ограничивается выполниться последовательно.
    identity значение должно быть идентификационными данными для функции объединителя. Это означает это для всех u, combiner(identity, u) равно u. Дополнительно, combiner функция должна быть совместимой с accumulator функция; для всех u и t, следующее должно содержать:
```
     combiner.apply(u, accumulator.apply(identity, t)) == accumulator.apply(u, t)
 
```
    Это - терминальная работа.
    Примечание API:
    
    Много сокращений, используя эту форму могут быть представлены более просто явной комбинацией map и reduce операции. accumulator функционируйте действия как сплавленный картопостроитель и аккумулятор, который может иногда быть более эффективным чем отдельное отображение и сокращение, такой как в случае, где знание ранее уменьшенного значения позволяет Вам избегать некоторого вычисления.
    
    Введите Параметры:
    
    U - Тип результата
    
    Параметры:
    
    identity - значение идентификационных данных для функции объединителя
    
    accumulator - ассоциативный невмешательство, не сохраняющее состояние функционирует для того, чтобы включить дополнительный элемент в результат
    
    combiner - ассоциативный невмешательство, не сохраняющее состояние функционирует для того, чтобы объединить два значения, которые должны быть совместимыми с функцией аккумулятора
    
    Возвраты:
    
    результат сокращения
    
    См. Также:
    
    reduce(BinaryOperator), reduce(Object, BinaryOperator)
  - собраться
```
<R> R collect(Supplier<R> resultFactory,
              BiConsumer<R,? super T> accumulator,
              BiConsumer<R,R> combiner)
```
    Выполняет изменчивую работу сокращения на элементах этого потока. Изменчивое сокращение - тот, в котором уменьшенное значение является изменчивым держателем значения, такой как ArrayList, и элементы включаются, обновляя состояние результата, а не заменяя результат. Это приводит к результату, эквивалентному:
```
     R result = resultFactory.get();
     for (T element : this stream)
         accumulator.accept(result, element);
     return result;
 
```
    Как reduce(Object, BinaryOperator), collect операции могут быть параллелизированы, не требуя дополнительной синхронизации.
    Это - терминальная работа.
    Примечание API:
    Есть много существующих классов в JDK, подписи которого являются хорошим соответствием для использования в качестве параметров collect(). Например, следующее накопит строки в ArrayList:
    List<String> asList = stringStream.collect(ArrayList::new, ArrayList::add, ArrayList::addAll);
    
    Следующее возьмет поток строк и связывает их в единственную строку:
    String concat = stringStream.collect(StringBuilder::new, StringBuilder::append, StringBuilder::append) .toString();
    Введите Параметры:
    
    R - тип результата
    
    Параметры:
    
    resultFactory - функция, которая создает новый контейнер результата. Для параллельного выполнения эта функция может быть вызвана многократно и должна возвратить новое значение каждый раз.
    
    accumulator - ассоциативный невмешательство, не сохраняющее состояние функционирует для того, чтобы включить дополнительный элемент в результат
    
    combiner - ассоциативный невмешательство, не сохраняющее состояние функционирует для того, чтобы объединить два значения, которые должны быть совместимыми с функцией аккумулятора
    
    Возвраты:
    
    результат сокращения
  - собраться
```
<R> R collect(Collector<? super T,R> collector)
```
    Выполняет изменчивую работу сокращения на элементах этого потока, используя a Collector объект описать сокращение. A Collector инкапсулирует функции, используемые в качестве параметров collect(Supplier, BiConsumer, BiConsumer), учет повторного использования стратегий набора, и состава собирает операции, такие как многоуровневая группировка или разделение.
    Это - терминальная работа.
    Когда выполняющийся параллельно, многократные промежуточные результаты можно инстанцировать, заполнили, и объединились, чтобы поддержать изоляцию изменчивых структур данных. Поэтому, даже когда выполняющийся параллельно с неориентированными на многопотоковое исполнение структурами данных (такой как ArrayList), никакая дополнительная синхронизация не необходима для параллельного сокращения.
    Примечание API:
    Следующее накопит строки в ArrayList:
    List<String> asList = stringStream.collect(Collectors.toList());
    
    Следующее классифицирует Person объекты городом:
    Map<String, Collection<Person>> peopleByCity = personStream.collect(Collectors.groupBy(Person::getCity));
    
    Следующее классифицирует Person объекты состоянием и городом, располагаясь каскадом два Collectors вместе:
    Map<String, Map<String, Collection<Person>>> peopleByStateAndCity = personStream.collect(Collectors.groupBy(Person::getState, Collectors.groupBy(Person::getCity)));
    Введите Параметры:
    
    R - тип результата
    
    Параметры:
    
    collector - Collector описание сокращения
    
    Возвраты:
    
    результат сокращения
    
    См. Также:
    
    collect(Supplier, BiConsumer, BiConsumer), Collectors
  - минута
```
Optional<T> min(Comparator<? super T> comparator)
```
    Возвращает минимальный элемент этого потока согласно обеспеченному Comparator. Это - особый случай сокращения.
    Это - терминальная работа.
    
    Параметры:
    
    comparator - невмешательство, не сохраняющее состояние Comparator использовать, чтобы сравнить элементы этого потока
    
    Возвраты:
    
    Optional описание минимального элемента этого потока, или пустого Optional если поток пуст
  - максимальный
```
Optional<T> max(Comparator<? super T> comparator)
```
    Возвращает максимальный элемент этого потока согласно обеспеченному Comparator. Это - особый случай сокращения.
    Это - терминальная работа.
    
    Параметры:
    
    comparator - невмешательство, не сохраняющее состояние Comparator использовать, чтобы сравнить элементы этого потока
    
    Возвраты:
    
    Optional описание максимального элемента этого потока, или пустого Optional если поток пуст
  - количество
```
long count()
```
    Возвращает количество элементов в этом потоке. Это - особый случай сокращения и эквивалентно:
```
     return mapToLong(e -> 1L).sum();
 
```
    Это - терминальная работа.
    Возвраты:
    
    количество элементов в этом потоке
  - anyMatch
```
boolean anyMatch(Predicate<? super T> predicate)
```
    Возвраты, соответствуют ли какие-либо элементы этого потока обеспеченный предикат., Возможно, не оценивает предикат на всех элементах если не необходимый для того, чтобы определить результат.
    Это - закорачивающая терминальная работа.
    
    Параметры:
    
    predicate - невмешательство, предикат не сохраняющий состояние, чтобы примениться к элементам этого потока
    
    Возвраты:
    
    true если какие-либо элементы потока соответствуют обеспеченный предикат иначе false
  - allMatch
```
boolean allMatch(Predicate<? super T> predicate)
```
    Возвраты, соответствуют ли все элементы этого потока обеспеченный предикат., Возможно, не оценивает предикат на всех элементах если не необходимый для того, чтобы определить результат.
    Это - закорачивающая терминальная работа.
    
    Параметры:
    
    predicate - невмешательство, предикат не сохраняющий состояние, чтобы примениться к элементам этого потока
    
    Возвраты:
    
    true если все элементы потока соответствуют обеспеченный предикат иначе false
  - noneMatch
```
boolean noneMatch(Predicate<? super T> predicate)
```
    Возвраты, не соответствуют ли никакие элементы этого потока обеспеченный предикат., Возможно, не оценивает предикат на всех элементах если не необходимый для того, чтобы определить результат.
    Это - закорачивающая терминальная работа.
    
    Параметры:
    
    predicate - невмешательство, предикат не сохраняющий состояние, чтобы примениться к элементам этого потока
    
    Возвраты:
    
    true если никакие элементы потока не соответствуют обеспеченный предикат иначе false
  - findFirst
```
Optional<T> findFirst()
```
    Возвраты Optional описание первого элемента этого потока (во встретиться порядке), или пустое Optional если поток пуст. Если поток имеет, не встречаются с порядком, чем любой элемент может быть возвращен.
    Это - закорачивающая терминальная работа.
    
    Возвраты:
    
    Optional описание первого элемента этого потока, или пустого Optional если поток пуст
    
    Броски:
    
    NullPointerException - если выбранный элемент является нулем
  - findAny
```
Optional<T> findAny()
```
    Возвраты Optional описание некоторого элемента потока, или пустого Optional если поток пуст.
    Это - закорачивающая терминальная работа.
    Поведение этой работы явно недетерминировано; это свободно выбрать любой элемент в потоке. Это должно учесть максимальную производительность в параллельных операциях; стоимость - то, что многократные вызовы на том же самом источнике, возможно, не возвращают тот же самый результат. (Если первый элемент во встретиться порядке требуется, использовать findFirst() вместо этого.)
    
    Возвраты:
    
    Optional описание некоторого элемента этого потока, или пустого Optional если поток пуст
    
    Броски:
    
    NullPointerException - если выбранный элемент является нулем
    
    См. Также:
    
    findFirst()
  - разработчик
```
static <T> StreamBuilder<T> builder()
```
    Возвращает разработчика для a Stream.
    
    Введите Параметры:
    
    T - тип элементов
    
    Возвраты:
    
    потоковый разработчик
  - пустой
```
static <T> Stream<T> empty()
```
    Возвращает пустое последовательное Stream.
    
    Введите Параметры:
    
    T - тип потоковых элементов
    
    Возвраты:
    
    пустой последовательный поток
  - из
```
static <T> Stream<T> of(T t)
```
    Возвращает последовательное Stream содержа единственный элемент.
    
    Введите Параметры:
    
    T - тип потоковых элементов
    
    Параметры:
    
    t - единственный элемент
    
    Возвраты:
    
    одиночный элемент последовательный поток
  - из
```
@SafeVarargs
static <T> Stream<T> of(T... values)
```
    Возвращает последовательный поток, элементы которого являются указанными значениями.
    
    Введите Параметры:
    
    T - тип потоковых элементов
    
    Параметры:
    
    values - элементы нового потока
    
    Возвраты:
    
    новый поток
  - выполнить итерации
```
static <T> Stream<T> iterate(T seed,
                             UnaryOperator<T> f)
```
    Возвращает последовательное большое количество Stream произведенный итеративным приложением функции f к начальному элементу seed, создание a Stream состоя из seed, f(seed), f(f(seed)), и т.д..
    Первый элемент (позиция 0) в Stream будет обеспеченный seed. Для n > 0, элемент в позиции n, будет результат применения функции f к элементу в позиции n - 1.
    
    Введите Параметры:
    
    T - тип потоковых элементов
    
    Параметры:
    
    seed - начальный элемент
    
    f - функция, которая будет применена к к предыдущему элементу, чтобы произвести новый элемент
    
    Возвраты:
    
    новое последовательное Stream
  - генерировать
```
static <T> Stream<T> generate(Supplier<T> s)
```
    Возвращает последовательное Stream где каждый элемент сгенерирован a Supplier. Это является подходящим для того, чтобы генерировать постоянные потоки, потоки случайных элементов, и т.д.
    
    Введите Параметры:
    
    T - тип потоковых элементов
    
    Параметры:
    
    s - Supplier из сгенерированных элементов
    
    Возвраты:
    
    новое последовательное Stream
  - iterator
```
Iterator<T> iterator()
```
    Возвращает iterator для элементов этого потока.
    Это - терминальная работа.
    
    Возвраты:
    
    элемент iterator для этого потока
  - spliterator
```
Spliterator<T> spliterator()
```
    Возвращает spliterator для элементов этого потока.
    Это - терминальная работа.
    
    Возвраты:
    
    элемент spliterator для этого потока
  - isParallel
```
boolean isParallel()
```
    Возвраты, выполнился ли бы этот поток, когда выполняющийся, параллельно (не принимающий дальнейшей модификации потока, такого как добавление дальнейших промежуточных операций или изменение его параллелизма). Вызов этого метода после вызова промежуточного или терминального метода операции с потоками может привести к непредсказуемым результатам.
    
    Возвраты:
    
    true если этот поток выполнился бы параллельно если выполняющийся без дальнейшей модификации иначе false
  - последовательный
```
S sequential()
```
    Возвращает эквивалентный поток, который последователен. Может возвратить себя, или потому что поток был уже последователен, или потому что базовое потоковое состояние было изменено, чтобы быть последовательным.
    Это - промежуточная работа.
    
    Возвраты:
    
    последовательный поток
  - параллель
```
S parallel()
```
    Возвращает эквивалентный поток, который параллелен. Может возвратить себя, или потому что поток был уже параллелен, или потому что базовое потоковое состояние было изменено, чтобы быть параллельным.
    Это - промежуточная работа.
    
    Возвраты:
    
    параллельный поток
  - неупорядоченный
```
S unordered()
```
    Возвращает эквивалентный поток, который неупорядочивается. Может возвратить себя, если поток был уже неупорядочен.
    Это - промежуточная работа.
    
    Возвраты:
    
    неупорядоченный поток

Представьте ошибку или функцию
Для дальнейшей ссылки API и документации разработчика, см. Java Документация SE. Та документация содержит более подробные, предназначенные разработчиком описания, с концептуальными краткими обзорами, определениями сроков, обходных решений, и рабочих примеров кода.
Авторское право © 1993, 2013, Oracle и/или его филиалы. Все права защищены.
Проект сборка-b92

Поток интерфейса <T>

Сводка метода

Деталь метода

фильтр

карта

mapToInt

mapToLong

mapToDouble

flatMap

flatMapToInt

flatMapToLong

flatMapToDouble

отличный

сортированный

сортированный

быстрый взгляд

предел

подпоток

подпоток

forEach

forEachOrdered

toArray

toArray

уменьшить

уменьшить

уменьшить

собраться

собраться

минута

максимальный

количество

anyMatch

allMatch

noneMatch

findFirst

findAny

разработчик

пустой

из

из

выполнить итерации

генерировать

iterator

spliterator

isParallel

последовательный

параллель

неупорядоченный