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>, Sequenced­Collection<E>
public abstract class ListOfUnknownSize<E> extends AbstractSequentialList<E>
An alternative to Abstract­List 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 Abstract­Sequential­List, subclasses are not expected to overwrite the list­Iterator(int) method. Instead, subclasses should implement the following methods:
Since:
1.6

  • 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:
      is­Empty in interface Collection<E>
      Specified by:
      is­Empty in interface List<E>
      Overrides:
      is­Empty in class Abstract­Collection<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 is­Valid­Index(int) returns false.
      Specified by:
      size in interface Collection<E>
      Specified by:
      size in interface List<E>
      Specified by:
      size in class Abstract­Collection<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 List­Of­Unknown­Size 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 Abstract­Sequential­List<E>
      Parameters:
      index - position of the element to get in this list.
      Returns:
      the element at the given index.
      Throws:
      Index­Out­Of­Bounds­Exception - 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:
      remove­All in interface Collection<E>
      Specified by:
      remove­All in interface List<E>
      Overrides:
      remove­All in class Abstract­Collection<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 is­Valid­Index(int) and get(int). Write operations are not supported.
      Specified by:
      list­Iterator in interface List<E>
      Specified by:
      list­Iterator in class Abstract­Sequential­List<E>
      Parameters:
      index - index of first element to be returned from the list.
      Returns:
      a list iterator over the elements in this list.
      Throws:
      Index­Out­Of­Bounds­Exception - 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

      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:
      to­Array in interface Collection<E>
      Specified by:
      to­Array in interface List<E>
      Overrides:
      to­Array in class Abstract­Collection<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:
      to­Array in interface Collection<E>
      Specified by:
      to­Array in interface List<E>
      Overrides:
      to­Array in class Abstract­Collection<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.