Spliterator.OfDouble (Java SE 26 & JDK 26)
Description: declaration: module: java.base, package: java.util, interface: Spliterator, interface: OfDouble
Keywords: java.util.Spliterator.OfDouble interface

# Interface Spliterator.OfDouble

All Superinterfaces:
  `Spliterator<Double>, Spliterator.OfPrimitive<Double, DoubleConsumer, Spliterator.OfDouble>`

All Known Implementing Classes:
  `Spliterators.AbstractDoubleSpliterator`

Enclosing interface:
  `Spliterator<T>`

public static interface Spliterator.OfDouble extends Spliterator.OfPrimitive<Double, DoubleConsumer, Spliterator.OfDouble>
A Spliterator specialized for `double` values.

Since:
  1.8

- ## Nested Class Summary

  ### Nested classes/interfaces declared in interface Spliterator

  `Spliterator.OfDouble, Spliterator.OfInt, Spliterator.OfLong, Spliterator.OfPrimitive<T,T_CONS,T_SPLITR>`
  Modifier and Type
  Interface
  Description
  `static interface`
  `Spliterator.OfDouble`
  A Spliterator specialized for `double` values.
  `static interface`
  `Spliterator.OfInt`
  A Spliterator specialized for `int` values.
  `static interface`
  `Spliterator.OfLong`
  A Spliterator specialized for `long` values.
  `static interface`
  `Spliterator.OfPrimitive<T, T_CONS, T_SPLITR extends Spliterator.OfPrimitive<T,T_CONS,T_SPLITR>>`
  A Spliterator specialized for primitive values.

- ## Field Summary

  ### Fields declared in interface Spliterator

  `CONCURRENT, DISTINCT, IMMUTABLE, NONNULL, ORDERED, SIZED, SORTED, SUBSIZED`
  Modifier and Type
  Field
  Description
  `static final int`
  `CONCURRENT`
  Characteristic value signifying that the element source may be safely concurrently modified (allowing additions, replacements, and/or removals) by multiple threads without external synchronization.
  `static final int`
  `DISTINCT`
  Characteristic value signifying that, for each pair of encountered elements `x, y`, `!x.equals(y)`.
  `static final int`
  `IMMUTABLE`
  Characteristic value signifying that the element source cannot be structurally modified; that is, elements cannot be added, replaced, or removed, so such changes cannot occur during traversal.
  `static final int`
  `NONNULL`
  Characteristic value signifying that the source guarantees that encountered elements will not be `null`.
  `static final int`
  `ORDERED`
  Characteristic value signifying that an encounter order is defined for elements.
  `static final int`
  `SIZED`
  Characteristic value signifying that the value returned from `estimateSize()` prior to traversal or splitting represents a finite size that, in the absence of structural source modification, represents an exact count of the number of elements that would be encountered by a complete traversal.
  `static final int`
  `SORTED`
  Characteristic value signifying that encounter order follows a defined sort order.
  `static final int`
  `SUBSIZED`
  Characteristic value signifying that all Spliterators resulting from `trySplit()` will be both `Spliterator.SIZED` and `Spliterator.SUBSIZED`.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `default void`
  `forEachRemaining(Consumer<? super Double> action)`
  Performs the given action for each remaining element, sequentially in the current thread, until all elements have been processed or the action throws an exception.
  `default boolean`
  `tryAdvance(Consumer<? super Double> action)`
  If a remaining element exists: performs the given action on it, returning `true`; else returns `false`.

  ### Methods declared in interface Spliterator

  `characteristics, estimateSize, getComparator, getExactSizeIfKnown, hasCharacteristics, trySplit`
  Modifier and Type
  Method
  Description
  `int`
  `characteristics()`
  Returns a set of characteristics of this Spliterator and its elements.
  `long`
  `estimateSize()`
  Returns an estimate of the number of elements that would be encountered by a `Spliterator.forEachRemaining(Consumer)` traversal, or returns `Long.MAX_VALUE` if infinite, unknown, or too expensive to compute.
  `default Comparator<? super Double>`
  `getComparator()`
  If this Spliterator's source is `Spliterator.SORTED` by a `Comparator`, returns that `Comparator`.
  `default long`
  `getExactSizeIfKnown()`
  Convenience method that returns `Spliterator.estimateSize()` if this Spliterator is `Spliterator.SIZED`, else `-1`.
  `default boolean`
  `hasCharacteristics(int characteristics)`
  Returns `true` if this Spliterator's `Spliterator.characteristics()` contain all of the given characteristics.
  `Spliterator<Double>`
  `trySplit()`
  If this spliterator can be partitioned, returns a Spliterator covering elements, that will, upon return from this method, not be covered by this Spliterator.

  ### Methods declared in interface Spliterator.OfPrimitive

  `forEachRemaining, tryAdvance`
  Modifier and Type
  Method
  Description
  `default void`
  `forEachRemaining(DoubleConsumer action)`
  Performs the given action for each remaining element, sequentially in the current thread, until all elements have been processed or the action throws an exception.
  `boolean`
  `tryAdvance(DoubleConsumer action)`
  If a remaining element exists, performs the given action on it, returning `true`; else returns `false`.

- ## Method Details

  - ### tryAdvance

    default boolean tryAdvance(Consumer<? super Double> action)
    If a remaining element exists: performs the given action on it, returning `true`; else returns `false`. If this Spliterator is `Spliterator.ORDERED` the action is performed on the next element in encounter order. Exceptions thrown by the action are relayed to the caller.

    Subsequent behavior of a spliterator is unspecified if the action throws an exception.

    Specified by:
      `tryAdvance` in interface `Spliterator<Double>`
    Implementation Requirements:
      If the action is an instance of `DoubleConsumer` then it is cast to `DoubleConsumer` and passed to `Spliterator.OfPrimitive.tryAdvance(java.util.function.DoubleConsumer)`; otherwise the action is adapted to an instance of `DoubleConsumer`, by boxing the argument of `DoubleConsumer`, and then passed to `Spliterator.OfPrimitive.tryAdvance(java.util.function.DoubleConsumer)`.
    Parameters:
      `action` - The action whose operation is performed at-most once
    Returns:
      `false` if no remaining elements existed upon entry to this method, else `true`.

  - ### forEachRemaining

    default void forEachRemaining(Consumer<? super Double> action)
    Performs the given action for each remaining element, sequentially in the current thread, until all elements have been processed or the action throws an exception. If this Spliterator is `Spliterator.ORDERED`, actions are performed in encounter order. Exceptions thrown by the action are relayed to the caller.

    Subsequent behavior of a spliterator is unspecified if the action throws an exception.

    Specified by:
      `forEachRemaining` in interface `Spliterator<Double>`
    Implementation Requirements:
      If the action is an instance of `DoubleConsumer` then it is cast to `DoubleConsumer` and passed to `Spliterator.OfPrimitive.forEachRemaining(java.util.function.DoubleConsumer)`; otherwise the action is adapted to an instance of `DoubleConsumer`, by boxing the argument of `DoubleConsumer`, and then passed to `Spliterator.OfPrimitive.forEachRemaining(java.util.function.DoubleConsumer)`.
    Parameters:
      `action` - The action