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

Возвращает:

новый поток

См. также:

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

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 - второй поток

Возвращает:

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