# Class ListOfUnknownSize<E>

Object
AbstractCollection<E>
AbstractList<E>
AbstractSequentialList<E>
ListOfUnknownSize<E>

Type Parameters:
  `E` - the type of elements in the list.

All Implemented Interfaces:
  `Iterable<E>, Collection<E>, List<E>, SequencedCollection<E>`

public abstract class ListOfUnknownSize<E> extends AbstractSequentialList<E>
An alternative to `AbstractList` for implementations having a costly `size()` method. The size of the set is not known in advance, but may become known after one complete iteration. This class overrides methods in a way that reduces or eliminates the need to invoke `size()`.

#### Note for implementers

Despite extending `AbstractSequentialList`, subclasses are not expected to overwrite the `listIterator(int)` method. Instead, subclasses should implement the following methods:

- `get(int)`
- `isValidIndex(int)`
- `sizeIfKnown()` — optional but recommended for efficiency
- `characteristics()` — if the implementation disallows null elements.

Since:
  1.6

- ## Field Summary

  ### Fields inherited from class AbstractList

  `modCount`

- ## Constructor Summary

  Constructors
  Modifier
  Constructor
  Description
  `protected`
  `ListOfUnknownSize()`
  Creates a new list of initially unknown size.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `protected int`
  `characteristics()`
  Returns characteristics of this collection as a combination of `Spliterator` bits.
  `abstract E`
  `get(int index)`
  Returns the element at the specified index.
  `boolean`
  `isEmpty()`
  Returns `true` if this list is empty.
  `protected abstract boolean`
  `isValidIndex(int index)`
  Returns `true` if the given index is valid for this list.
  `ListIterator<E>`
  `listIterator(int index)`
  Returns a list iterator over the elements in this list.
  `boolean`
  `removeAll(Collection<?> c)`
  Removes elements of the given collection from this list.
  `int`
  `size()`
  Returns the number of elements in this list.
  `protected OptionalInt`
  `sizeIfKnown()`
  Returns the `size()` value if it is already known, or empty if the size is still unknown.
  `Spliterator<E>`
  `spliterator()`
  Creates a `Spliterator` which may be of unknown size.
  `Object[]`
  `toArray()`
  Returns all elements in an array.
  `<T> T[]`
  `toArray(IntFunction<T[]> generator)`
  Returns the elements in an array generated by the given function.
  `<T> T[]`
  `toArray(T[] array)`
  Returns the elements in the given array, or in a new array if it was necessary to allocate more space.

  ### Methods inherited from class AbstractSequentialList

  `add, addAll, iterator, remove, set`

  ### Methods inherited from class AbstractList

  `add, clear, hashCode, indexOf, lastIndexOf, listIterator, removeRange, subList`

  ### Methods inherited from class AbstractCollection

  `addAll, contains, containsAll, remove, retainAll, toString`

  ### Methods inherited from class Object

  `clone, finalize, getClass, notify, notifyAll, wait, wait, wait`

  ### Methods inherited from interface Collection

  `parallelStream, removeIf, stream`

  ### Methods inherited from interface Iterable

  `forEach`

  ### Methods inherited from interface List

  `addAll, addFirst, addLast, contains, containsAll, getFirst, getLast, remove, removeFirst, removeLast, replaceAll, retainAll, reversed, sort`

- ## Constructor Details

  - ### ListOfUnknownSize

    protected ListOfUnknownSize()
    Creates a new list of initially unknown size.

- ## Method Details

  - ### isEmpty

    public boolean isEmpty()
    Returns `true` if this list is empty. The implementation of this method avoids to invoke `size()`.
    Specified by:
      `isEmpty` in interface `Collection<E>`
    Specified by:
      `isEmpty` in interface `List<E>`
    Overrides:
      `isEmpty` in class `AbstractCollection<E>`
    Returns:
      `true` if this list is empty.

  - ### size

    public int size()
    Returns the number of elements in this list. The default implementation returns the size if known, or otherwise searches the smallest value for which `isValidIndex(int)` returns `false`.
    Specified by:
      `size` in interface `Collection<E>`
    Specified by:
      `size` in interface `List<E>`
    Specified by:
      `size` in class `AbstractCollection<E>`
    Returns:
      the number of elements in this list.

  - ### sizeIfKnown

    protected OptionalInt sizeIfKnown()
    Returns the `size()` value if it is already known, or empty if the size is still unknown. The default implementation always returns an empty value. Subclasses can overwrite this method if they have already computed and cached the number of elements. When this information is known, some `ListOfUnknownSize` methods will take a more efficient path.
    Returns:
      `size()` if its value is already known, or empty if this value is still costly to compute.

  - ### isValidIndex

    protected abstract boolean isValidIndex(int index)
    Returns `true` if the given index is valid for this list. If the index i is valid, then all indices from 0 to i - 1 inclusive are presumed also valid. Invoking this method is usually less expansive than testing `index < size()` when the size is costly to compute.
    Parameters:
      `index` - the index where to verify if an element exists.
    Returns:
      `true` if an element exists at the given index.

  - ### get

    public abstract E get(int index)
    Returns the element at the specified index. Invoking this method may trig computation of the element if these computations are deferred.
    Specified by:
      `get` in interface `List<E>`
    Overrides:
      `get` in class `AbstractSequentialList<E>`
    Parameters:
      `index` - position of the element to get in this list.
    Returns:
      the element at the given index.
    Throws:
      `IndexOutOfBoundsException` - if the given index is out of bounds.

  - ### removeAll

    public boolean removeAll(Collection<?> c)
    Removes elements of the given collection from this list. The implementation of this method avoids to invoke `size()`.
    Specified by:
      `removeAll` in interface `Collection<E>`
    Specified by:
      `removeAll` in interface `List<E>`
    Overrides:
      `removeAll` in class `AbstractCollection<E>`
    Parameters:
      `c` - the collection containing elements to remove.
    Returns:
      `true` if at least one element has been removed.

  - ### listIterator

    public ListIterator<E> listIterator(int index)
    Returns a list iterator over the elements in this list. The default implementation delegates to `isValidIndex(int)` and `get(int)`. Write operations are not supported.
    Specified by:
      `listIterator` in interface `List<E>`
    Specified by:
      `listIterator` in class `AbstractSequentialList<E>`
    Parameters:
      `index` - index of first element to be returned from the list.
    Returns:
      a list iterator over the elements in this list.
    Throws:
      `IndexOutOfBoundsException` - if the given index is out of bounds.

  - ### characteristics

    protected int characteristics()
    Returns characteristics of this collection as a combination of `Spliterator` bits. The default implementation returns `Spliterator​.ORDERED`. Subclasses should add the `Spliterator​.NONNULL` bit if they guarantee that this list does not contain any `null` element.
    Returns:
      the characteristics of this collection.
    See Also:
      - `Spliterator​.ORDERED`
      - `Spliterator​.NONNULL`
      - `Spliterator​.IMMUTABLE`
      - `Spliterator​.characteristics()`

  - ### spliterator

    public Spliterator<E> spliterator()
    Creates a `Spliterator` which may be of unknown size.
    Returns:
      a `Spliterator` over the elements in this collection.

  - ### toArray

    public Object[] toArray()
    Returns all elements in an array. The implementation of this method avoids to invoke `size()`.
    Specified by:
      `toArray` in interface `Collection<E>`
    Specified by:
      `toArray` in interface `List<E>`
    Overrides:
      `toArray` in class `AbstractCollection<E>`
    Returns:
      an array containing all list elements.

  - ### toArray

    public <T> T[] toArray(T[] array)
    Returns the elements in the given array, or in a new array if it was necessary to allocate more space. If the given array is larger than necessary, the remaining array elements are set to `null`. The implementation of this method avoids to invoke `size()`.
    Specified by:
      `toArray` in interface `Collection<E>`
    Specified by:
      `toArray` in interface `List<E>`
    Overrides:
      `toArray` in class `AbstractCollection<E>`
    Type Parameters:
      `T` - the type array elements.
    Parameters:
      `array` - where to store the elements.
    Returns:
      an array containing all list elements.

  - ### toArray

    public <T> T[] toArray(IntFunction<T[]> generator)
    Returns the elements in an array generated by the given function. The implementation of this method avoids to invoke `size()`.
    Type Parameters:
      `T` - the type array elements.
    Parameters:
      `generator` - the function for allocating a new array.
    Returns:
      an array containing all list elements.