Интерфейс IntStream

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

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

int sum = widgets.stream()
                      .filter(w -> w.getColor() == RED)
                      .mapToInt(w -> w.getWeight())
                      .sum();

Методы

filter

IntStream filter(IntPredicate predicate)

Параметры:

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

Возвращает:

новый поток

map

IntStream map(IntUnaryOperator mapper)

Параметры:

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

Возвращает:

новый поток

mapToObj

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

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

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

Параметры:

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

Возвращает:

новый поток

mapToLong

LongStream mapToLong(IntToLongFunction mapper)

Параметры:

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

Возвращает:

новый поток

mapToDouble

DoubleStream mapToDouble(IntToDoubleFunction mapper)

Параметры:

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

Возвращает:

новый поток

flatMap

IntStream flatMap(IntFunction<? extends IntStream> mapper)

Параметры:

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

Возвращает:

новый поток

См. также:

Stream.flatMap(Function)

distinct

IntStream distinct()

Возвращает:

новый поток

sorted

IntStream sorted()

Возвращает:

новый поток

peek

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

Параметры:

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

Возвращает:

новый поток

limit

IntStream limit(long maxSize)

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

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

Параметры:

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

Возвращает:

новый поток

Выбрасывает:

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

skip

IntStream skip(long n)

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

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

Параметры:

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

Возвращает:

новый поток

Выбрасывает:

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

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;

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

Sum, min, max и average — это все частные случаи редукции. Суммирование потока чисел может быть выражено как:

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)

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)

collect

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

sum

int sum()

return reduce(0, Integer::sum);

Возвращаемое значение:

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

min

OptionalInt min()

return reduce(Integer::min);

Возвращаемое значение:

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

max

OptionalInt max()

return reduce(Integer::max);

Возвращаемое значение:

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

count

long count()

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

Возвращаемое значение:

количество элементов в этом потоке

average

OptionalDouble average()

Возвращаемое значение:

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

summaryStatistics

IntSummaryStatistics summaryStatistics()

Возвращаемое значение:

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

anyMatch

boolean anyMatch(IntPredicate predicate)

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

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

Параметры:

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

Возвращаемое значение:

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

allMatch

boolean allMatch(IntPredicate predicate)

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

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

Параметры:

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

Возвращаемое значение:

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

noneMatch

boolean noneMatch(IntPredicate predicate)

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

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

Параметры:

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

Возвращаемое значение:

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

findFirst

OptionalInt findFirst()

Возвращаемое значение:

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

findAny

OptionalInt findAny()

Возвращает:

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

См. также:

findFirst()

asLongStream

LongStream asLongStream()

Возвращает:

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

asDoubleStream

DoubleStream asDoubleStream()

Возвращает:

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

boxed

Stream<Integer> boxed()

Возвращает:

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

sequential

IntStream sequential()

Описание скопировано из интерфейса: BaseStream

Определено в:

sequential в интерфейсе BaseStream<Integer,IntStream>

Возвращает:

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

parallel

IntStream parallel()

Описание скопировано из интерфейса: BaseStream

Определено в:

parallel в интерфейсе BaseStream<Integer,IntStream>

Возвращает:

параллельный поток

iterator

PrimitiveIterator.OfInt iterator()

Описание скопировано из интерфейса: BaseStream

Определено в:

iterator в интерфейсе BaseStream<Integer,IntStream>

Возвращает:

итератор элементов для этого потока

spliterator

Spliterator.OfInt spliterator()

Описание скопировано из интерфейса: BaseStream

Определено в:

spliterator в интерфейсе BaseStream<Integer,IntStream>

Возвращает:

итератор для элементов этого потока

builder

static IntStream.Builder builder()

Возвращает билдер для IntStream.

Возвращает:

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

empty

static IntStream empty()

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

Возвращает:

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

of

static IntStream of(int t)

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

Параметры:

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

Возвращает:

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

of

static IntStream of(int... values)

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

Параметры:

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

Возвращает:

новый поток

iterate

static IntStream iterate(int seed,
                         IntUnaryOperator f)

Параметры:

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

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

Возвращает:

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

generate

static IntStream generate(IntSupplier s)

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

Параметры:

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

Возвращает:

новый бесконечный последовательный неупорядоченный 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)

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

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

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

Параметры:

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

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

Возвращает:

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