Интерфейс IntStream

IntStream filter(IntPredicate predicate)

Параметры:

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

Возвращает:

новый поток

IntStream map(IntUnaryOperator mapper)

Параметры:

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

Возвращает:

новый поток

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

Параметры типа:

U - тип элементов нового потока

Параметры:

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

Возвращает:

новый поток

LongStream mapToLong(IntToLongFunction mapper)

Параметры:

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

Возвращает:

новый поток

DoubleStream mapToDouble(IntToDoubleFunction mapper)

Параметры:

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

Возвращает:

новый поток

IntStream flatMap(IntFunction<? extends IntStream> mapper)

Параметры:

mapper - функция, которая не влияет на состояние, и не зависит от состояния, применяется к каждому элементу, которая генерирует поток новых значений

Возвращает:

новый поток

См. также:

• Stream.flatMap(Function)

default IntStream mapMulti(IntStream.IntMapMultiConsumer mapper)

Требования к реализации:

По умолчанию реализация вызывает flatMap в этом потоке, передавая функцию, которая ведет себя следующим образом. Сначала она вызывает функцию отображения с IntConsumer, которая накапливает элементы замены во вновь созданный внутренний буфер. Когда функция отображения возвращается, она создаёт IntStream из внутреннего буфера. Наконец, она возвращает этот поток flatMap.

Параметры:

mapper - функция, которая не влияет на состояние, и не зависит от состояния, генерирует элементы замены

Возвращает:

новый поток

С тех пор:

16

См. также:

• Stream.mapMulti

IntStream distinct()

Возвращает:

новый поток

IntStream sorted()

Возвращает:

новый поток

IntStream peek(IntConsumer action)

Примечание 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 - действие, которое не влияет на состояние, которое должно быть выполнено над элементами по мере их потребления из потока

Возвращает:

новый поток

IntStream limit(long maxSize)

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

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

Параметры:

maxSize - количество элементов, до которого должен быть ограничен поток

Возвращает:

новый поток

Исключения:

IllegalArgumentException - если maxSize отрицательно

IntStream skip(long n)

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

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

Параметры:

n - количество пропускаемых начальных элементов

Возвращает:

новый поток

Исключения:

IllegalArgumentException - если n отрицательно

default IntStream takeWhile(IntPredicate predicate)

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

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

Требования к реализации:

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

Параметры:

predicate - невмешивающийся, бессостоятельный предикат для применения к элементам для определения самого длинного префикса элементов.

Возвращает:

новый поток

С:

9

default IntStream dropWhile(IntPredicate predicate)

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

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

Требования к реализации:

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

Параметры:

predicate - невмешивающийся, бессостоятельный предикат для применения к элементам для определения самого длинного префикса элементов.

Возвращает:

новый поток

С:

9

void forEach(IntConsumer action)

Параметры:

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

void forEachOrdered(IntConsumer action)

Параметры:

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

См. также:

• forEach(IntConsumer)

int[] toArray()

Возвращает:

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

int reduce(int identity, IntBinaryOperator op)

     int result = identity;
     for (int element : this stream)
         result = accumulator.applyAsInt(result, element)
     return result;
 

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

Сумма, минимум и максимум — это частные случаи сведения, которые можно выразить с помощью этого метода. Например, суммирование потока можно выразить как:

     int sum = integers.reduce(0, (a, b) -> a+b);
 

или более компактно:

     int sum = integers.reduce(0, Integer::sum);
 

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

Параметры:

identity - значение идентичности для функции накопления

op - ассоциативная, не вмешивающаяся, бессостоятельная функция для объединения двух значений

Возвращает:

результат сведения

См. также:

• sum()
• min()
• max()
• average()

OptionalInt reduce(IntBinaryOperator op)

     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();
 

Параметры:

op - ассоциативная, не вмешивающаяся, бессостоятельная функция для объединения двух значений

Возвращает:

результат сведения

См. также:

• reduce(int, IntBinaryOperator)

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

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

Тип параметров:

R - тип контейнера результата с возможностью изменения

Параметры:

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

accumulator - ассоциативная, не вмешивающаяся, бессостоятельная функция, которая должна складывать элемент в контейнер результата.

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

Возвращает:

результат сведения

См. также:

• Stream.collect(Supplier, BiConsumer, BiConsumer)

int sum()

     return reduce(0, Integer::sum);
 

Возвращает:

сумму элементов в этом потоке

OptionalInt min()

     return reduce(Integer::min);
 

Возвращает:

объект, содержащий минимальный элемент этого потока, или пустой объект, если поток пустой

OptionalInt max()

     return reduce(Integer::max);
 

Возвращает:

объект, содержащий максимальный элемент этого потока, или пустой объект, если поток пустой

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()

Возвращает:

объект, содержащий среднее значение элементов этого потока, или пустой объект, если поток пустой

IntSummaryStatistics summaryStatistics()

Возвращает:

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

boolean anyMatch(IntPredicate predicate)

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

Этот метод оценивает существование квантификации предиката по элементам потока (для некоторого x P(x)).

Параметры:

predicate - не вмешивающийся, бессостоятельный предикат для применения к элементам этого потока

Возвращает:

true, если какие-либо элементы потока соответствуют предоставленному предикату, в противном случае false

boolean allMatch(IntPredicate predicate)

API Note:

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

Parameters:

predicate - не влияющий, бессостоятельный предикат, который применяется к элементам этого потока

Returns:

true, если все элементы потока соответствуют предоставленному предикату или поток пустой, в противном случае false

boolean noneMatch(IntPredicate predicate)

API Note:

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

Parameters:

predicate - не влияющий, бессостоятельный предикат, который применяется к элементам этого потока

Returns:

true, если ни один элемент потока не соответствует предоставленному предикату или поток пустой, в противном случае false

OptionalInt findFirst()

Returns:

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

OptionalInt findAny()

Returns:

OptionalInt, описывающую какой-либо элемент этого потока, или пустой OptionalInt, если поток пустой

See Also:

• findFirst()

LongStream asLongStream()

Returns:

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

DoubleStream asDoubleStream()

Returns:

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

Stream<Integer> boxed()

Returns:

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

static IntStream.Builder builder()

Returns:

билдер потока

static IntStream empty()

Returns:

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

static IntStream of(int t)

Parameters:

t - единственный элемент

Returns:

последовательный поток с одним элементом

static IntStream of(int... values)

Parameters:

values - элементы нового потока

Returns:

новый поток

static IntStream iterate(int seed, IntUnaryOperator f)

Parameters:

seed - начальный элемент

f - функция, применяемая к предыдущему элементу для создания нового элемента

Returns:

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

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

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

Parameters:

seed - начальный элемент

hasNext - предикат, применяемый к элементам для определения, когда поток должен завершиться.

next - функция, применяемая к предыдущему элементу для получения нового элемента

Returns:

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

Since:

9

static IntStream generate(IntSupplier s)

Parameters:

s - функция IntSupplier для генерируемых элементов

Returns:

новый бесконечный последовательный неупорядоченный IntStream

static IntStream range(int startInclusive, int endExclusive)

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

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

     for (int i = startInclusive; i < endExclusive ; i++) { ... }
 

Параметры:

startInclusive - начальное значение (включительно)

endExclusive - верхняя граница (исключительно)

Возвращает:

упорядоченную последовательность IntStream для диапазона элементов int

static IntStream rangeClosed(int startInclusive, int endInclusive)

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

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

     for (int i = startInclusive; i <= endInclusive ; i++) { ... }
 

Параметры:

startInclusive - начальное значение (включительно)

endInclusive - верхняя граница (включительно)

Возвращает:

упорядоченную последовательность IntStream для диапазона элементов int

static IntStream concat(IntStream a, IntStream b)

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

Для сохранения возможностей оптимизации этот метод связывает каждый поток с его источником и принимает только два потока в качестве параметров. Например, точный размер источника конкатенированного потока может быть вычислен, если известен точный размер источника каждого входного потока. Для конкатенации большего количества потоков без привязки или без вложенных вызовов этого метода попробуйте создать поток потоков и выполнить flat-mapping с функцией тождества, например:

     IntStream concat = Stream.of(s1, s2, s3, s4).flatMapToInt(s -> s);
 

Примечание реализации:

Будьте осторожны при построении потоков из многократной конкатенации. Обращение к элементу глубоко конкатенированного потока может привести к глубоким цепочкам вызовов или даже к StackOverflowError.

Параметры:

a - первый поток

b - второй поток

Возвращает:

конкатенацию двух входных потоков