Интерфейс LongStream

Все суперинтерфейсы:
AutoCloseable, BaseStream<Long,​LongStream> 
public interface LongStream
extends BaseStream<Long,LongStream>

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

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

long sum = widgets.stream()
                       .filter(w -> w.getColor() == RED)
                       .mapToLong(w -> w.getWeight())
                       .sum();
См. документацию класса Stream и документацию пакета java.util.stream для дополнительной спецификации потоков, операций с потоками, конвейеров потоков и параллелизма.
С момента:
1.8
См. также:
Stream, java.util.stream

Вложенные классы

Модификатор и тип Интерфейс Описание
static interface  LongStream.Builder

Изменяемый билдер для LongStream.

Методы

Модификатор и тип Метод Описание
boolean allMatch​(LongPredicate predicate)

Возвращает, соответствуют ли все элементы этого потока предоставленному предикату.
boolean anyMatch​(LongPredicate predicate)

Возвращает, соответствует ли какой-либо элемент этого потока предоставленному предикату.
DoubleStream asDoubleStream()

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

Возвращает OptionalDouble, описывающую среднее арифметическое элементов этого потока, или пустой необязательный параметр, если этот поток пустой.
Stream<Long> boxed()

Возвращает Stream, состоящий из элементов этого потока, каждый из которых упакован в Long.
static LongStream.Builder builder()

Возвращает билдер для LongStream.
<R> R collect​(Supplier<R> supplier, ObjLongConsumer<R> accumulator, BiConsumer<R,​R> combiner)

Выполняет операцию изменяемого сведения по элементам этого потока.
static LongStream concat​(LongStream a, LongStream b)

Создает лениво конкатенированный поток, элементы которого — все элементы первого потока, за которыми следуют все элементы второго потока.
long count()

Возвращает количество элементов в этом потоке.
LongStream distinct()

Возвращает поток, состоящий из различных элементов этого потока.
default LongStream dropWhile​(LongPredicate predicate)

Возвращает, если этот поток упорядочен, поток, состоящий из оставшихся элементов этого потока после удаления наибольшего префикса элементов, соответствующих заданному предикату.
static LongStream empty()

Возвращает пустой последовательный LongStream.
LongStream filter​(LongPredicate predicate)

Возвращает поток, содержащий элементы этого потока, которые соответствуют заданному предикату.
OptionalLong findAny()

Возвращает OptionalLong, описывающий некоторый элемент потока, или пустой OptionalLong если поток пустой.
OptionalLong findFirst()

Возвращает OptionalLong, описывающий первый элемент этого потока, или пустой OptionalLong если поток пустой.
LongStream flatMap​(LongFunction<? extends LongStream> mapper)

Возвращает поток, состоящий из результатов замены каждого элемента этого потока содержимым отображённого потока, полученного путём применения указанной функции отображения к каждому элементу.
void forEach​(LongConsumer action)

Выполняет действие для каждого элемента этого потока.
void forEachOrdered​(LongConsumer action)

Выполняет действие для каждого элемента этого потока, гарантируя, что каждый элемент обрабатывается в порядке встречи для потоков, для которых определен порядок встречи.
static LongStream generate​(LongSupplier s)

Возвращает бесконечный последовательный неупорядоченный поток, где каждый элемент генерируется предоставленной LongSupplier.
static LongStream iterate​(long seed, LongPredicate hasNext, LongUnaryOperator next)

Возвращает последовательный упорядоченный LongStream, полученный итерационным применением заданной next функции к начальному элементу, при условии удовлетворения заданного hasNext предиката.
static LongStream iterate​(long seed, LongUnaryOperator f)

Возвращает бесконечный последовательный упорядоченный LongStream, полученный итерационным применением функции f к начальному элементу seed, производя Stream, состоящий из seed, f(seed), f(f(seed)), и т. д.
LongStream limit​(long maxSize)

Возвращает поток, состоящий из элементов этого потока, усечённых, чтобы их длина не превышала maxSize.
LongStream map​(LongUnaryOperator mapper)

Возвращает поток, содержащий результаты применения данной функции к элементам этого потока.
DoubleStream mapToDouble​(LongToDoubleFunction mapper)

Возвращает DoubleStream, содержащий результаты применения заданной функции к элементам этого потока.
IntStream mapToInt​(LongToIntFunction mapper)

Возвращает IntStream, содержащий результаты применения заданной функции к элементам этого потока.
<U> Stream<U> mapToObj​(LongFunction<? extends U> mapper)

Возвращает Stream типа объект, содержащий результаты применения заданной функции к элементам этого потока.
OptionalLong max()

Возвращает OptionalLong, описывающую максимальный элемент этого потока, или пустой необязательный параметр, если этот поток пустой.
OptionalLong min()

Возвращает OptionalLong, описывающую минимальный элемент этого потока, или пустой необязательный параметр, если этот поток пустой.
boolean noneMatch​(LongPredicate predicate)

Возвращает значение TRUE, если ни один элемент этого потока не соответствует предоставленному предикату.
static LongStream of​(long t)

Возвращает последовательный LongStream, содержащий один элемент.
static LongStream of​(long... values)

Возвращает последовательный упорядоченный поток, элементы которого — указанные значения.
LongStream peek​(LongConsumer action)

Возвращает поток, содержащий элементы этого потока, дополнительно выполняя указанное действие над каждым элементом при потреблении элементов из результирующего потока.
static LongStream range​(long startInclusive, long endExclusive)

Возвращает последовательный упорядоченный LongStream от startInclusive (включительно) до endExclusive (исключительно) с нарастающим шагом 1.
static LongStream rangeClosed​(long startInclusive, long endInclusive)

Возвращает последовательный упорядоченный LongStream от startInclusive (включительно) до endInclusive (включительно) с нарастающим шагом 1.
long reduce​(long identity, LongBinaryOperator op)

Выполняет сведение над элементами этого потока, используя предоставленное значение тождества и ассоциативную функцию накопления и возвращает значение сведения.
OptionalLong reduce​(LongBinaryOperator op)

Выполняет сведение над элементами этого потока, используя ассоциативную функцию накопления и возвращает OptionalLong, описывающую значение сведения, если оно есть.
LongStream skip​(long n)

Возвращает поток, состоящий из оставшихся элементов этого потока после отбрасывания первых n элементов потока.
LongStream sorted()

Возвращает поток, содержащий элементы этого потока в отсортированном порядке.
long sum()

Возвращает сумму элементов в этом потоке.
LongSummaryStatistics summaryStatistics()

Возвращает LongSummaryStatistics, описывающий различные сводные данные об элементах этого потока.
default LongStream takeWhile​(LongPredicate predicate)

Возвращает, если этот поток упорядочен, поток, содержащий самый длинный префикс элементов, взятых из этого потока, которые соответствуют заданному предикату.
long[] toArray()

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

Методы, объявленные в интерфейсе java.util.stream.BaseStream

close, isParallel, iterator, onClose, parallel, sequential, spliterator, unordered

Методы

filter

LongStream filter(LongPredicate predicate)

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

Это промежуточная операция.

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

map

LongStream map(LongUnaryOperator mapper)

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

Это промежуточная операция.

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

mapToObj

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

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

Это промежуточная операция.

Параметры типа:
U - тип элемента нового потока
Параметры:
mapper - невозмущающая, бессостоятельная функция, применяемая к каждому элементу
Возвращает:
новый поток

mapToInt

IntStream mapToInt(LongToIntFunction mapper)

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

Это промежуточная операция.

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

mapToDouble

DoubleStream mapToDouble(LongToDoubleFunction mapper)

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

Это промежуточная операция.

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

flatMap

LongStream flatMap(LongFunction<? extends LongStream> mapper)

Возвращает поток, содержащий результаты замены каждого элемента этого потока содержимым сопоставленного потока, полученного путем применения предоставленной функции отображения к каждому элементу. Каждый сопоставленный поток closed после того, как его содержимое помещено в этот поток. (Если сопоставленный поток null используется пустой поток.)

Это промежуточная операция.

Параметры:
mapper - невозмущающая, бессостоятельная функция, применяемая к каждому элементу, которая создает LongStream новых значений
Возвращает:
новый поток
См. также:
Stream.flatMap(Function)

distinct

LongStream distinct()

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

Это состоятельная промежуточная операция.

Возвращает:
новый поток

sorted

LongStream sorted()

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

Это состоятельная промежуточная операция.

Возвращает:
новый поток

peek

LongStream peek(LongConsumer action)

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

Это промежуточная операция.

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

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

limit

LongStream limit(long maxSize)

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

Это короткозамыкающая состоятельная промежуточная операция.

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

skip

LongStream skip(long n)

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

Это состоятельная промежуточная операция.

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

takeWhile

default LongStream takeWhile(LongPredicate predicate)

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

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

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

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

Это короткозамыкающая состоятельная промежуточная операция.

Примечание API:
Хотя takeWhile() обычно является недорогой операцией в потоковых конвейерах, она может быть очень дорогостоящей в упорядоченных параллельных конвейерах, поскольку операция обязана вернуть не просто любой допустимый префикс, а самый длинный префикс элементов в порядке их появления. Использование неупорядоченного источника потока (например, generate(LongSupplier)) или удаление ограничения упорядоченности с помощью BaseStream.unordered() может привести к значительному ускорению takeWhile() в параллельных конвейерах, если это позволяет семантика вашей ситуации. Если требуется согласованность с порядком появления, и вы сталкиваетесь с низкой производительностью или использованием памяти при использовании takeWhile() в параллельных конвейерах, переключение на последовательное выполнение с помощью BaseStream.sequential() может улучшить производительность.
Требования к реализации:
Базовая реализация получает spliterator этого потока, оборачивает этот разделитель для поддержки семантики этой операции при обходе и возвращает новый поток, связанный с обернутым разделителем. Возвращаемый поток сохраняет характеристики выполнения этого потока (а именно, параллельное или последовательное выполнение в соответствии с BaseStream.isParallel()), но обернутый разделитель может выбрать не поддерживать разделение. При закрытии возвращаемого потока вызываются обработчики закрытия как для возвращаемого, так и для этого потока.
Параметры:
predicate - предикат, не влияющий на состояние и не имеющий состояния, применяемый к элементам для определения самого длинного префикса элементов.
Возвращаемое значение:
новый поток
С тех пор:
9

dropWhile

default LongStream dropWhile(LongPredicate predicate)

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

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

Если этот поток неупорядочен, и некоторые (но не все) элементы этого потока соответствуют заданному предикату, то поведение этой операции является недетерминированным; оно свободно удаляет любое подмножество соответствующих элементов (включая пустое множество).

Независимо от того, упорядочен ли этот поток или нет, если все элементы потока соответствуют заданному предикату, эта операция удаляет все элементы (результат — пустой поток), или если ни один элемент потока не соответствует заданному предикату, то элементы не удаляются (результат такой же, как у входных данных).

Это состоятельная промежуточная операция.

Примечание API:
Хотя dropWhile() обычно является недорогой операцией в потоковых конвейерах, она может быть очень дорогостоящей в упорядоченных параллельных конвейерах, поскольку операция обязана вернуть не просто любой допустимый префикс, а самый длинный префикс элементов в порядке их появления. Использование неупорядоченного источника потока (например, generate(LongSupplier)) или удаление ограничения упорядоченности с помощью BaseStream.unordered() может привести к значительному ускорению dropWhile() в параллельных конвейерах, если это позволяет семантика вашей ситуации. Если требуется согласованность с порядком появления, и вы сталкиваетесь с низкой производительностью или использованием памяти при использовании dropWhile() в параллельных конвейерах, переключение на последовательное выполнение с помощью BaseStream.sequential() может улучшить производительность.
Требования к реализации:
Базовая реализация получает spliterator этого потока, оборачивает этот разделитель для поддержки семантики этой операции при обходе и возвращает новый поток, связанный с обернутым разделителем. Возвращаемый поток сохраняет характеристики выполнения этого потока (а именно, параллельное или последовательное выполнение в соответствии с BaseStream.isParallel()), но обернутый разделитель может выбрать не поддерживать разделение. При закрытии возвращаемого потока вызываются обработчики закрытия как для возвращаемого, так и для этого потока.
Параметры:
predicate - предикат, не влияющий на состояние и не имеющий состояния, применяемый к элементам для определения самого длинного префикса элементов.
Возвращаемое значение:
новый поток
С тех пор:
9

forEach

void forEach(LongConsumer action)

Выполняет действие для каждого элемента этого потока.

Это конечная операция.

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

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

forEachOrdered

void forEachOrdered(LongConsumer action)

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

Это конечная операция.

Параметры:
action - безвлияющее на состояние действие, выполняемое над элементами
См. также:
forEach(LongConsumer)

toArray

long[] toArray()

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

Это конечная операция.

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

reduce

long reduce(long identity,
            LongBinaryOperator op)

Выполняет редукцию над элементами этого потока, используя предоставленное значение идентичности и ассоциативную функцию накопления и возвращает результирующее значение. Это эквивалентно: 

long result = identity;
     for (long element : this stream)
         result = accumulator.applyAsLong(result, element)
     return result;
но не ограничено последовательным выполнением.

Значение identity должно быть тождеством для функции накопления. Это означает, что для всех x, accumulator.apply(identity, x) равно x. Функция accumulator должна быть ассоциативной функцией.

Это конечная операция.

Примечание API:
Сумма, минимум, максимум и среднее значение — это частные случаи редукции. Суммирование потока чисел может быть выражено как: 
long sum = integers.reduce(0, (a, b) -> a+b);
или более компактно: 
long sum = integers.reduce(0, Long::sum);

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

Параметры:
identity - значение идентичности для функции накопления
op - ассоциативная, не влияющая на состояние, бессостоятельная функция для объединения двух значений
Возвращаемое значение:
результат редукции
См. также:
sum(), min(), max(), average()

reduce

OptionalLong reduce(LongBinaryOperator op)

Выполняет редукцию над элементами этого потока, используя ассоциативную функцию накопления и возвращает OptionalLong, описывающую результирующее значение, если оно есть. Это эквивалентно: 

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();
но не ограничено последовательным выполнением.

Функция accumulator должна быть ассоциативной функцией.

Это конечная операция.

Параметры:
op - ассоциативная, не влияющая на состояние, бессостоятельная функция для объединения двух значений
Возвращаемое значение:
результат редукции
См. также:
reduce(long, LongBinaryOperator)

collect

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

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

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

Как и reduce(long, LongBinaryOperator), операции collect могут быть распараллелены без необходимости дополнительной синхронизации.

Это конечная операция.

Параметры типа:
R - тип контейнера изменяемого результата
Параметры:
supplier - функция, создающая новый контейнер изменяемого результата. При параллельном выполнении эта функция может вызываться несколько раз и должна возвращать новое значение каждый раз.
accumulator - ассоциативная, невзаимодействующая, бессостоятельная функция, которая должна складывать элемент в контейнер результата.
combiner - ассоциативная, невзаимодействующая, бессостоятельная функция, которая принимает два частичных контейнера результатов и объединяет их, которая должна быть совместима с функцией аккумулятора. Функция объединения должна складывать элементы из второго контейнера результата в первый контейнер результата.
Возвращает:
результат сокращения
См. также:
Stream.collect(Supplier, BiConsumer, BiConsumer)

сумма

long sum()

Возвращает сумму элементов в этом потоке. Это частный случай сокращения и эквивалентно: 

return reduce(0, Long::sum);

Это конечная операция.

Возвращает:
сумма элементов в этом потоке

мин

OptionalLong min()

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

return reduce(Long::min);

Это конечная операция.

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

макс

OptionalLong max()

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

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

Это конечная операция.

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

любой совпадает

boolean anyMatch(LongPredicate predicate)

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

Это короткая конечная операция.

Примечание API:
Этот метод вычисляет существование квантификации предиката над элементами потока (для некоторого x P(x)).
Параметры:
predicate - не вмешивающийся, бессостоятельный предикат, который нужно применить к элементам этого потока
Возвращает:
true если какие-либо элементы потока соответствуют предоставленному предикату, в противном случае false

все совпадают

boolean allMatch(LongPredicate predicate)

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

Это короткая конечная операция.

Примечание API:
Этот метод вычисляет универсальную квантификацию предиката над элементами потока (для всех x P(x)). Если поток пуст, квантификация считается пусто удовлетворительной и всегда true (независимо от P(x)).
Параметры:
predicate - не вмешивающийся, бессостоятельный предикат, который нужно применить к элементам этого потока
Возвращает:
true если все элементы потока соответствуют предоставленному предикату или поток пуст, в противном случае false

не соответствует ни одному

boolean noneMatch(LongPredicate predicate)

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

Это короткая конечная операция.

Примечание API:
Этот метод вычисляет универсальную квантификацию отрицаемого предиката над элементами потока (для всех x ~P(x)). Если поток пуст, квантификация считается пусто удовлетворительной и всегда true, независимо от P(x).
Параметры:
predicate - не вмешивающийся, бессостоятельный предикат, который нужно применить к элементам этого потока
Возвращает:
true если ни один элемент потока не соответствует предоставленному предикату или поток пуст, в противном случае false

найти первый

OptionalLong findFirst()

Возвращает OptionalLong, описывающий первый элемент этого потока, или пустой OptionalLong, если поток пуст. Если у потока нет порядка встреч, то может быть возвращён любой элемент.

Это короткая конечная операция.

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

найти любой

OptionalLong findAny()

Возвращает OptionalLong, описывающий какой-либо элемент потока, или пустой OptionalLong, если поток пуст.

Это короткая конечная операция.

Поведение этой операции явно недетерминировано; она свободна выбрать любой элемент в потоке. Это позволяет максимизировать производительность в параллельных операциях; стоимость заключается в том, что несколько вызовов одного и того же источника могут не возвращать одинаковый результат. (Если требуется стабильный результат, используйте findFirst() вместо этого.)

Возвращает:
OptionalLong, описывающий какой-либо элемент этого потока, или пустой OptionalLong, если поток пуст
См. также:
findFirst()

какDoubleStream

DoubleStream asDoubleStream()

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

Это промежуточная операция.

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

упакованный

Stream<Long> boxed()

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

Это промежуточная операция.

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

билдер

static LongStream.Builder builder()

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

Возвращает:
билдер потока

пустой

static LongStream empty()

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

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

из

static LongStream of(long t)

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

Параметры:
t - единственный элемент
Возвращает:
последовательный поток с одним элементом

из

static LongStream of(long... values)

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

Параметры:
values - элементы нового потока
Возвращает:
новый поток

iterate

static LongStream iterate(long seed,
                          LongUnaryOperator f)

Возвращает бесконечный упорядоченный LongStream, полученный путём итеративного применения функции f к начальному элементу seed, создавая Stream, состоящий из seed, f(seed), f(f(seed)) и так далее.

Первый элемент (позиция 0) в LongStream будет заданным seed. Для n > 0, элемент на позиции n, будет результатом применения функции f к элементу на позиции n - 1.

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

Параметры:
seed - начальный элемент
f - функция, применяемая к предыдущему элементу для получения нового элемента
Возвращает:
новый последовательный LongStream

iterate

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

Возвращает последовательный упорядоченный LongStream, полученный путём итеративного применения заданной функции next к начальному элементу, при условии удовлетворения заданному предикату hasNext. Поток завершается, как только предикат hasNext возвращает false.

LongStream.iterate должен генерировать ту же последовательность элементов, что и соответствующий цикл for:

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

Результат может быть пустым, если предикат hasNext не выполняется для начального значения. В противном случае первым элементом будет предоставленное значение seed, следующим элементом (если он существует) будет результат применения функции next к значению seed, и так далее, итеративно, пока предикат hasNext не укажет, что поток должен завершиться.

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

Параметры:
seed - начальный элемент
hasNext - предикат для применения к элементам, чтобы определить, когда поток должен завершиться.
next - функция, применяемая к предыдущему элементу для получения нового элемента
Возвращает:
новый последовательный LongStream
С:
9

generate

static LongStream generate(LongSupplier s)

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

Параметры:
s - поставщик LongSupplier для сгенерированных элементов
Возвращает:
новый бесконечный последовательный неупорядоченный LongStream

range

static LongStream range(long startInclusive,
                        long endExclusive)

Возвращает последовательный упорядоченный LongStream от startInclusive (включительно) до endExclusive (исключительно) с увеличивающимся шагом 1.

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

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

for (long i = startInclusive; i < endExclusive ; i++) { ... }
Параметры:
startInclusive - начальное значение (включительно)
endExclusive - исключительная верхняя граница
Возвращает:
последовательный LongStream для диапазона long элементов

rangeClosed

static LongStream rangeClosed(long startInclusive,
                              long endInclusive)

Возвращает последовательный упорядоченный LongStream от startInclusive (включительно) до endInclusive (включительно) с увеличивающимся шагом 1.

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

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

for (long i = startInclusive; i <= endInclusive ; i++) { ... }
Параметры:
startInclusive - начальное значение (включительно)
endInclusive - верхняя граница (включительно)
Возвращает:
последовательный LongStream для диапазона long элементов

concat

static LongStream concat(LongStream a,
                         LongStream b)

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

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

Примечание API:
Для сохранения возможностей оптимизации этот метод связывает каждый поток с его источником и принимает только два потока в качестве параметров. Например, точный размер источника соединённого потока может быть вычислен, если точный размер источника каждого входного потока известен. Для соединения большего количества потоков без привязки или без вложенных вызовов этого метода, попробуйте создать поток из потоков и выполнить flat-маппинг с функцией тождества, например: 
LongStream concat = Stream.of(s1, s2, s3, s4).flatMapToLong(s -> s);
Примечание реализации:
Следует проявлять осторожность при построении потоков из многократного соединения. Доступ к элементу глубоко соединённого потока может привести к глубоким цепочкам вызовов или даже StackOverflowError.
Параметры:
a - первый поток
b - второй поток
Возвращает:
соединение двух входных потоков

© 1993, 2020, Oracle and/or its affiliates. All rights reserved.
Documentation extracted from Debian's OpenJDK Development Kit package.
Licensed under the GNU General Public License, version 2, with the Classpath Exception.
Various third party code in OpenJDK is licensed under different licenses (see Debian package).
Java and OpenJDK are trademarks or registered trademarks of Oracle and/or its affiliates.
https://docs.oracle.com/en/java/javase/11/docs/api/java.base/java/util/stream/LongStream.html

Spec-Zone .ru
спецификации, руководства, описания, API