groovy.lang

## Class ListWithDefault<T>

- java.lang.Object
- - groovy.lang.ListWithDefault<T>

- All Implemented Interfaces:
    java.lang.Iterable<T>, java.util.Collection<T>, java.util.List<T>

      public final class ListWithDefault<T>
      extends java.lang.Object
      implements java.util.List<T>

  A wrapper for `List` which automatically grows the list when either `get(int)` or `getAt(int)` is called with an index greater than or equal to `size()`.
  Since:
    1.8.7

- - ### Method Summary

    All Methods Static Methods Instance Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `add(int i, T t)`
    `boolean` | `add(T t)`
    `boolean` | `addAll(java.util.Collection<? extends T> ts)`
    `boolean` | `addAll(int i, java.util.Collection<? extends T> ts)`
    `void` | `clear()`
    `boolean` | `contains(java.lang.Object o)`
    `boolean` | `containsAll(java.util.Collection<?> objects)`
    `boolean` | `equals(java.lang.Object obj)`
    `T` | `get(int index)` Returns the element at the given index but grows the list if needed.
    `T` | `getAt(int index)` Overwrites subscript operator handling by redirecting to `get(int)`.
    `java.util.List<T>` | `getDelegate()`
    `Closure` | `getInitClosure()`
    `int` | `hashCode()`
    `int` | `indexOf(java.lang.Object o)`
    `boolean` | `isEmpty()`
    `boolean` | `isLazyDefaultValues()`
    `java.util.Iterator<T>` | `iterator()`
    `int` | `lastIndexOf(java.lang.Object o)`
    `java.util.ListIterator<T>` | `listIterator()`
    `java.util.ListIterator<T>` | `listIterator(int i)`
    `static <T> ListWithDefault<T>` | `newInstance(java.util.List<T> items, boolean lazyDefaultValues, Closure initClosure)`
    `T` | `remove(int i)`
    `boolean` | `remove(java.lang.Object o)`
    `boolean` | `removeAll(java.util.Collection<?> objects)`
    `boolean` | `retainAll(java.util.Collection<?> objects)`
    `T` | `set(int i, T t)`
    `int` | `size()`
    `ListWithDefault<T>` | `subList(int fromIndex, int toIndex)` Returns a view of a portion of this list.
    `java.lang.Object[]` | `toArray()`
    `<T> T[]` | `toArray(T[] ts)`

    - ### Methods inherited from class java.lang.Object

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

    - ### Methods inherited from interface java.util.List

      `replaceAll, sort, spliterator`

    - ### Methods inherited from interface java.util.Collection

      `parallelStream, removeIf, stream`

    - ### Methods inherited from interface java.lang.Iterable

      `forEach`

- - ### Method Detail

    - #### getDelegate

          public java.util.List<T> getDelegate()

    - #### isLazyDefaultValues

          public boolean isLazyDefaultValues()

    - #### getInitClosure

          public Closure getInitClosure()

    - #### newInstance

          public static <T> ListWithDefault<T> newInstance(java.util.List<T> items,
                                                           boolean lazyDefaultValues,
                                                           Closure initClosure)

    - #### size

          public int size()

      Specified by:
        `size` in interface `java.util.Collection<T>`
      Specified by:
        `size` in interface `java.util.List<T>`

    - #### isEmpty

          public boolean isEmpty()

      Specified by:
        `isEmpty` in interface `java.util.Collection<T>`
      Specified by:
        `isEmpty` in interface `java.util.List<T>`

    - #### contains

          public boolean contains(java.lang.Object o)

      Specified by:
        `contains` in interface `java.util.Collection<T>`
      Specified by:
        `contains` in interface `java.util.List<T>`

    - #### iterator

          public java.util.Iterator<T> iterator()

      Specified by:
        `iterator` in interface `java.lang.Iterable<T>`
      Specified by:
        `iterator` in interface `java.util.Collection<T>`
      Specified by:
        `iterator` in interface `java.util.List<T>`

    - #### toArray

          public java.lang.Object[] toArray()

      Specified by:
        `toArray` in interface `java.util.Collection<T>`
      Specified by:
        `toArray` in interface `java.util.List<T>`

    - #### toArray

          public <T> T[] toArray(T[] ts)

      Specified by:
        `toArray` in interface `java.util.Collection<T>`
      Specified by:
        `toArray` in interface `java.util.List<T>`

    - #### add

          public boolean add(T t)

      Specified by:
        `add` in interface `java.util.Collection<T>`
      Specified by:
        `add` in interface `java.util.List<T>`

    - #### remove

          public boolean remove(java.lang.Object o)

      Specified by:
        `remove` in interface `java.util.Collection<T>`
      Specified by:
        `remove` in interface `java.util.List<T>`

    - #### containsAll

          public boolean containsAll(java.util.Collection<?> objects)

      Specified by:
        `containsAll` in interface `java.util.Collection<T>`
      Specified by:
        `containsAll` in interface `java.util.List<T>`

    - #### addAll

          public boolean addAll(java.util.Collection<? extends T> ts)

      Specified by:
        `addAll` in interface `java.util.Collection<T>`
      Specified by:
        `addAll` in interface `java.util.List<T>`

    - #### addAll

          public boolean addAll(int i,
                                java.util.Collection<? extends T> ts)

      Specified by:
        `addAll` in interface `java.util.List<T>`

    - #### removeAll

          public boolean removeAll(java.util.Collection<?> objects)

      Specified by:
        `removeAll` in interface `java.util.Collection<T>`
      Specified by:
        `removeAll` in interface `java.util.List<T>`

    - #### retainAll

          public boolean retainAll(java.util.Collection<?> objects)

      Specified by:
        `retainAll` in interface `java.util.Collection<T>`
      Specified by:
        `retainAll` in interface `java.util.List<T>`

    - #### clear

          public void clear()

      Specified by:
        `clear` in interface `java.util.Collection<T>`
      Specified by:
        `clear` in interface `java.util.List<T>`

    - #### getAt

          public T getAt(int index)

      Overwrites subscript operator handling by redirecting to `get(int)`.
      Parameters:
        `index` - an index (might be greater or equal to `size()`, or smaller than 0)
      Returns:
        the value at the given `index` or the default value

    - #### get

          public T get(int index)

      Returns the element at the given index but grows the list if needed. If the requested `index` is greater than or equal to `size()`, the list will grow to the new size and a default value calculated using the `initClosure` will be used to populate the missing value and returned.

      If `lazyDefaultValues` is `true` any gaps when growing the list are filled with nulls. Subsequent attempts to retrieve items from the list from those gap index values will, upon finding null, call the `initClosure` to populate the list for the given list value. Hence, when in this mode, nulls cannot be stored in this list. If `lazyDefaultValues` is `false` any gaps when growing the list are filled eagerly by calling the `initClosure` for all gap indexes during list growth. No calls to `initClosure` are made except during list growth and it is ok to store null values in the list when in this mode.

      This implementation breaks the contract of `List.get(int)` as it a) possibly modifies the underlying list and b) does NOT throw an `IndexOutOfBoundsException` when `index < 0 || index >= size()`.

      Specified by:
        `get` in interface `java.util.List<T>`
      Parameters:
        `index` - an index (might be greater or equal to `size()`, or smaller than 0)
      Returns:
        the value at the given `index` or the default value

    - #### set

          public T set(int i,
                       T t)

      Specified by:
        `set` in interface `java.util.List<T>`

    - #### add

          public void add(int i,
                          T t)

      Specified by:
        `add` in interface `java.util.List<T>`

    - #### remove

          public T remove(int i)

      Specified by:
        `remove` in interface `java.util.List<T>`

    - #### indexOf

          public int indexOf(java.lang.Object o)

      Specified by:
        `indexOf` in interface `java.util.List<T>`

    - #### lastIndexOf

          public int lastIndexOf(java.lang.Object o)

      Specified by:
        `lastIndexOf` in interface `java.util.List<T>`

    - #### listIterator

          public java.util.ListIterator<T> listIterator()

      Specified by:
        `listIterator` in interface `java.util.List<T>`

    - #### listIterator

          public java.util.ListIterator<T> listIterator(int i)

      Specified by:
        `listIterator` in interface `java.util.List<T>`

    - #### equals

          public boolean equals(java.lang.Object obj)

      Specified by:
        `equals` in interface `java.util.Collection<T>`
      Specified by:
        `equals` in interface `java.util.List<T>`
      Overrides:
        `equals` in class `java.lang.Object`

    - #### hashCode

          public int hashCode()

      Specified by:
        `hashCode` in interface `java.util.Collection<T>`
      Specified by:
        `hashCode` in interface `java.util.List<T>`
      Overrides:
        `hashCode` in class `java.lang.Object`

    - #### subList

          public ListWithDefault<T> subList(int fromIndex,
                                            int toIndex)

      Returns a view of a portion of this list. This method returns a list with the same lazy list settings as the original list.
      Specified by:
        `subList` in interface `java.util.List<T>`
      Parameters:
        `fromIndex` - low endpoint of the subList (inclusive)
        `toIndex` - upper endpoint of the subList (exclusive)
      Returns:
        a view of a specified range within this list, keeping all lazy list settings