Интерфейс DoubleStream

DoubleStream filter(DoublePredicate predicate)

Параметры:

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

Возвращает:

новый поток

DoubleStream map(DoubleUnaryOperator mapper)

Параметры:

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

Возвращает:

новый поток

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

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

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

Параметры:

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

Возвращает:

новый поток

IntStream mapToInt(DoubleToIntFunction mapper)

Параметры:

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

Возвращает:

новый поток

LongStream mapToLong(DoubleToLongFunction mapper)

Параметры:

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

Возвращает:

новый поток

DoubleStream flatMap(DoubleFunction<? extends DoubleStream> mapper)

Параметры:

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

Возвращает:

новый поток

См. также:

• Stream.flatMap(Function)

default DoubleStream mapMulti(DoubleStream.DoubleMapMultiConsumer mapper)

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

Стандартная реализация вызывает flatMap для этого потока, передавая функцию, которая работает следующим образом. Во-первых, она вызывает функцию-маппер с DoubleConsumer, которая накапливает элементы замены в вновь созданном внутреннем буфере. После того, как функция-маппер возвращается, она создаёт DoubleStream из внутреннего буфера. Наконец, она возвращает этот поток для flatMap.

Параметры:

mapper - не влияющая, бессостоятельная функция, генерирующая элементы замены

Возвращает:

новый поток

С:

16

См. также:

• Stream.mapMulti

DoubleStream distinct()

Возвращает:

результат потока

DoubleStream sorted()

Возвращает:

результат потока

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

Возвращает:

новый поток

DoubleStream limit(long maxSize)

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

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

Параметры:

maxSize - количество элементов, до которого должен быть ограничен поток

Возвращает:

новый поток

Исключения:

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

DoubleStream skip(long n)

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

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

Параметры:

n - количество ведущих элементов для пропуска

Возвращает:

новый поток

Исключения:

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

default DoubleStream takeWhile(DoublePredicate predicate)

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

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

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

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

Параметры:

predicate - невмешательство, бессостояние предикат для применения к элементам для определения самого длинного префикса элементов.

Возвращает:

новый поток

С:

9

default DoubleStream dropWhile(DoublePredicate predicate)

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

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

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

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

Параметры:

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

Возвращает:

новый поток

С:

9

void forEach(DoubleConsumer action)

Параметры:

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

void forEachOrdered(DoubleConsumer action)

Параметры:

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

См. также:

• forEach(DoubleConsumer)

double[] toArray()

Возвращает:

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

double reduce(double identity, DoubleBinaryOperator op)

     double result = identity;
     for (double element : this stream)
         result = accumulator.applyAsDouble(result, element)
     return result;
 

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

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

     double sum = numbers.reduce(0, (a, b) -> a+b);
 

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

     double sum = numbers.reduce(0, Double::sum);
 

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

Параметры:

identity - идентификационное значение для функции накопления

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

Возвращает:

результат редукции

См. также:

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

OptionalDouble reduce(DoubleBinaryOperator op)

     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();
 

Параметры:

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

Возвращает:

результат редукции

См. также:

• reduce(double, DoubleBinaryOperator)

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

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

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

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

Параметры:

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

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

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

Возвращает:

результат редукции

См. также:

• Stream.collect(Supplier, BiConsumer, BiConsumer)

double sum()

     return reduce(0, Double::sum);
 

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

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

Возвращает:

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

OptionalDouble min()

     return reduce(Double::min);
 

Возвращает:

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

OptionalDouble max()

     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()

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

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

Возвращает:

OptionalDouble, содержащий среднее значение элемента этого потока, или пустой необязательный объект, если поток пустой

DoubleSummaryStatistics summaryStatistics()

Возвращает:

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

boolean anyMatch(DoublePredicate predicate)

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

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

Параметры:

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

Возвращает:

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

boolean allMatch(DoublePredicate predicate)

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

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

Параметры:

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

Возвращает:

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

boolean noneMatch(DoublePredicate predicate)

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

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

Параметры:

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

Возвращает:

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

OptionalDouble findFirst()

Возвращает:

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

OptionalDouble findAny()

Возвращает:

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

См. также:

• findFirst()

Stream<Double> boxed()

Возвращает:

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

static DoubleStream.Builder builder()

Возвращает:

билдер потока

static DoubleStream empty()

Возвращает:

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

static DoubleStream of(double t)

Параметры:

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

Возвращает:

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

static DoubleStream of(double... values)

Параметры:

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

Возвращает:

новый поток

static DoubleStream iterate(double seed, DoubleUnaryOperator f)

Параметры:

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

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

Возвращает:

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

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

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

Parameters:

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

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

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

Returns:

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

Since:

9

static DoubleStream generate(DoubleSupplier s)

Parameters:

s - DoubleSupplier для генерируемых элементов

Returns:

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

static DoubleStream concat(DoubleStream a, DoubleStream b)

API Note:

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

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

Implementation Note:

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

Parameters:

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

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

Returns:

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