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
Author:
  Andre Steingress

### Method Summary

All Methods Static Methods Instance Methods Concrete Methods
`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> java.util.List<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()`
`java.util.List<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> java.util.List<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 java.util.List<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