# Print output for @column tags ?>
Developers

- Design
- Develop
- Distribute

Developer Console

## Most visited

## Recently visited

## Results for

Summary: Inherited Constants | Protected Ctors | Methods | Inherited Methods

# Spliterators.AbstractSpliterator

`public static abstract class Spliterators.AbstractSpliterator`
`extends Object` `implements Spliterator<T>`

java.lang.Object
↳ | java.util.Spliterators.AbstractSpliterator<T>

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

An extending class need only implement `tryAdvance`. The extending class should override `forEach` if it can provide a more performant implementation.

See also:

- `Spliterators.spliterator(Iterator, long, int)`

## Summary

### Inherited constants
From interface `java.util.Spliterator`
`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.
`int` | `DISTINCT` Characteristic value signifying that, for each pair of encountered elements `x, y`, `!x.equals(y)`.
`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.
`int` | `NONNULL` Characteristic value signifying that the source guarantees that encountered elements will not be `null`.
`int` | `ORDERED` Characteristic value signifying that an encounter order is defined for elements.
`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.
`int` | `SORTED` Characteristic value signifying that encounter order follows a defined sort order.
`int` | `SUBSIZED` Characteristic value signifying that all Spliterators resulting from `trySplit()` will be both `SIZED` and `SUBSIZED`.

### Protected constructors
`AbstractSpliterator(long est, int additionalCharacteristics)` Creates a spliterator reporting the given estimated size and additionalCharacteristics.

### Public methods
`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 `forEachRemaining(Consumer)` traversal, or returns `Long.MAX_VALUE` if infinite, unknown, or too expensive to compute.
`Spliterator<T>` | `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. This implementation permits limited parallelism.

### Inherited methods
From class `java.lang.Object`
`Object` | `clone()` Creates and returns a copy of this object.
`boolean` | `equals(Object obj)` Indicates whether some other object is "equal to" this one.
`void` | `finalize()` Called by the garbage collector on an object when garbage collection determines that there are no more references to the object.
`final Class<?>` | `getClass()` Returns the runtime class of this `Object`.
`int` | `hashCode()` Returns a hash code value for the object.
`final void` | `notify()` Wakes up a single thread that is waiting on this object's monitor.
`final void` | `notifyAll()` Wakes up all threads that are waiting on this object's monitor.
`String` | `toString()` Returns a string representation of the object.
`final void` | `wait(long timeout, int nanos)` Causes the current thread to wait until another thread invokes the `notify()` method or the `notifyAll()` method for this object, or some other thread interrupts the current thread, or a certain amount of real time has elapsed.
`final void` | `wait(long timeout)` Causes the current thread to wait until either another thread invokes the `notify()` method or the `notifyAll()` method for this object, or a specified amount of time has elapsed.
`final void` | `wait()` Causes the current thread to wait until another thread invokes the `notify()` method or the `notifyAll()` method for this object.
From interface `java.util.Spliterator`
`abstract int` | `characteristics()` Returns a set of characteristics of this Spliterator and its elements.
`abstract long` | `estimateSize()` Returns an estimate of the number of elements that would be encountered by a `forEachRemaining(Consumer)` traversal, or returns `Long.MAX_VALUE` if infinite, unknown, or too expensive to compute.
`default void` | `forEachRemaining(Consumer<? super T> 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 Comparator<? super T>` | `getComparator()` If this Spliterator's source is `SORTED` by a `Comparator`, returns that `Comparator`.
`default long` | `getExactSizeIfKnown()` Convenience method that returns `estimateSize()` if this Spliterator is `SIZED`, else `-1`.
`default boolean` | `hasCharacteristics(int characteristics)` Returns `true` if this Spliterator's `characteristics()` contain all of the given characteristics.
`abstract boolean` | `tryAdvance(Consumer<? super T> action)` If a remaining element exists, performs the given action on it, returning `true`; else returns `false`.
`abstract Spliterator<T>` | `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.

## Protected constructors

### AbstractSpliterator

    protected AbstractSpliterator (long est,
                    int additionalCharacteristics)

Creates a spliterator reporting the given estimated size and additionalCharacteristics.

Parameters
`est` | `long`: the estimated size of this spliterator if known, otherwise `Long.MAX_VALUE`.
`additionalCharacteristics` | `int`: properties of this spliterator's source or elements. If `SIZED` is reported then this spliterator will additionally report `SUBSIZED`.

## Public methods

### characteristics

    public int characteristics ()

Returns a set of characteristics of this Spliterator and its elements. The result is represented as ORed values from `ORDERED`, `DISTINCT`, `SORTED`, `SIZED`, `NONNULL`, `IMMUTABLE`, `CONCURRENT`, `SUBSIZED`. 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.

##### Implementation Requirements:

- This implementation returns the characteristics as reported when created.

Returns
`int` | a representation of characteristics

### estimateSize

    public long estimateSize ()

Returns an estimate of the number of elements that would be encountered by a `forEachRemaining(Consumer)` traversal, or returns `Long.MAX_VALUE` if infinite, unknown, or too expensive to compute.

If this Spliterator is `SIZED` and has not yet been partially traversed or split, or this Spliterator is `SUBSIZED` 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()`.

##### Implementation Requirements:

- This implementation returns the estimated size as reported when created and, if the estimate size is known, decreases in size when split.

Returns
`long` | the estimated size, or `Long.MAX_VALUE` if infinite, unknown, or too expensive to compute.

### trySplit

    public Spliterator<T> 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.

If this Spliterator is `ORDERED`, 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.

Returns
`Spliterator<T>` | a `Spliterator` covering some portion of the elements, or `null` if this spliterator cannot be split

Full name *
Email address *
Company / developer name
One of your Play Store app URLs *
Which best describes your business:*
Apps
Games
Apps & Games
*
*