# Spliterators.AbstractLongSpliterator Added in [API level 24](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels) AbstractLongSpliterator ======================= ``` abstract class AbstractLongSpliterator : Spliterator.OfLong ``` |---|-----------------------------------------------------| | [kotlin.Any](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-any/index.html) || | ↳ | [java.util.Spliterators.AbstractLongSpliterator](#) | An abstract `Spliterator.OfLong` that implements `trySplit` to permit limited parallelism. To implement a spliterator an extending class need only implement [tryAdvance](/reference/kotlin/java/util/Spliterator.OfLong#tryAdvance(java.util.function.LongConsumer)). The extending class should override [forEachRemaining](/reference/kotlin/java/util/Spliterator.OfLong#forEachRemaining(java.util.function.LongConsumer)) if it can provide a more performant implementation. Summary ------- | Protected constructors || |------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---| | [AbstractLongSpliterator](#AbstractLongSpliterator(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](#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](#estimateSize())`()` Returns an estimate of the number of elements that would be encountered by a [forEachRemaining](/reference/kotlin/java/util/Spliterator#forEachRemaining(java.util.function.Consumer)) traversal, or returns [java.lang.Long#MAX_VALUE](../lang/Long.html#MAX_VALUE:kotlin.Long) if infinite, unknown, or too expensive to compute. | | open [Spliterator.OfLong](/reference/kotlin/java/util/Spliterator.OfLong)! | [trySplit](#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 [OfLong](/reference/kotlin/java/util/Spliterator.OfLong) |------------------------------------------------------------------------------------|-----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | [Unit](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-unit/index.html) | [forEachRemaining](/reference/kotlin/java/util/Spliterator.OfLong#forEachRemaining(java.util.function.Consumer))`(`action:` `[Consumer](/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](/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](/reference/kotlin/java/util/Spliterator.OfLong#forEachRemaining(java.util.function.LongConsumer))`(`action:` `[LongConsumer](/reference/kotlin/java/util/function/LongConsumer)!`)`
| | [Boolean](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-boolean/index.html) | [tryAdvance](/reference/kotlin/java/util/Spliterator.OfLong#tryAdvance(java.util.function.Consumer))`(`action:` `[Consumer](/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](/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](/reference/kotlin/java/util/Spliterator.OfLong#tryAdvance(java.util.function.LongConsumer))`(`action:` `[LongConsumer](/reference/kotlin/java/util/function/LongConsumer)!`)`
| || Protected constructors ---------------------- ### AbstractLongSpliterator Added in [API level 24](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels) ``` protected AbstractLongSpliterator(     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](/reference/kotlin/java/util/Spliterator#ORDERED:kotlin.Int), [DISTINCT](/reference/kotlin/java/util/Spliterator#DISTINCT:kotlin.Int), [SORTED](/reference/kotlin/java/util/Spliterator#SORTED:kotlin.Int), [SIZED](/reference/kotlin/java/util/Spliterator#SIZED:kotlin.Int), [NONNULL](/reference/kotlin/java/util/Spliterator#NONNULL:kotlin.Int), [IMMUTABLE](/reference/kotlin/java/util/Spliterator#IMMUTABLE:kotlin.Int), [CONCURRENT](/reference/kotlin/java/util/Spliterator#CONCURRENT:kotlin.Int), [SUBSIZED](/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](/reference/kotlin/java/util/Spliterator#forEachRemaining(java.util.function.Consumer)) traversal, or returns [java.lang.Long#MAX_VALUE](../lang/Long.html#MAX_VALUE:kotlin.Long) if infinite, unknown, or too expensive to compute. If this Spliterator is [SIZED](/reference/kotlin/java/util/Spliterator#SIZED:kotlin.Int) and has not yet been partially traversed or split, or this Spliterator is [SUBSIZED](/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](/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.OfLong! ``` 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](/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.OfLong](/reference/kotlin/java/util/Spliterator.OfLong)! | a `Spliterator` covering some portion of the elements, or `null` if this spliterator cannot be split |