ForwardingList
Date: 2016-05-24

com.google.common.collect

## Class ForwardingList<E>

- java.lang.Object
- - com.google.common.collect.ForwardingObject
  - - com.google.common.collect.ForwardingCollection<E>
    - - com.google.common.collect.ForwardingList<E>

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

      @GwtCompatible
      public abstract class ForwardingList<E>
      extends ForwardingCollection<E>
      implements java.util.List<E>

  A list which forwards all its method calls to another list. Subclasses should override one or more methods to modify the behavior of the backing list as desired per the decorator pattern.

  This class does not implement `RandomAccess`. If the delegate supports random access, the `ForwardingList` subclass should implement the `RandomAccess` interface.

  Warning: The methods of `ForwardingList` forward indiscriminately to the methods of the delegate. For example, overriding `add(int, E)` alone will not change the behavior of `addAll(int, java.util.Collection<? extends E>)`, which can lead to unexpected behavior. In this case, you should override `addAll` as well, either providing your own implementation, or delegating to the provided `standardAddAll` method.

  The `standard` methods and any collection views they return are not guaranteed to be thread-safe, even when all of the methods that they depend on are thread-safe.

  Since:
    2.0

- - ### Constructor Summary

    Constructors
    Modifier | Constructor and Description
    --- | ---
    `protected` | `ForwardingList()` Constructor for use by subclasses.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `add(int index, E element)`
    `boolean` | `addAll(int index, java.util.Collection<? extends E> elements)`
    `protected abstract java.util.List<E>` | `delegate()` Returns the backing delegate instance that methods are forwarded to.
    `boolean` | `equals(java.lang.Object object)`
    `E` | `get(int index)`
    `int` | `hashCode()`
    `int` | `indexOf(java.lang.Object element)`
    `int` | `lastIndexOf(java.lang.Object element)`
    `java.util.ListIterator<E>` | `listIterator()`
    `java.util.ListIterator<E>` | `listIterator(int index)`
    `E` | `remove(int index)`
    `E` | `set(int index, E element)`
    `protected boolean` | `standardAdd(E element)` A sensible default implementation of `ForwardingCollection.add(Object)`, in terms of `add(int, Object)`.
    `protected boolean` | `standardAddAll(int index, java.lang.Iterable<? extends E> elements)` A sensible default implementation of `addAll(int, Collection)`, in terms of the `add` method of `listIterator(int)`.
    `protected boolean` | `standardEquals(java.lang.Object object)` A sensible definition of `equals(Object)` in terms of `ForwardingCollection.size()` and `ForwardingCollection.iterator()`.
    `protected int` | `standardHashCode()` A sensible definition of `hashCode()` in terms of `ForwardingCollection.iterator()`.
    `protected int` | `standardIndexOf(java.lang.Object element)` A sensible default implementation of `indexOf(java.lang.Object)`, in terms of `listIterator()`.
    `protected java.util.Iterator<E>` | `standardIterator()` A sensible default implementation of `ForwardingCollection.iterator()`, in terms of `listIterator()`.
    `protected int` | `standardLastIndexOf(java.lang.Object element)` A sensible default implementation of `lastIndexOf(java.lang.Object)`, in terms of `listIterator(int)`.
    `protected java.util.ListIterator<E>` | `standardListIterator()` A sensible default implementation of `listIterator()`, in terms of `listIterator(int)`.
    `protected java.util.ListIterator<E>` | `standardListIterator(int start)` A sensible default implementation of `listIterator(int)`, in terms of `ForwardingCollection.size()`, `get(int)`, `set(int, Object)`, `add(int, Object)`, and `remove(int)`.
    `protected java.util.List<E>` | `standardSubList(int fromIndex, int toIndex)` A sensible default implementation of `subList(int, int)`.
    `java.util.List<E>` | `subList(int fromIndex, int toIndex)`

    - ### Methods inherited from class com.google.common.collect.ForwardingCollection

      `add, addAll, clear, contains, containsAll, isEmpty, iterator, remove, removeAll, retainAll, size, standardAddAll, standardClear, standardContains, standardContainsAll, standardIsEmpty, standardRemove, standardRemoveAll, standardRetainAll, standardToArray, standardToArray, standardToString, toArray, toArray`

    - ### Methods inherited from class com.google.common.collect.ForwardingObject

      `toString`

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

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

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

      `add, addAll, clear, contains, containsAll, isEmpty, iterator, remove, removeAll, retainAll, size, toArray, toArray`

- - ### Constructor Detail

    - #### ForwardingList

          protected ForwardingList()

      Constructor for use by subclasses.

  - ### Method Detail

    - #### delegate

          protected abstract java.util.List<E> delegate()

      Description copied from class: `ForwardingObject`
      Returns the backing delegate instance that methods are forwarded to. Abstract subclasses generally override this method with an abstract method that has a more specific return type, such as `ForwardingSet.delegate()`. Concrete subclasses override this method to supply the instance being decorated.
      Specified by:
        `delegate` in class `ForwardingCollection<E>`

    - #### add

          public void add(int index,
                 E element)

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

    - #### addAll

          public boolean addAll(int index,
                       java.util.Collection<? extends E> elements)

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

    - #### get

          public E get(int index)

      Specified by:
        `get` in interface `java.util.List<E>`

    - #### indexOf

          public int indexOf(java.lang.Object element)

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

    - #### lastIndexOf

          public int lastIndexOf(java.lang.Object element)

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

    - #### listIterator

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

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

    - #### listIterator

          public java.util.ListIterator<E> listIterator(int index)

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

    - #### remove

          public E remove(int index)

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

    - #### set

          public E set(int index,
              E element)

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

    - #### subList

          public java.util.List<E> subList(int fromIndex,
                                  int toIndex)

      Specified by:
        `subList` in interface `java.util.List<E>`

    - #### equals

          public boolean equals(@Nullable
                       java.lang.Object object)

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

    - #### hashCode

          public int hashCode()

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

    - #### standardAdd

          protected boolean standardAdd(E element)

      A sensible default implementation of `ForwardingCollection.add(Object)`, in terms of `add(int, Object)`. If you override `add(int, Object)`, you may wish to override `ForwardingCollection.add(Object)` to forward to this implementation.
      Since:
        7.0

    - #### standardAddAll

          protected boolean standardAddAll(int index,
                               java.lang.Iterable<? extends E> elements)

      A sensible default implementation of `addAll(int, Collection)`, in terms of the `add` method of `listIterator(int)`. If you override `listIterator(int)`, you may wish to override `addAll(int, Collection)` to forward to this implementation.
      Since:
        7.0

    - #### standardIndexOf

          protected int standardIndexOf(@Nullable
                            java.lang.Object element)

      A sensible default implementation of `indexOf(java.lang.Object)`, in terms of `listIterator()`. If you override `listIterator()`, you may wish to override `indexOf(java.lang.Object)` to forward to this implementation.
      Since:
        7.0

    - #### standardLastIndexOf

          protected int standardLastIndexOf(@Nullable
                                java.lang.Object element)

      A sensible default implementation of `lastIndexOf(java.lang.Object)`, in terms of `listIterator(int)`. If you override `listIterator(int)`, you may wish to override `lastIndexOf(java.lang.Object)` to forward to this implementation.
      Since:
        7.0

    - #### standardIterator

          protected java.util.Iterator<E> standardIterator()

      A sensible default implementation of `ForwardingCollection.iterator()`, in terms of `listIterator()`. If you override `listIterator()`, you may wish to override `ForwardingCollection.iterator()` to forward to this implementation.
      Since:
        7.0

    - #### standardListIterator

          protected java.util.ListIterator<E> standardListIterator()

      A sensible default implementation of `listIterator()`, in terms of `listIterator(int)`. If you override `listIterator(int)`, you may wish to override `listIterator()` to forward to this implementation.
      Since:
        7.0

    - #### standardListIterator

          @Beta
          protected java.util.ListIterator<E> standardListIterator(int start)

      A sensible default implementation of `listIterator(int)`, in terms of `ForwardingCollection.size()`, `get(int)`, `set(int, Object)`, `add(int, Object)`, and `remove(int)`. If you override any of these methods, you may wish to override `listIterator(int)` to forward to this implementation.
      Since:
        7.0

    - #### standardSubList

          @Beta
          protected java.util.List<E> standardSubList(int fromIndex,
                                               int toIndex)

      A sensible default implementation of `subList(int, int)`. If you override any other methods, you may wish to override `subList(int, int)` to forward to this implementation.
      Since:
        7.0

    - #### standardEquals

          @Beta
          protected boolean standardEquals(@Nullable
                                    java.lang.Object object)

      A sensible definition of `equals(Object)` in terms of `ForwardingCollection.size()` and `ForwardingCollection.iterator()`. If you override either of those methods, you may wish to override `equals(Object)` to forward to this implementation.
      Since:
        7.0

    - #### standardHashCode

          @Beta
          protected int standardHashCode()

      A sensible definition of `hashCode()` in terms of `ForwardingCollection.iterator()`. If you override `ForwardingCollection.iterator()`, you may wish to override `hashCode()` to forward to this implementation.
      Since:
        7.0