Интерфейс 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 — не взаимодействующая с источником, без состояния функция, применяемая к каждому элементу и возвращающая IntStream новых значений

Возвращает:

новый поток

См. также:

• 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, содержащий минимальный элемент этого потока, или пустой OptionalInt, если поток пуст

OptionalInt max()

    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, содержащий среднее значение элементов этого потока, или пустой Optional, если поток пуст

IntSummaryStatistics summaryStatistics()

Возвращает:

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

boolean anyMatch(IntPredicate predicate)

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

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

Параметры:

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

Возвращает:

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

boolean allMatch(IntPredicate predicate)

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

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

Параметры:

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

Возвращает:

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

boolean noneMatch(IntPredicate predicate)

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

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

Параметры:

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

Возвращает:

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

OptionalInt findFirst()

Возвращает:

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

OptionalInt findAny()

Возвращает:

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

См. также:

• findFirst()

LongStream asLongStream()

Возвращает:

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

DoubleStream asDoubleStream()

Возвращает:

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

Stream<Integer> boxed()

Возвращает:

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

static IntStream.Builder builder()

Возвращает:

построитель потока

static IntStream empty()

Возвращает:

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

static IntStream of(int t)

Параметры:

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

Возвращает:

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

static IntStream of(int... values)

Параметры:

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

Возвращает:

новый поток

static IntStream iterate(int seed, IntUnaryOperator f)

Параметры:

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

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

Возвращает:

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

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

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

Параметры:

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

hasNext — предикат, применяемый к элементам для определения момента завершения потока.

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

Возвращает:

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

С момента:

9

static IntStream generate(IntSupplier s)

Параметры:

s — IntSupplier для создаваемых элементов

Возвращает:

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

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

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

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

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

Параметры:

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

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

Возвращает:

объединение двух входных потоков