Интерфейс DoubleStream

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

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

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

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

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

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

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

Методы

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

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

Возвращает значение, указывающее, соответствует ли хотя бы один элемент этого потока предоставленному предикату.
OptionalDouble average()

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

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

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

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

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

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

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

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

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

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

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

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

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

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

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

Возвращает бесконечный последовательный неупорядоченный поток, где каждый элемент генерируется предоставленной DoubleSupplier.
static DoubleStream iterate​(double seed, DoublePredicate hasNext, DoubleUnaryOperator next)

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

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

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

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

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

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

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

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

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

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

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

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

Возвращает поток, состоящий из элементов этого потока, дополнительно выполняющий предоставленное действие над каждым элементом по мере потребления элементов из результирующего потока.
double reduce​(double identity, DoubleBinaryOperator op)

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

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

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

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

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

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

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

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

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

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

Методы

filter

DoubleStream filter(DoublePredicate predicate)

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

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

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

map

DoubleStream map(DoubleUnaryOperator mapper)

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

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

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

mapToObj

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

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

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

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

mapToInt

IntStream mapToInt(DoubleToIntFunction mapper)

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

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

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

mapToLong

LongStream mapToLong(DoubleToLongFunction mapper)

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

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

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

flatMap

DoubleStream flatMap(DoubleFunction<? extends DoubleStream> mapper)

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

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

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

distinct

DoubleStream distinct()

Возвращает поток, состоящий из уникальных элементов этого потока. Элементы сравниваются на равенство в соответствии с Double.compare(double, double).

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

Возвращает:
результирующий поток

sorted

DoubleStream sorted()

Возвращает поток, содержащий элементы этого потока в отсортированном порядке. Элементы сравниваются на равенство в соответствии с Double.compare(double, double).

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

Возвращает:
результирующий поток

peek

DoubleStream peek(DoubleConsumer action)

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

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

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

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

DoubleStream limit(long maxSize)

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

Это промежуточная состояниевая операция короткого замыкания.

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

skip

DoubleStream skip(long n)

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

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

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

takeWhile

default DoubleStream takeWhile(DoublePredicate predicate)

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

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

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

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

Это состояниевая промежуточная операция короткого замыкания.

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

dropWhile

default DoubleStream dropWhile(DoublePredicate predicate)

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

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

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

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

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

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

forEach

void forEach(DoubleConsumer action)

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

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

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

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

forEachOrdered

void forEachOrdered(DoubleConsumer action)

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

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

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

toArray

double[] toArray()

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

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

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

reduce

double reduce(double identity,
              DoubleBinaryOperator op)

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

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

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

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

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

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

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

reduce

OptionalDouble reduce(DoubleBinaryOperator op)

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

boolean foundAny = false;
     double result = null;
     for (double element : this stream) {
         if (!foundAny) {
             foundAny = true;
             result = element;
         }
         else
             result = accumulator.applyAsDouble(result, element);
     }
     return foundAny ? OptionalDouble.of(result) : OptionalDouble.empty();
, но не ограничено последовательным выполнением.

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

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

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

collect

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

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

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

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

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

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

сумма

double sum()

Возвращает сумму элементов в этом потоке. Суммирование — это частный случай сокращения. Если бы суммирование с плавающей точкой было точным, этот метод был бы эквивалентен: 

return reduce(0, Double::sum);
Однако, поскольку суммирование с плавающей точкой не является точным, код выше не обязательно эквивалентен вычислению суммы этим методом.

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

Различные условия могут привести к вычислению бесконечной суммы. Это может произойти даже если все суммируемые элементы конечны. Если какой-либо элемент является бесконечным, сумма будет бесконечной:

  • Если какой-либо элемент — NaN, то окончательная сумма будет NaN.
  • Если элементы содержат одну или несколько бесконечностей, сумма будет бесконечной или NaN.
    • Если элементы содержат бесконечности разных знаков, сумма будет NaN.
    • Если элементы содержат бесконечности одного знака, а промежуточная сумма переполняется в бесконечность противоположного знака, сумма может быть NaN.
Возможны случаи, когда промежуточные суммы конечных значений переполняются в бесконечности противоположных знаков; если это произойдёт, окончательная сумма будет NaN, даже если все элементы конечны. Если все элементы равны нулю, знак нуля не гарантируется, что сохранится в окончательной сумме.

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

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

min

OptionalDouble min()

Возвращает OptionalDouble, описывающую минимальный элемент этого потока, или пустой OptionalDouble, если этот поток пуст. Минимальный элемент будет Double.NaN , если какой-либо элемент потока был NaN. В отличие от числовых операторов сравнения, этот метод считает отрицательный ноль строго меньше положительного нуля. Это частный случай сокращения и эквивалентен: 

return reduce(Double::min);

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

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

max

OptionalDouble max()

Возвращает OptionalDouble , описывающую максимальный элемент этого потока, или пустой OptionalDouble, если этот поток пуст. Максимальный элемент будет Double.NaN , если какой-либо элемент потока был NaN. В отличие от числовых операторов сравнения, этот метод считает отрицательный ноль строго меньше положительного нуля. Это частный случай сокращения и эквивалентен: 

return reduce(Double::max);

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

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

количество

long count()

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

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

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

Примечание API:
Реализация может выбрать не выполнять обработку потока (ни последовательно, ни параллельно), если она способна вычислить количество напрямую из источника потока. В таких случаях элементы источника не будут просматриваться, а промежуточные операции не будут вычисляться. Параметры поведения с побочными эффектами, которые настоятельно не рекомендуются, за исключением безобидных случаев, таких как отладка, могут быть затронуты. Например, рассмотрим следующий поток: 
DoubleStream s = DoubleStream.of(1, 2, 3, 4);
     long count = s.peek(System.out::println).count();
Количество элементов, охватываемых источником потока, известно, и промежуточная операция peek не вставляет и не удаляет элементы из потока (в отличие от flatMap или filter операций). Таким образом, количество равно 4, и нет необходимости выполнять обработку потока и, как побочный эффект, выводить элементы.
Возвращает:
количество элементов в этом потоке

среднее

OptionalDouble average()

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

Вычисляемое среднее может изменяться численно и иметь особенности поведения, как при вычислении суммы; см. sum() для подробностей.

Среднее — это частный случай сокращения.

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

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

статистики

DoubleSummaryStatistics summaryStatistics()

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

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

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

любой_соответствует

boolean anyMatch(DoublePredicate predicate)

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

Это конечная операция короткого замыкания.

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

все_соответствуют

boolean allMatch(DoublePredicate predicate)

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

Это конечная операция короткого замыкания.

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

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

boolean noneMatch(DoublePredicate predicate)

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

Это конечная операция короткого замыкания.

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

найти_первый

OptionalDouble findFirst()

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

Это конечная операция короткого замыкания.

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

найти_любой

OptionalDouble findAny()

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

Это короткозамкнутая терминальная операция.

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

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

boxed

Stream<Double> boxed()

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

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

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

builder

static DoubleStream.Builder builder()

Возвращает конструктор DoubleStream.

Возвращает:
строитель потока

empty

static DoubleStream empty()

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

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

of

static DoubleStream of(double t)

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

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

of

static DoubleStream of(double... values)

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

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

iterate

static DoubleStream iterate(double seed,
                            DoubleUnaryOperator f)

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

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

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

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

iterate

static DoubleStream iterate(double seed,
                            DoublePredicate hasNext,
                            DoubleUnaryOperator next)

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

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

for (double index=seed; hasNext.test(index); index = next.applyAsDouble(index)) {
         ...
     }

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

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

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

generate

static DoubleStream generate(DoubleSupplier s)

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

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

concat

static DoubleStream concat(DoubleStream a,
                           DoubleStream b)

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

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

Примечание API:
Для сохранения возможностей оптимизации этот метод связывает каждый поток с его источником и принимает только два потока в качестве параметров. Например, точный размер источника конкатенированного потока можно вычислить, если известен точный размер источника каждого входного потока. Чтобы конкатенировать больше потоков без привязки или без вложенных вызовов этого метода, попробуйте создать поток потоков и выполнить flat-mapping с функцией identity, например: 
DoubleStream concat = Stream.of(s1, s2, s3, s4).flatMapToDouble(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/DoubleStream.html

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