# Spliterators.AbstractDoubleSpliterator Added in[API level 24](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels) # AbstractDoubleSpliterator ``` abstract class AbstractDoubleSpliterator : Spliterator.OfDouble ``` |---|------------------------------------------------------------------------------------------------------------------------------------------------------| | [kotlin.Any](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-any/index.html) || | ↳ | [java.util.Spliterators.AbstractDoubleSpliterator](https://developer.android.com/reference/kotlin/java/util/Spliterators.AbstractDoubleSpliterator#) | An abstract`Spliterator.OfDouble`that implements`trySplit`to permit limited parallelism. To implement a spliterator an extending class need only implement[tryAdvance](https://developer.android.com/reference/kotlin/java/util/Spliterator.OfDouble#tryAdvance(java.util.function.DoubleConsumer)). The extending class should override[forEachRemaining](https://developer.android.com/reference/kotlin/java/util/Spliterator.OfDouble#forEachRemaining(java.util.function.DoubleConsumer))if it can provide a more performant implementation. ## Summary | Protected constructors || |---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---| | [AbstractDoubleSpliterator](https://developer.android.com/reference/kotlin/java/util/Spliterators.AbstractDoubleSpliterator#AbstractDoubleSpliterator(kotlin.Long,%20kotlin.Int))`(`est:` `[Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html)`, `additionalCharacteristics:` `[Int](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/index.html)`)` Creates a spliterator reporting the given estimated size and characteristics. | | Public methods || |------------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | open[Int](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/index.html) | [characteristics](https://developer.android.com/reference/kotlin/java/util/Spliterators.AbstractDoubleSpliterator#characteristics())`()` Returns a set of characteristics of this Spliterator and its elements. | | open[Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html) | [estimateSize](https://developer.android.com/reference/kotlin/java/util/Spliterators.AbstractDoubleSpliterator#estimateSize())`()` Returns an estimate of the number of elements that would be encountered by a[forEachRemaining](https://developer.android.com/reference/kotlin/java/util/Spliterator#forEachRemaining(java.util.function.Consumer))traversal, or returns[java.lang.Long#MAX_VALUE](https://developer.android.com/reference/kotlin/java/lang/Long.html#MAX_VALUE:kotlin.Long)if infinite, unknown, or too expensive to compute. | | open[Spliterator.OfDouble](https://developer.android.com/reference/kotlin/java/util/Spliterator.OfDouble)! | [trySplit](https://developer.android.com/reference/kotlin/java/util/Spliterators.AbstractDoubleSpliterator#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. | | Inherited functions || |---|---| | From class[OfDouble](https://developer.android.com/reference/kotlin/java/util/Spliterator.OfDouble) |------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | [Unit](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-unit/index.html) | [forEachRemaining](https://developer.android.com/reference/kotlin/java/util/Spliterator.OfDouble#forEachRemaining(java.util.function.Consumer))`(`action:` `[Consumer](https://developer.android.com/reference/kotlin/java/util/function/Consumer)!`)`
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[ORDERED](https://developer.android.com/reference/kotlin/java/util/Spliterator#ORDERED:kotlin.Int), 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.
| | [Unit](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-unit/index.html) | [forEachRemaining](https://developer.android.com/reference/kotlin/java/util/Spliterator.OfDouble#forEachRemaining(java.util.function.DoubleConsumer))`(`action:` `[DoubleConsumer](https://developer.android.com/reference/kotlin/java/util/function/DoubleConsumer)!`)`
| | [Boolean](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-boolean/index.html) | [tryAdvance](https://developer.android.com/reference/kotlin/java/util/Spliterator.OfDouble#tryAdvance(java.util.function.Consumer))`(`action:` `[Consumer](https://developer.android.com/reference/kotlin/java/util/function/Consumer)!`)`
If a remaining element exists: performs the given action on it, returning`true`; else returns`false`. If this Spliterator is[ORDERED](https://developer.android.com/reference/kotlin/java/util/Spliterator#ORDERED:kotlin.Int)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.
| | [Boolean](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-boolean/index.html) | [tryAdvance](https://developer.android.com/reference/kotlin/java/util/Spliterator.OfDouble#tryAdvance(java.util.function.DoubleConsumer))`(`action:` `[DoubleConsumer](https://developer.android.com/reference/kotlin/java/util/function/DoubleConsumer)!`)`
| || ## Protected constructors ### AbstractDoubleSpliterator Added in[API level 24](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels) ``` protected AbstractDoubleSpliterator(     est: Long,     additionalCharacteristics: Int) ``` Creates a spliterator reporting the given estimated size and characteristics. | Parameters || |-----------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | `est` | [Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html):the estimated size of this spliterator if known, otherwise`Long.MAX_VALUE`. | | `additionalCharacteristics` | [Int](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/index.html):properties of this spliterator's source or elements. If`SIZED`is reported then this spliterator will additionally report`SUBSIZED`. | ## Public methods ### characteristics Added in[API level 24](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels) ``` open fun characteristics(): Int ``` Returns a set of characteristics of this Spliterator and its elements. The result is represented as ORed values from[ORDERED](https://developer.android.com/reference/kotlin/java/util/Spliterator#ORDERED:kotlin.Int),[DISTINCT](https://developer.android.com/reference/kotlin/java/util/Spliterator#DISTINCT:kotlin.Int),[SORTED](https://developer.android.com/reference/kotlin/java/util/Spliterator#SORTED:kotlin.Int),[SIZED](https://developer.android.com/reference/kotlin/java/util/Spliterator#SIZED:kotlin.Int),[NONNULL](https://developer.android.com/reference/kotlin/java/util/Spliterator#NONNULL:kotlin.Int),[IMMUTABLE](https://developer.android.com/reference/kotlin/java/util/Spliterator#IMMUTABLE:kotlin.Int),[CONCURRENT](https://developer.android.com/reference/kotlin/java/util/Spliterator#CONCURRENT:kotlin.Int),[SUBSIZED](https://developer.android.com/reference/kotlin/java/util/Spliterator#SUBSIZED:kotlin.Int). Repeated calls to`characteristics()`on a given spliterator, prior to or in-between calls to`trySplit`, should always return the same result. If a Spliterator reports an inconsistent set of characteristics (either those returned from a single invocation or across multiple invocations), no guarantees can be made about any computation using this Spliterator. | Return || |----------------------------------------------------------------------------|-------------------------------------| | [Int](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/index.html) | a representation of characteristics | ### estimateSize Added in[API level 24](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels) ``` open fun estimateSize(): Long ``` Returns an estimate of the number of elements that would be encountered by a[forEachRemaining](https://developer.android.com/reference/kotlin/java/util/Spliterator#forEachRemaining(java.util.function.Consumer))traversal, or returns[java.lang.Long#MAX_VALUE](https://developer.android.com/reference/kotlin/java/lang/Long.html#MAX_VALUE:kotlin.Long)if infinite, unknown, or too expensive to compute. If this Spliterator is[SIZED](https://developer.android.com/reference/kotlin/java/util/Spliterator#SIZED:kotlin.Int)and has not yet been partially traversed or split, or this Spliterator is[SUBSIZED](https://developer.android.com/reference/kotlin/java/util/Spliterator#SUBSIZED:kotlin.Int)and has not yet been partially traversed, this estimate must be an accurate count of elements that would be encountered by a complete traversal. Otherwise, this estimate may be arbitrarily inaccurate, but must decrease as specified across invocations of[trySplit](https://developer.android.com/reference/kotlin/java/util/Spliterator#trySplit()). | Return || |------------------------------------------------------------------------------|------------------------------------------------------------------------------------------| | [Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html) | the estimated size, or`Long.MAX_VALUE`if infinite, unknown, or too expensive to compute. | ### trySplit Added in[API level 24](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels) ``` open fun trySplit(): Spliterator.OfDouble! ``` If this spliterator can be partitioned, returns a Spliterator covering elements, that will, upon return from this method, not be covered by this Spliterator. If this Spliterator is[ORDERED](https://developer.android.com/reference/kotlin/java/util/Spliterator#ORDERED:kotlin.Int), the returned Spliterator must cover a strict prefix of the elements. Unless this Spliterator covers an infinite number of elements, repeated calls to`trySplit()`must eventually return`null`. Upon non-null return: - the value reported for`estimateSize()`before splitting, must, after splitting, be greater than or equal to`estimateSize()`for this and the returned Spliterator; and - if this Spliterator is`SUBSIZED`, then`estimateSize()`for this spliterator before splitting must be equal to the sum of`estimateSize()`for this and the returned Spliterator after splitting. This method may return`null`for any reason, including emptiness, inability to split after traversal has commenced, data structure constraints, and efficiency considerations. This implementation permits limited parallelism. | Return || |--------------------------------------------------------------------------------------------------------|--------------------------------------------------------------------------------------------------| | [Spliterator.OfDouble](https://developer.android.com/reference/kotlin/java/util/Spliterator.OfDouble)! | a`Spliterator`covering some portion of the elements, or`null`if this spliterator cannot be split |