Интерфейс IntStream

Все суперинтерфейсы:
AutoCloseable, BaseStream<Integer,​IntStream> 
public interface IntStream
extends BaseStream<Integer,IntStream>

Последовательность примитивных элементов int, поддерживающая последовательные и параллельные агрегатные операции. Это примитивное специализированное представление Stream.

Следующий пример иллюстрирует агрегатную операцию, использующую Stream и IntStream, вычисляющую сумму весов красных виджетов:

int sum = widgets.stream()
                      .filter(w -> w.getColor() == RED)
                      .mapToInt(w -> w.getWeight())
                      .sum();
См. документацию класса для Stream и документацию пакета для java.util.stream для дополнительной спецификации потоков, операций над потоками, конвейеров потоков и параллелизма.
С тех пор:
1.8
См. также:
Stream, java.util.stream

Вложенные классы

Модификатор и тип Интерфейс Описание
static interface  IntStream.Builder

Изменяемый билдер для IntStream.

Методы

Модификатор и тип Метод Описание
boolean allMatch​(IntPredicate predicate)

Возвращает значение, указывающее, соответствуют ли все элементы этого потока предоставленному предикату.
boolean anyMatch​(IntPredicate predicate)

Возвращает значение, указывающее, соответствуют ли какие-либо элементы этого потока предоставленному предикату.
DoubleStream asDoubleStream()

Возвращает DoubleStream, содержащий элементы этого потока, преобразованные в double.
LongStream asLongStream()

Возвращает LongStream, содержащий элементы этого потока, преобразованные в long.
OptionalDouble average()

Возвращает OptionalDouble, описывающую среднее арифметическое элементов этого потока, или пустой необязательный объект, если этот поток пустой.
Stream<Integer> boxed()

Возвращает Stream, содержащий элементы этого потока, каждый из которых упакован в Integer.
static IntStream.Builder builder()

Возвращает билдер для IntStream.
<R> R collect​(Supplier<R> supplier, ObjIntConsumer<R> accumulator, BiConsumer<R,​R> combiner)

Выполняет операцию мутабельного сокращения над элементами этого потока.
static IntStream concat​(IntStream a, IntStream b)

Создаёт лениво конкатенированный поток, элементы которого — все элементы первого потока, за которыми следуют все элементы второго потока.
long count()

Возвращает количество элементов в этом потоке.
IntStream distinct()

Возвращает поток, содержащий уникальные элементы этого потока.
default IntStream dropWhile​(IntPredicate predicate)

Если этот поток упорядочен, возвращает поток, содержащий оставшиеся элементы этого потока после удаления самой длинной префиксной последовательности элементов, соответствующих заданному предикату.
static IntStream empty()

Возвращает пустой последовательный IntStream.
IntStream filter​(IntPredicate predicate)

Возвращает поток, содержащий элементы этого потока, соответствующие заданному предикату.
OptionalInt findAny()

Возвращает OptionalInt, описывающий некоторый элемент потока, или пустой OptionalInt если поток пуст.
OptionalInt findFirst()

Возвращает OptionalInt, описывающий первый элемент этого потока, или пустой OptionalInt если поток пуст.
IntStream flatMap​(IntFunction<? extends IntStream> mapper)

Возвращает поток, содержащий результаты замены каждого элемента этого потока содержимым сопоставленного потока, полученного путём применения предоставленной функции сопоставления к каждому элементу.
void forEach​(IntConsumer action)

Выполняет действие для каждого элемента этого потока.
void forEachOrdered​(IntConsumer action)

Выполняет действие для каждого элемента этого потока, гарантируя, что каждый элемент обрабатывается в порядке встречи для потоков, имеющих определённый порядок встречи.
static IntStream generate​(IntSupplier s)

Возвращает бесконечный последовательный неупорядоченный поток, где каждый элемент генерируется предоставленной IntSupplier.
static IntStream iterate​(int seed, IntPredicate hasNext, IntUnaryOperator next)

Возвращает последовательный упорядоченный IntStream, полученный итерационным применением данной next функции к начальному элементу, с учётом выполнения заданного hasNext предиката.
static IntStream iterate​(int seed, IntUnaryOperator f)

Возвращает бесконечный последовательный упорядоченный IntStream, полученный итерационным применением функции f к начальному элементу seed, создавая Stream, состоящий из seed, f(seed), f(f(seed)), и так далее.
IntStream limit​(long maxSize)

Возвращает поток, содержащий элементы этого потока, усечённые до длины не более maxSize.
IntStream map​(IntUnaryOperator mapper)

Возвращает поток, содержащий результаты применения данной функции к элементам этого потока.
DoubleStream mapToDouble​(IntToDoubleFunction mapper)

Возвращает DoubleStream, содержащий результаты применения данной функции к элементам этого потока.
LongStream mapToLong​(IntToLongFunction mapper)

Возвращает LongStream, содержащий результаты применения данной функции к элементам этого потока.
<U> Stream<U> mapToObj​(IntFunction<? extends U> mapper)

Возвращает Stream со значениями типа объект, содержащий результаты применения данной функции к элементам этого потока.
OptionalInt max()

Возвращает OptionalInt, описывающую максимальный элемент этого потока, или пустой необязательный объект, если этот поток пуст.
OptionalInt min()

Возвращает OptionalInt, описывающую минимальный элемент этого потока, или пустой необязательный объект, если этот поток пуст.
boolean noneMatch​(IntPredicate predicate)

Возвращает значение, указывающее, не соответствуют ли никакие элементы этого потока предоставленному предикату.
static IntStream of​(int t)

Возвращает последовательный IntStream, содержащий один элемент.
static IntStream of​(int... values)

Возвращает последовательный упорядоченный поток, элементы которого — указанные значения.
IntStream peek​(IntConsumer action)

Возвращает поток, содержащий элементы этого потока, дополнительно выполняющий предоставленное действие над каждым элементом при извлечении элементов из результирующего потока.
static IntStream range​(int startInclusive, int endExclusive)

Возвращает последовательный упорядоченный IntStream от startInclusive (включительно) до endExclusive (исключительно) с приращением 1.
static IntStream rangeClosed​(int startInclusive, int endInclusive)

Возвращает последовательный упорядоченный IntStream от startInclusive (включительно) до endInclusive (включительно) с приращением 1.
int reduce​(int identity, IntBinaryOperator op)

Выполняет операцию сокращения над элементами этого потока, используя предоставленное значение идентификатора и функцию накопления, ассоциативную с точки зрения OptionalInt, и возвращает значение, полученное в результате сокращения.
OptionalInt reduce​(IntBinaryOperator op)

Выполняет операцию сокращения над элементами этого потока, используя ассоциативную функцию накопления, и возвращает OptionalInt, описывающую значение, полученное в результате сокращения, если оно есть.
IntStream skip​(long n)

Возвращает поток, содержащий оставшиеся элементы этого потока после удаления первых n элементов потока.
IntStream sorted()

Возвращает поток, содержащий элементы этого потока в отсортированном порядке.
int sum()

Возвращает сумму элементов в этом потоке.
IntSummaryStatistics summaryStatistics()

Возвращает IntSummaryStatistics, описывающее различные сводные данные об элементах этого потока.
default IntStream takeWhile​(IntPredicate predicate)

Если этот поток упорядочен, возвращает поток, содержащий самую длинную префиксную последовательность элементов, взятых из этого потока, соответствующих заданному предикату.
int[] toArray()

Возвращает массив, содержащий элементы этого потока.

Методы, объявленные в интерфейсе java.util.stream.BaseStream

close, isParallel, iterator, onClose, parallel, sequential, spliterator, unordered

Методы

filter

IntStream filter(IntPredicate predicate)

Возвращает поток, состоящий из элементов этого потока, соответствующих заданному предикату.

Это промежуточная операция.

Параметры:
predicate - предикат, который применяется к каждому элементу, чтобы определить, следует ли его включать
Возвращает:
новый поток

map

IntStream map(IntUnaryOperator mapper)

Возвращает поток, состоящий из результатов применения заданной функции к элементам этого потока.

Это промежуточная операция.

Параметры:
mapper - функция, которая применяется к каждому элементу
Возвращает:
новый поток

mapToObj

<U> Stream<U> mapToObj(IntFunction<? extends U> mapper)

Возвращает поток с объектами Stream, состоящий из результатов применения заданной функции к элементам этого потока.

Это промежуточная операция.

Параметры типа:
U - тип элементов нового потока
Параметры:
mapper - функция, которая применяется к каждому элементу
Возвращает:
новый поток

mapToLong

LongStream mapToLong(IntToLongFunction mapper)

Возвращает поток LongStream , состоящий из результатов применения заданной функции к элементам этого потока.

Это промежуточная операция.

Параметры:
mapper - функция, которая применяется к каждому элементу
Возвращает:
новый поток

mapToDouble

DoubleStream mapToDouble(IntToDoubleFunction mapper)

Возвращает поток DoubleStream , состоящий из результатов применения заданной функции к элементам этого потока.

Это промежуточная операция.

Параметры:
mapper - функция, которая применяется к каждому элементу
Возвращает:
новый поток

flatMap

IntStream flatMap(IntFunction<? extends IntStream> mapper)

Возвращает поток, состоящий из результатов замены каждого элемента этого потока содержимым отображённого потока, созданного путём применения заданной функции отображения к каждому элементу. Каждый отображённый поток closed после того, как его содержимое будет помещено в этот поток. (Если отображённый поток null , вместо этого используется пустой поток.)

Это промежуточная операция.

Параметры:
mapper - функция, которая применяется к каждому элементу и которая создаёт IntStream новых значений
Возвращает:
новый поток
См. также:
Stream.flatMap(Function)

distinct

IntStream distinct()

Возвращает поток, состоящий из уникальных элементов этого потока.

Это операция со состоянием.

Возвращает:
новый поток

sorted

IntStream sorted()

Возвращает поток, содержащий элементы этого потока в отсортированном порядке.

Это операция со состоянием.

Возвращает:
новый поток

peek

IntStream peek(IntConsumer action)

Возвращает поток, состоящий из элементов этого потока, дополнительно выполняющий предоставленное действие над каждым элементом по мере потребления элементов из результирующего потока.

Это промежуточная операция.

Для параллельных потоков действия могут вызываться в любое время и в любой потоке, в котором элемент становится доступным от upstream операции. Если действие изменяет общее состояние, оно отвечает за предоставление необходимой синхронизации.

Примечание API:
Этот метод существует в основном для отладки, где вы хотите увидеть элементы по мере их прохождения через определенную точку в конвейере: 
IntStream.of(1, 2, 3, 4)
         .filter(e -> e > 2)
         .peek(e -> System.out.println("Filtered value: " + e))
         .map(e -> e * e)
         .peek(e -> System.out.println("Mapped value: " + e))
         .sum();

В случаях, когда реализация потока может оптимизировать производство некоторых или всех элементов (таких как операции с коротким замыканием, например findFirst, или в примере, описанном в count()), действие не будет вызвано для этих элементов.

Параметры:
action - действие, выполняемое над элементами по мере их потребления из потока
Возвращает:
новый поток

limit

IntStream limit(long maxSize)

Возвращает поток, состоящий из элементов этого потока, усечённых до длины не более maxSize.

Это операция с состоянием с коротким замыканием.

Примечание API:
Хотя limit() обычно является недорогой операцией в последовательных потоковых конвейерах, она может быть довольно дорогой в упорядоченных параллельных конвейерах, особенно для больших значений maxSize, поскольку limit(n) ограничен возвратом не только любых n элементов, но и первых n элементов в порядке встречи. Использование неупорядоченного источника потока (например, generate(IntSupplier)) или удаление ограничения упорядоченности с помощью BaseStream.unordered() может привести к существенному ускорению limit() в параллельных конвейерах, если семантика вашей ситуации это допускает. Если соблюдение порядка встречи обязательно, и вы испытываете плохую производительность или использование памяти с limit() в параллельных конвейерах, переход к последовательному выполнению с помощью BaseStream.sequential() может улучшить производительность.
Параметры:
maxSize - количество элементов, до которого должен быть ограничен поток
Возвращает:
новый поток
Исключения:
IllegalArgumentException - если maxSize отрицательное

skip

IntStream skip(long n)

Возвращает поток, состоящий из оставшихся элементов этого потока после удаления первых n элементов потока. Если в этом потоке меньше, чем n элементов, то будет возвращен пустой поток.

Это операция со состоянием.

Примечание API:
Хотя skip() обычно является недорогой операцией в последовательных потоковых конвейерах, она может быть довольно дорогой в упорядоченных параллельных конвейерах, особенно для больших значений n, поскольку skip(n) ограничен пропусканием не только любых n элементов, но и первых n элементов в порядке встречи. Использование неупорядоченного источника потока (например, generate(IntSupplier)) или удаление ограничения упорядоченности с помощью BaseStream.unordered() может привести к существенному ускорению skip() в параллельных конвейерах, если семантика вашей ситуации это допускает. Если соблюдение порядка встречи обязательно, и вы испытываете плохую производительность или использование памяти с skip() в параллельных конвейерах, переход к последовательному выполнению с помощью BaseStream.sequential() может улучшить производительность.
Параметры:
n - количество ведущих элементов для пропуска
Возвращает:
новый поток
Исключения:
IllegalArgumentException - если n отрицательное

takeWhile

default IntStream takeWhile(IntPredicate predicate)

Возвращает, если этот поток упорядочен, поток, состоящий из самого длинного префикса элементов, взятых из этого потока, которые соответствуют заданному предикату. В противном случае, если этот поток неупорядочен, возвращает поток, состоящий из подмножества элементов, взятых из этого потока, которые соответствуют заданному предикату.

Если этот поток упорядочен, то самый длинный префикс - это непрерывная последовательность элементов этого потока, которые соответствуют заданному предикату. Первый элемент последовательности - это первый элемент этого потока, а элемент, непосредственно следующий за последним элементом последовательности, не соответствует заданному предикату.

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

Независимо от того, упорядочен ли этот поток или нет, если все элементы этого потока соответствуют заданному предикату, то эта операция берет все элементы (результат такой же, как входной), или если ни один элемент потока не соответствует заданному предикату, то не берутся никакие элементы (результат - пустой поток).

Это операция с состоянием с коротким замыканием.

Примечание API:
Хотя takeWhile() обычно является быстрой операцией в последовательных потоковых конвейерах, она может быть довольно медленной в упорядоченных параллельных конвейерах, так как операция должна возвращать не просто любой допустимый префикс, а самый длинный префикс элементов в порядке встречи. Использование источника потока без порядка (такого как generate(IntSupplier)) или удаление ограничения порядка с помощью BaseStream.unordered() может привести к значительному ускорению takeWhile() в параллельных конвейерах, если семантика вашей ситуации это допускает. Если требуется согласованность с порядком встречи, и вы сталкиваетесь с плохой производительностью или использованием памяти с takeWhile() в параллельных конвейерах, переключение на последовательное выполнение с помощью BaseStream.sequential() может улучшить производительность.
Требования к реализации:
Встроенная реализация получает spliterator данного потока, оборачивает этот разделитель для поддержки семантики этой операции при прохождении и возвращает новый поток, связанный с обернутым разделителем. Возвращаемый поток сохраняет характеристики выполнения этого потока (в частности, параллельное или последовательное выполнение в соответствии с BaseStream.isParallel()), но обернутый разделитель может выбрать, не поддерживать разделение. При закрытии возвращаемого потока вызываются обработчики закрытия как для возвращаемого, так и для текущего потока.
Параметры:
predicate - предикат, не влияющий на состояние, не имеющий состояния, применяемый к элементам для определения самого длинного префикса элементов.
Возвращает:
новый поток
С:
9

dropWhile

default IntStream dropWhile(IntPredicate predicate)

Возвращает, если этот поток упорядочен, поток, состоящий из оставшихся элементов этого потока после удаления самого длинного префикса элементов, соответствующих заданному предикату. В противном случае, если этот поток неупорядочен, возвращает поток, состоящий из оставшихся элементов этого потока после удаления подмножества элементов, соответствующих заданному предикату.

Если этот поток упорядочен, то самый длинный префикс — это непрерывная последовательность элементов этого потока, соответствующих заданному предикату. Первый элемент последовательности — первый элемент этого потока, а элемент, непосредственно следующий за последним элементом последовательности, не соответствует заданному предикату.

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

Независимо от того, упорядочен ли этот поток или нет, если все элементы потока соответствуют заданному предикату, то эта операция удаляет все элементы (результатом является пустой поток), или если ни один элемент потока не соответствует заданному предикату, то элементы не удаляются (результат такой же, как и вход).

Это состоятельная промежуточная операция.

Примечание API:
Хотя dropWhile() обычно является быстрой операцией в последовательных потоковых конвейерах, она может быть довольно медленной в упорядоченных параллельных конвейерах, так как операция должна возвращать не просто любой допустимый префикс, а самый длинный префикс элементов в порядке встречи. Использование источника потока без порядка (такого как generate(IntSupplier)) или удаление ограничения порядка с помощью BaseStream.unordered() может привести к значительному ускорению dropWhile() в параллельных конвейерах, если семантика вашей ситуации это допускает. Если требуется согласованность с порядком встречи, и вы сталкиваетесь с плохой производительностью или использованием памяти с dropWhile() в параллельных конвейерах, переключение на последовательное выполнение с помощью BaseStream.sequential() может улучшить производительность.
Требования к реализации:
Встроенная реализация получает spliterator данного потока, оборачивает этот разделитель для поддержки семантики этой операции при прохождении и возвращает новый поток, связанный с обернутым разделителем. Возвращаемый поток сохраняет характеристики выполнения этого потока (в частности, параллельное или последовательное выполнение в соответствии с BaseStream.isParallel()), но обернутый разделитель может выбрать, не поддерживать разделение. При закрытии возвращаемого потока вызываются обработчики закрытия как для возвращаемого, так и для текущего потока.
Параметры:
predicate - предикат, не влияющий на состояние, не имеющий состояния, применяемый к элементам для определения самого длинного префикса элементов.
Возвращает:
новый поток
С:
9

forEach

void forEach(IntConsumer action)

Выполняет действие для каждого элемента этого потока.

Это конечная операция.

Для параллельных конвейеров потоков эта операция не гарантирует соблюдение порядка встречи потока, так как это бы пожертвовало преимуществами параллелизма. Для любого данного элемента действие может быть выполнено в любое время и в любом потоке, который выбирает библиотека. Если действие обращается к общим данным, оно отвечает за предоставление необходимой синхронизации.

Параметры:
action - действие, не влияющее на состояние, для выполнения над элементами

forEachOrdered

void forEachOrdered(IntConsumer action)

Выполняет действие для каждого элемента этого потока, гарантируя, что каждый элемент обрабатывается в порядке встречи для потоков, имеющих определенный порядок встречи.

Это конечная операция.

Параметры:
action - действие, не влияющее на состояние, для выполнения над элементами
См. также:
forEach(IntConsumer)

toArray

int[] toArray()

Возвращает массив, содержащий элементы этого потока.

Это конечная операция.

Возвращает:
массив, содержащий элементы этого потока

reduce

int reduce(int identity,
           IntBinaryOperator op)

Выполняет редукцию над элементами этого потока, используя предоставленное значение идентичности и ассоциативную функцию накопления и возвращает значение, полученное в результате редукции. Это эквивалентно: 

int result = identity;
     for (int element : this stream)
         result = accumulator.applyAsInt(result, element)
     return result;
, но не ограничено последовательным выполнением.

Значение identity должно быть тождеством для функции накопления. Это означает, что для всех x, accumulator.apply(identity, x) равно x. Функция accumulator должна быть ассоциативной функцией.

Это конечная операция.

Примечание API:
Суммирование, минимум, максимум и среднее значение — все это частные случаи редукции. Суммирование потока чисел может быть выражено как: 
int sum = integers.reduce(0, (a, b) -> a+b);
или более кратко: 
int sum = integers.reduce(0, Integer::sum);

Хотя это может показаться более окольным способом выполнения агрегирования по сравнению с простым изменением текущей суммы в цикле, операции редукции лучше масштабируются при параллельном выполнении без необходимости дополнительной синхронизации и с значительно меньшим риском гонок данных.

Параметры:
identity - значение тождества для функции накопления
op - ассоциативная, не влияющая на состояние, бессостоятельная функция для объединения двух значений
Возвращает:
результат редукции
См. также:
sum(), min(), max(), average()

reduce

OptionalInt reduce(IntBinaryOperator op)

Выполняет редукцию над элементами этого потока, используя ассоциативную функцию накопления и возвращает OptionalInt, описывающее результирующее значение, если таковое имеется. Это эквивалентно: 

boolean foundAny = false;
     int result = null;
     for (int element : this stream) {
         if (!foundAny) {
             foundAny = true;
             result = element;
         }
         else
             result = accumulator.applyAsInt(result, element);
     }
     return foundAny ? OptionalInt.of(result) : OptionalInt.empty();
, но не ограничено последовательным выполнением.

Функция accumulator должна быть ассоциативной функцией.

Это конечная операция.

Параметры:
op - ассоциативная, не влияющая на состояние, бессостоятельная функция для объединения двух значений
Возвращает:
результат редукции
См. также:
reduce(int, IntBinaryOperator)

collect

<R> R collect(Supplier<R> supplier,
              ObjIntConsumer<R> accumulator,
              BiConsumer<R,​R> combiner)

Выполняет операцию изменяемой редукции над элементами этого потока. Изменяемая редукция — это операция, в которой значение, полученное в результате редукции, представляет собой контейнер результата с изменяемым состоянием, например ArrayList, и элементы включаются путём обновления состояния результата, а не заменой результата. Это приводит к результату, эквивалентному: 

R result = supplier.get();
     for (int element : this stream)
         accumulator.accept(result, element);
     return result;

Как и reduce(int, IntBinaryOperator), операции collect могут быть выполнены параллельно без необходимости дополнительной синхронизации.

Это конечная операция.

Параметры типа:
R — тип контейнера результатов, изменяемого во время выполнения
Параметры:
supplier — функция, создающая новый изменяемый контейнер результатов. При параллельном выполнении эта функция может быть вызвана несколько раз и должна возвращать новое значение каждый раз.
accumulator — ассоциативная, не вызывающая побочных эффектов, бессостоятельная функция, которая складывает элемент в контейнер результатов.
combiner — ассоциативная, не вызывающая побочных эффектов, бессостоятельная функция, которая принимает два частичных контейнера результатов и объединяет их, совместимая с функцией аккумулятора. Функция объединения должна складывать элементы из второго контейнера результатов в первый контейнер результатов.
Возвращает:
результат сокращения
См. также:
Stream.collect(Supplier, BiConsumer, BiConsumer)

сумма

int sum()

Возвращает сумму элементов в этом потоке. Это частный случай сокращения и эквивалентен: 

return reduce(0, Integer::sum);

Это конечная операция.

Возвращает:
сумму элементов в этом потоке

минимум

OptionalInt min()

Возвращает OptionalInt , описывающую минимальный элемент этого потока, или пустой OptionalInt , если этот поток пустой. Это частный случай сокращения и эквивалентен: 

return reduce(Integer::min);

Это конечная операция.

Возвращает:
OptionalInt , содержащую минимальный элемент этого потока, или пустой OptionalInt , если поток пустой

максимум

OptionalInt max()

Возвращает OptionalInt , описывающую максимальный элемент этого потока, или пустой OptionalInt , если этот поток пустой. Это частный случай сокращения и эквивалентен: 

return reduce(Integer::max);

Это конечная операция.

Возвращает:
OptionalInt , содержащую максимальный элемент этого потока, или пустой OptionalInt , если поток пустой

количество

long count()

Возвращает количество элементов в этом потоке. Это частный случай сокращения и эквивалентен: 

return mapToLong(e -> 1L).sum();

Это конечная операция.

Примечание API:
Реализация может выбрать не выполнять потоковую обработку (ни последовательно, ни параллельно), если она способна вычислить количество элементов непосредственно из источника потока. В таких случаях элементы источника не будут просматриваться, и промежуточные операции не будут оцениваться. Параметры поведения с побочными эффектами, которые крайне нежелательны, за исключением безобидных случаев, таких как отладка, могут быть затронуты. Например, рассмотрим следующий поток: 
IntStream s = IntStream.of(1, 2, 3, 4);
     long count = s.peek(System.out::println).count();
Количество элементов, охваченных источником потока, известно, и промежуточная операция, peek, не вводит в поток и не удаляет элементы из потока (в отличие от flatMap или filter операций). Таким образом, количество равно 4, и нет необходимости выполнять обработку потока и, как побочный эффект, выводить элементы.
Возвращает:
количество элементов в этом потоке

среднее

OptionalDouble average()

Возвращает OptionalDouble , описывающую среднее арифметическое элементов этого потока, или пустой OptionalDouble , если этот поток пустой. Это частный случай сокращения.

Это конечная операция.

Возвращает:
OptionalDouble , содержащую среднее значение элементов этого потока, или пустой OptionalDouble , если поток пустой

статистические данные

IntSummaryStatistics summaryStatistics()

Возвращает IntSummaryStatistics , описывающую различные статистические данные об элементах этого потока. Это частный случай сокращения.

Это конечная операция.

Возвращает:
IntSummaryStatistics , описывающая различные статистические данные об элементах этого потока

любой

boolean anyMatch(IntPredicate predicate)

Возвращает значение, указывающее, соответствуют ли какие-либо элементы этого потока заданному предикату. Предикат может не быть вычислен для всех элементов, если это не необходимо для определения результата. Если поток пустой, возвращается false , и предикат не вычисляется.

Это короткозамкнутая конечная операция.

Примечание API:
Этот метод оценивает экзистенциальное квантификация предиката над элементами потока (для некоторого x P(x)).
Параметры:
predicate — не вызывающий побочных эффектов, бессостоятельный предикат, применяемый к элементам этого потока
Возвращает:
true , если какие-либо элементы потока соответствуют заданному предикату, в противном случае false

все

boolean allMatch(IntPredicate predicate)

Возвращает значение, указывающее, соответствуют ли все элементы этого потока заданному предикату. Предикат может не быть вычислен для всех элементов, если это не необходимо для определения результата. Если поток пустой, возвращается true , и предикат не вычисляется.

Это короткозамкнутая конечная операция.

Примечание API:
Этот метод оценивает универсальную квантификацию предиката над элементами потока (для всех x P(x)). Если поток пустой, квантификация считается пустым выполнением и всегда true (независимо от P(x)).
Параметры:
predicate — не вызывающий побочных эффектов, бессостоятельный предикат, применяемый к элементам этого потока
Возвращает:
true , если все элементы потока соответствуют заданному предикату или поток пустой, в противном случае false

ни один

boolean noneMatch(IntPredicate predicate)

Возвращает значение, указывающее, не соответствует ли ни один элемент этого потока заданному предикату. Предикат может не быть вычислен для всех элементов, если это не необходимо для определения результата. Если поток пустой, возвращается true , и предикат не вычисляется.

Это короткозамкнутая конечная операция.

Примечание API:
Этот метод оценивает универсальную квантификацию отрицания предиката над элементами потока (для всех x ~P(x)). Если поток пустой, квантификация считается пустым выполнением и всегда true, независимо от P(x).
Параметры:
predicate — не вызывающий побочных эффектов, бессостоятельный предикат, применяемый к элементам этого потока
Возвращает:
true , если ни один элемент потока не соответствует заданному предикату или поток пустой, в противном случае false

первый

OptionalInt findFirst()

Возвращает OptionalInt , описывающую первый элемент этого потока, или пустой OptionalInt , если поток пустой. Если у потока нет порядка обхода, то может быть возвращен любой элемент.

Это короткозамкнутая конечная операция.

Возвращает:
OptionalInt , описывающую первый элемент этого потока, или пустой OptionalInt , если поток пустой

любой элемент

OptionalInt findAny()

Возвращает OptionalInt , описывающую некоторый элемент потока, или пустой OptionalInt , если поток пустой.

Это короткозамкнутая конечная операция.

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

Возвращает:
OptionalInt , описывающую некоторый элемент этого потока, или пустой OptionalInt , если поток пустой
См. также:
findFirst()

как поток long

LongStream asLongStream()

Возвращает LongStream , состоящий из элементов этого потока, преобразованных в long.

Это промежуточная операция.

Возвращает:
LongStream , состоящий из элементов этого потока, преобразованных в long

как поток double

DoubleStream asDoubleStream()

Возвращает DoubleStream , состоящий из элементов этого потока, преобразованных в double.

Это промежуточная операция.

Возвращает:
DoubleStream , состоящий из элементов этого потока, преобразованных в double

упакованный

Stream<Integer> boxed()

Возвращает Stream , состоящий из элементов этого потока, каждый из которых упакован в Integer.

Это промежуточная операция.

Возвращает:
Stream , состоящий из элементов этого потока, каждый из которых упакован в Integer

построитель

static IntStream.Builder builder()

Возвращает построитель для IntStream.

Возвращает:
построитель потока

пустой

static IntStream empty()

Возвращает пустой последовательный IntStream.

Возвращает:
пустой последовательный поток

из

static IntStream of(int t)

Возвращает последовательный IntStream содержащий один элемент.

Параметры:
t - единственный элемент
Возвращает:
последовательный поток из одного элемента

of

static IntStream of(int... values)

Возвращает упорядоченный последовательный поток, элементы которого — указанные значения.

Параметры:
values - элементы нового потока
Возвращает:
новый поток

iterate

static IntStream iterate(int seed,
                         IntUnaryOperator f)

Возвращает бесконечный упорядоченный IntStream, полученный итерационным применением функции f к начальному элементу seed, создавая Stream, состоящий из seed, f(seed), f(f(seed)) и т.д.

Первый элемент (позиция 0) в IntStream будет предоставленным seed. Для n > 0, элемент на позиции n, будет результатом применения функции f к элементу на позиции n - 1.

Действие применения f для одного элемента происходит до действия применения f для последующих элементов. Для любого данного элемента действие может быть выполнено в любой потоке, выбранной библиотекой.

Параметры:
seed - начальный элемент
f - функция, применяемая к предыдущему элементу для получения нового элемента
Возвращает:
новый последовательный IntStream

iterate

static IntStream iterate(int seed,
                         IntPredicate hasNext,
                         IntUnaryOperator next)

Возвращает упорядоченный последовательный IntStream, полученный итерационным применением заданной функции next к начальному элементу, при условии выполнения заданного hasNext предиката. Поток завершается, как только hasNext предикат возвращает false.

IntStream.iterate должен создавать ту же последовательность элементов, что и соответствующий цикл for:

for (int index=seed; hasNext.test(index); index = next.applyAsInt(index)) {
         ...
     }

Полученная последовательность может быть пустой, если hasNext предикат не выполняется для начального значения. В противном случае, первым элементом будет заданное seed значение, следующим (если он есть) — результат применения next функции к seed значению, и так далее до тех пор, пока hasNext предикат не укажет на завершение потока.

Действие применения hasNext предиката к элементу происходит до действия применения next функции к этому элементу. Действие применения next функции к одному элементу происходит до действия применения hasNext предиката к последующим элементам. Для любого данного элемента действие может быть выполнено в любом потоке, выбранном библиотекой.

Параметры:
seed - начальный элемент
hasNext - предикат для определения момента завершения потока.
next - функция, применяемая к предыдущему элементу для получения нового элемента
Возвращает:
новый последовательный IntStream
С:
9

generate

static IntStream generate(IntSupplier s)

Возвращает бесконечный неупорядоченный последовательный поток, где каждый элемент генерируется предоставленным IntSupplier. Это подходит для генерации постоянных потоков, потоков случайных элементов и т.д.

Параметры:
s - генератор для сгенерированных элементов
Возвращает:
новый бесконечный последовательный неупорядоченный IntStream

range

static IntStream range(int startInclusive,
                       int endExclusive)

Возвращает упорядоченный последовательный IntStream от startInclusive (включительно) до endExclusive (исключительно) с шагом инкремента 1.

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

Эквивалентную последовательность возрастающих значений можно создать последовательно с помощью цикла for, как показано ниже:

for (int i = startInclusive; i < endExclusive ; i++) { ... }
Параметры:
startInclusive - начальное значение (включительно)
endExclusive - верхняя граница (исключительно)
Возвращает:
последовательный IntStream для диапазона int элементов

rangeClosed

static IntStream rangeClosed(int startInclusive,
                             int endInclusive)

Возвращает упорядоченный последовательный IntStream от startInclusive (включительно) до endInclusive (включительно) с шагом инкремента 1.

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

Эквивалентную последовательность возрастающих значений можно создать последовательно с помощью цикла for, как показано ниже:

for (int i = startInclusive; i <= endInclusive ; i++) { ... }
Параметры:
startInclusive - начальное значение (включительно)
endInclusive - верхняя граница (включительно)
Возвращает:
последовательный IntStream для диапазона int элементов

concat

static IntStream concat(IntStream a,
                        IntStream b)

Создает лениво конкатенированный поток, элементы которого — все элементы первого потока, за которым следуют все элементы второго потока. Результирующий поток упорядочен, если оба входных потока упорядочены, и параллелен, если один из входных потоков параллелен. При закрытии результирующего потока вызываются обработчики закрытия для обоих входных потоков.

Этот метод работает с двумя входными потоками и связывает каждый поток с его источником. В результате последующие изменения источника входного потока могут не отражаться в результирующем конкатенированном потоке.

Примечание API:
Для сохранения возможностей оптимизации этот метод связывает каждый поток со своим источником и принимает только два потока в качестве параметров. Например, точный размер источника конкатенированного потока может быть вычислен, если точный размер источника каждого входного потока известен. Для конкатенации более потоков без привязки или без вложенных вызовов этого метода, попробуйте создать поток потоков и выполнить флат-маппинг с функцией тождества, например: 
IntStream concat = Stream.of(s1, s2, s3, s4).flatMapToInt(s -> s);
Примечание реализации:
Будьте осторожны при построении потоков из многократной конкатенации. Доступ к элементу глубоко конкатенированного потока может привести к глубоким цепочкам вызовов или даже к StackOverflowError.
Параметры:
a - первый поток
b - второй поток
Возвращает:
конкатенация двух входных потоков

© 1993, 2020, Oracle and/or its affiliates. All rights reserved.
Documentation extracted from Debian's OpenJDK Development Kit package.
Licensed under the GNU General Public License, version 2, with the Classpath Exception.
Various third party code in OpenJDK is licensed under different licenses (see Debian package).
Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.
https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/stream/IntStream.html

Spec-Zone .ru
спецификации, руководства, описания, API