# Spliterators.AbstractSpliterator

Added in[API level 24](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels)

# AbstractSpliterator

```
abstract class AbstractSpliterator<T : Any!> : Spliterator<T>
```

|---|------------------------------------------------------------------------------------------------------------------------------------------|
| [kotlin.Any](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-any/index.html)                                                           ||
| ↳ | [java.util.Spliterators.AbstractSpliterator](https://developer.android.com/reference/kotlin/java/util/Spliterators.AbstractSpliterator#) |

An abstract`Spliterator`that implements`trySplit`to permit limited parallelism.

An extending class need only implement[tryAdvance](https://developer.android.com/reference/kotlin/java/util/Spliterator#tryAdvance(java.util.function.Consumer)). The extending class should override[forEachRemaining](https://developer.android.com/reference/kotlin/java/util/Spliterator#forEachRemaining(java.util.function.Consumer))if it can provide a more performant implementation.

## Summary

| Inherited constants ||
|---|---|
| From class[Spliterator](https://developer.android.com/reference/kotlin/java/util/Spliterator) |----------------------------------------------------------------------------|----------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | [Int](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/index.html) | [CONCURRENT](https://developer.android.com/reference/kotlin/java/util/Spliterator#CONCURRENT:kotlin.Int) <br /> Characteristic value signifying that the element source may be safely concurrently modified (allowing additions, replacements, and/or removals) by multiple threads without external synchronization. If so, the Spliterator is expected to have a documented policy concerning the impact of modifications during traversal. A top-level Spliterator should not report both`CONCURRENT`and`SIZED`, since the finite size, if known, may change if the source is concurrently modified during traversal. Such a Spliterator is inconsistent and no guarantees can be made about any computation using that Spliterator. Sub-spliterators may report`SIZED`if the sub-split size is known and additions or removals to the source are not reflected when traversing. A top-level Spliterator should not report both`CONCURRENT`and`IMMUTABLE`, since they are mutually exclusive. Such a Spliterator is inconsistent and no guarantees can be made about any computation using that Spliterator. Sub-spliterators may report`IMMUTABLE`if additions or removals to the source are not reflected when traversing. <br /> | | [Int](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/index.html) | [DISTINCT](https://developer.android.com/reference/kotlin/java/util/Spliterator#DISTINCT:kotlin.Int) <br /> Characteristic value signifying that, for each pair of encountered elements`x, y`,`!x.equals(y)`. This applies for example, to a Spliterator based on a[Set](https://developer.android.com/reference/kotlin/java/util/Set). <br />                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                         | | [Int](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/index.html) | [IMMUTABLE](https://developer.android.com/reference/kotlin/java/util/Spliterator#IMMUTABLE:kotlin.Int) <br /> 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. A Spliterator that does not report`IMMUTABLE`or`CONCURRENT`is expected to have a documented policy (for example throwing[ConcurrentModificationException](https://developer.android.com/reference/kotlin/java/util/ConcurrentModificationException)) concerning structural interference detected during traversal. <br />                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | | [Int](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/index.html) | [NONNULL](https://developer.android.com/reference/kotlin/java/util/Spliterator#NONNULL:kotlin.Int) <br /> Characteristic value signifying that the source guarantees that encountered elements will not be`null`. (This applies, for example, to most concurrent collections, queues, and maps.) <br />                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                | | [Int](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/index.html) | [ORDERED](https://developer.android.com/reference/kotlin/java/util/Spliterator#ORDERED:kotlin.Int) <br /> Characteristic value signifying that an encounter order is defined for elements. If so, this Spliterator guarantees that method[trySplit](https://developer.android.com/reference/kotlin/java/util/Spliterator#trySplit())splits a strict prefix of elements, that method[tryAdvance](https://developer.android.com/reference/kotlin/java/util/Spliterator#tryAdvance(java.util.function.Consumer))steps by one element in prefix order, and that[forEachRemaining](https://developer.android.com/reference/kotlin/java/util/Spliterator#forEachRemaining(java.util.function.Consumer))performs actions in encounter order. A[Collection](https://developer.android.com/reference/kotlin/java/util/Collection)has an encounter order if the corresponding[Collection.iterator](https://developer.android.com/reference/kotlin/java/util/Collection#iterator())documents an order. If so, the encounter order is the same as the documented order. Otherwise, a collection does not have an encounter order. <br />                                                                                                           | | [Int](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/index.html) | [SIZED](https://developer.android.com/reference/kotlin/java/util/Spliterator#SIZED:kotlin.Int) <br /> 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. <br />                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                       | | [Int](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/index.html) | [SORTED](https://developer.android.com/reference/kotlin/java/util/Spliterator#SORTED:kotlin.Int) <br /> Characteristic value signifying that encounter order follows a defined sort order. If so, method[getComparator()](https://developer.android.com/reference/kotlin/java/util/Spliterator#getComparator())returns the associated Comparator, or`null`if all elements are[Comparable](https://developer.android.com/reference/kotlin/java/lang/Comparable.html#)and are sorted by their natural ordering. A Spliterator that reports`SORTED`must also report`ORDERED`. <br />                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                      | | [Int](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/index.html) | [SUBSIZED](https://developer.android.com/reference/kotlin/java/util/Spliterator#SUBSIZED:kotlin.Int) <br /> Characteristic value signifying that all Spliterators resulting from`trySplit()`will be both[SIZED](https://developer.android.com/reference/kotlin/java/util/Spliterator#SIZED:kotlin.Int)and[SUBSIZED](https://developer.android.com/reference/kotlin/java/util/Spliterator#SUBSIZED:kotlin.Int). (This means that all child Spliterators, whether direct or indirect, will be`SIZED`.) A Spliterator that does not report`SIZED`as required by`SUBSIZED`is inconsistent and no guarantees can be made about any computation using that Spliterator. <br />                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                                               | ||

|                                                                                                                                                                                                                     Protected constructors                                                                                                                                                                                                                     ||
|-------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------|---|
| [AbstractSpliterator](https://developer.android.com/reference/kotlin/java/util/Spliterators.AbstractSpliterator#AbstractSpliterator(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 additionalCharacteristics. |

|                                                                                                                                                                                                                                                                                                              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.AbstractSpliterator#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.AbstractSpliterator#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](https://developer.android.com/reference/kotlin/java/util/Spliterator)\<T\>! | [trySplit](https://developer.android.com/reference/kotlin/java/util/Spliterators.AbstractSpliterator#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[Spliterator](https://developer.android.com/reference/kotlin/java/util/Spliterator) |--------------------------------------------------------------------------------------------|---------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------------| | [Unit](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-unit/index.html)               | [forEachRemaining](https://developer.android.com/reference/kotlin/java/util/Spliterator#forEachRemaining(java.util.function.Consumer))`(`action:` `[Consumer](https://developer.android.com/reference/kotlin/java/util/function/Consumer)<in` `T>!`)` <br /> 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. <br /> | | [Comparator](https://developer.android.com/reference/kotlin/java/util/Comparator)<in` `T>! | [getComparator](https://developer.android.com/reference/kotlin/java/util/Spliterator#getComparator())`()` <br /> If this Spliterator's source is[SORTED](https://developer.android.com/reference/kotlin/java/util/Spliterator#SORTED:kotlin.Int)by a[Comparator](https://developer.android.com/reference/kotlin/java/util/Comparator), returns that`Comparator`. If the source is`SORTED`in[natural order](https://developer.android.com/reference/kotlin/java/lang/Comparable.html#), returns`null`. Otherwise, if the source is not`SORTED`, throws[IllegalStateException](https://developer.android.com/reference/kotlin/java/lang/IllegalStateException.html#). <br />                                                                                    | | [Long](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-long/index.html)               | [getExactSizeIfKnown](https://developer.android.com/reference/kotlin/java/util/Spliterator#getExactSizeIfKnown())`()` <br /> Convenience method that returns[estimateSize()](https://developer.android.com/reference/kotlin/java/util/Spliterator#estimateSize())if this Spliterator is[SIZED](https://developer.android.com/reference/kotlin/java/util/Spliterator#SIZED:kotlin.Int), else`-1`. <br />                                                                                                                                                                                                                                                                                                                                                       | | [Boolean](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-boolean/index.html)         | [hasCharacteristics](https://developer.android.com/reference/kotlin/java/util/Spliterator#hasCharacteristics(kotlin.Int))`(`characteristics:` `[Int](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-int/index.html)`)` <br /> Returns`true`if this Spliterator's[characteristics](https://developer.android.com/reference/kotlin/java/util/Spliterator#characteristics())contain all of the given characteristics. <br />                                                                                                                                                                                                                                                                                                                               | | [Boolean](https://kotlinlang.org/api/latest/jvm/stdlib/kotlin/-boolean/index.html)         | [tryAdvance](https://developer.android.com/reference/kotlin/java/util/Spliterator#tryAdvance(java.util.function.Consumer))`(`action:` `[Consumer](https://developer.android.com/reference/kotlin/java/util/function/Consumer)<in` `T>!`)` <br /> 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. <br />                                                       | ||

## Protected constructors

### AbstractSpliterator

Added in[API level 24](https://developer.android.com/guide/topics/manifest/uses-sdk-element.html#ApiLevels)  

```
protected AbstractSpliterator(
    est: Long, 
    additionalCharacteristics: Int)
```

Creates a spliterator reporting the given estimated size and additionalCharacteristics.

|                                                                                                                 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<T>!
```

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](https://developer.android.com/reference/kotlin/java/util/Spliterator)<T>! | a`Spliterator`covering some portion of the elements, or`null`if this spliterator cannot be split |