Интерфейс LongStream

LongStream filter(LongPredicate predicate)

Параметры:

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

Возвращает:

новый поток

LongStream map(LongUnaryOperator mapper)

Параметры:

mapper — функция, которая должна быть не мешающей и без сохранения состояния; применяется к каждому элементу

Возвращает:

новый поток

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

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

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

Параметры:

mapper — функция, которая должна быть не мешающей и без сохранения состояния; применяется к каждому элементу

Возвращает:

новый поток

IntStream mapToInt(LongToIntFunction mapper)

Параметры:

mapper — функция, которая должна быть не мешающей и без сохранения состояния; применяется к каждому элементу

Возвращает:

новый поток

DoubleStream mapToDouble(LongToDoubleFunction mapper)

Параметры:

mapper — функция, которая должна быть не мешающей и без сохранения состояния; применяется к каждому элементу

Возвращает:

новый поток

LongStream flatMap(LongFunction<? extends LongStream> mapper)

Параметры:

mapper — функция, которая должна быть не мешающей и без сохранения состояния; применяется к каждому элементу и создаёт LongStream новых значений

Возвращает:

новый поток

См. также:

• Stream.flatMap(Function)

default LongStream mapMulti(LongStream.LongMapMultiConsumer mapper)

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

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

Параметры:

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

Возвращает:

новый поток

Начиная с версии:

16

См. также:

• Stream.mapMulti

LongStream distinct()

Возвращает:

новый поток

LongStream sorted()

Возвращает:

новый поток

LongStream peek(LongConsumer action)

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

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

    LongStream.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 — не мешающее действие, выполняемое над элементами по мере их потребления из потока

Возвращает:

новый поток

LongStream limit(long maxSize)

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

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

Параметры:

maxSize — число элементов, до которого следует ограничить поток

Возвращает:

новый поток

Исключения:

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

LongStream skip(long n)

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

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

Параметры:

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

Возвращает:

новый поток

Исключения:

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

default LongStream takeWhile(LongPredicate predicate)

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

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

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

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

Параметры:

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

Возвращает:

новый поток

Начиная с версии:

9

default LongStream dropWhile(LongPredicate predicate)

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

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

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

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

Параметры:

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

Возвращает:

новый поток

Начиная с версии:

9

void forEach(LongConsumer action)

Параметры:

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

void forEachOrdered(LongConsumer action)

Параметры:

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

См. также:

• forEach(LongConsumer)

long[] toArray()

Возвращает:

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

long reduce(long identity, LongBinaryOperator op)

    long result = identity;
    for (long element : this stream)
        result = accumulator.applyAsLong(result, element)
    return result;

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

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

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

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

    long sum = integers.reduce(0, Long::sum);

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

Параметры:

identity — нейтральное значение для функции накопления

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

Возвращает:

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

См. также:

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

OptionalLong reduce(LongBinaryOperator op)

    boolean foundAny = false;
    long result = null;
    for (long element : this stream) {
        if (!foundAny) {
            foundAny = true;
            result = element;
        }
        else
            result = accumulator.applyAsLong(result, element);
    }
    return foundAny ? OptionalLong.of(result) : OptionalLong.empty();

Параметры:

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

Возвращает:

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

См. также:

• reduce(long, LongBinaryOperator)

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

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

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

R — тип изменяемого контейнера результата

Параметры:

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

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

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

Возвращает:

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

См. также:

• Stream.collect(Supplier, BiConsumer, BiConsumer)

long sum()

    return reduce(0, Long::sum);

Возвращает:

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

OptionalLong min()

    return reduce(Long::min);

Возвращает:

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

OptionalLong max()

    return reduce(Long::max);

Возвращает:

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

long count()

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

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

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

    LongStream s = LongStream.of(1, 2, 3, 4);
    long count = s.peek(System.out::println).count();

Число элементов, охватываемых источником потока, известно, а промежуточная операция peek не добавляет и не удаляет элементы из потока (как это может происходить при операциях flatMap или filter). Поэтому количество равно 4, и выполнять конвейер нет необходимости, а значит, побочный эффект в виде вывода элементов не произойдёт.

Возвращает:

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

OptionalDouble average()

Возвращает:

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

LongSummaryStatistics summaryStatistics()

Возвращает:

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

boolean anyMatch(LongPredicate predicate)

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

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

Параметры:

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

Возвращает:

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

boolean allMatch(LongPredicate predicate)

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

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

Параметры:

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

Возвращает:

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

boolean noneMatch(LongPredicate predicate)

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

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

Параметры:

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

Возвращает:

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

OptionalLong findFirst()

Возвращает:

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

OptionalLong findAny()

Возвращает:

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

См. также:

• findFirst()

DoubleStream asDoubleStream()

Возвращает:

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

Stream<Long> boxed()

Возвращает:

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

static LongStream.Builder builder()

Возвращает:

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

static LongStream empty()

Возвращает:

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

static LongStream of(long t)

Параметры:

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

Возвращает:

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

static LongStream of(long... values)

Параметры:

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

Возвращает:

новый поток

static LongStream iterate(long seed, LongUnaryOperator f)

Параметры:

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

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

Возвращает:

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

static LongStream iterate(long seed, LongPredicate hasNext, LongUnaryOperator next)

    for (long index=seed; hasNext.test(index); index = next.applyAsLong(index)) {
        ...
    }

Параметры:

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

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

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

Возвращает:

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

Начиная с:

9

static LongStream generate(LongSupplier s)

Параметры:

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

Возвращает:

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

static LongStream range(long startInclusive, long endExclusive)

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

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

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

Параметры:

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

endExclusive — исключительная верхняя граница

Возвращает:

последовательный LongStream для диапазона из long элементов

static LongStream rangeClosed(long startInclusive, long endInclusive)

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

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

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

Параметры:

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

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

Возвращает:

последовательный LongStream для диапазона из long элементов

static LongStream concat(LongStream a, LongStream b)

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

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

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

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

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

Параметры:

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

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

Возвращает:

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