ForwardingCollection
Date: 2016-05-24

com.google.common.collect

## Class ForwardingCollection<E>

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

- All Implemented Interfaces:
    java.lang.Iterable<E>, java.util.Collection<E>
  Direct Known Subclasses:
    ForwardingList, ForwardingMultiset, ForwardingQueue, ForwardingSet

      @GwtCompatible
      public abstract class ForwardingCollection<E>
      extends ForwardingObject
      implements java.util.Collection<E>

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

  Warning: The methods of `ForwardingCollection` forward indiscriminately to the methods of the delegate. For example, overriding `add(E)` alone will not change the behavior of `addAll(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 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` | `ForwardingCollection()` Constructor for use by subclasses.

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `boolean` | `add(E element)`
    `boolean` | `addAll(java.util.Collection<? extends E> collection)`
    `void` | `clear()`
    `boolean` | `contains(java.lang.Object object)`
    `boolean` | `containsAll(java.util.Collection<?> collection)`
    `protected abstract java.util.Collection<E>` | `delegate()` Returns the backing delegate instance that methods are forwarded to.
    `boolean` | `isEmpty()`
    `java.util.Iterator<E>` | `iterator()`
    `boolean` | `remove(java.lang.Object object)`
    `boolean` | `removeAll(java.util.Collection<?> collection)`
    `boolean` | `retainAll(java.util.Collection<?> collection)`
    `int` | `size()`
    `protected boolean` | `standardAddAll(java.util.Collection<? extends E> collection)` A sensible definition of `addAll(java.util.Collection<? extends E>)` in terms of `add(E)`.
    `protected void` | `standardClear()` A sensible definition of `clear()` in terms of `iterator()`, using the iterator's `remove` method.
    `protected boolean` | `standardContains(java.lang.Object object)` A sensible definition of `contains(java.lang.Object)` in terms of `iterator()`.
    `protected boolean` | `standardContainsAll(java.util.Collection<?> collection)` A sensible definition of `containsAll(java.util.Collection<?>)` in terms of `contains(java.lang.Object)` .
    `protected boolean` | `standardIsEmpty()` A sensible definition of `isEmpty()` as `!iterator().hasNext`.
    `protected boolean` | `standardRemove(java.lang.Object object)` A sensible definition of `remove(java.lang.Object)` in terms of `iterator()`, using the iterator's `remove` method.
    `protected boolean` | `standardRemoveAll(java.util.Collection<?> collection)` A sensible definition of `removeAll(java.util.Collection<?>)` in terms of `iterator()`, using the iterator's `remove` method.
    `protected boolean` | `standardRetainAll(java.util.Collection<?> collection)` A sensible definition of `retainAll(java.util.Collection<?>)` in terms of `iterator()`, using the iterator's `remove` method.
    `protected java.lang.Object[]` | `standardToArray()` A sensible definition of `toArray()` in terms of `toArray(Object[])`.
    `protected <T> T[]` | `standardToArray(T[] array)` A sensible definition of `toArray(Object[])` in terms of `size()` and `iterator()`.
    `protected java.lang.String` | `standardToString()` A sensible definition of `ForwardingObject.toString()` in terms of `iterator()`.
    `java.lang.Object[]` | `toArray()`
    `<T> T[]` | `toArray(T[] array)`

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

      `toString`

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

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

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

      `equals, hashCode`

- - ### Constructor Detail

    - #### ForwardingCollection

          protected ForwardingCollection()

      Constructor for use by subclasses.

  - ### Method Detail

    - #### delegate

          protected abstract java.util.Collection<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 `ForwardingObject`

    - #### iterator

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

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

    - #### size

          public int size()

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

    - #### removeAll

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

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

    - #### isEmpty

          public boolean isEmpty()

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

    - #### contains

          public boolean contains(java.lang.Object object)

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

    - #### add

          public boolean add(E element)

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

    - #### remove

          public boolean remove(java.lang.Object object)

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

    - #### containsAll

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

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

    - #### addAll

          public boolean addAll(java.util.Collection<? extends E> collection)

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

    - #### retainAll

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

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

    - #### clear

          public void clear()

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

    - #### toArray

          public java.lang.Object[] toArray()

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

    - #### toArray

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

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

    - #### standardContains

          protected boolean standardContains(@Nullable
                                 java.lang.Object object)

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

    - #### standardContainsAll

          protected boolean standardContainsAll(java.util.Collection<?> collection)

      A sensible definition of `containsAll(java.util.Collection<?>)` in terms of `contains(java.lang.Object)` . If you override `contains(java.lang.Object)`, you may wish to override `containsAll(java.util.Collection<?>)` to forward to this implementation.
      Since:
        7.0

    - #### standardAddAll

          protected boolean standardAddAll(java.util.Collection<? extends E> collection)

      A sensible definition of `addAll(java.util.Collection<? extends E>)` in terms of `add(E)`. If you override `add(E)`, you may wish to override `addAll(java.util.Collection<? extends E>)` to forward to this implementation.
      Since:
        7.0

    - #### standardRemove

          protected boolean standardRemove(@Nullable
                               java.lang.Object object)

      A sensible definition of `remove(java.lang.Object)` in terms of `iterator()`, using the iterator's `remove` method. If you override `iterator()`, you may wish to override `remove(java.lang.Object)` to forward to this implementation.
      Since:
        7.0

    - #### standardRemoveAll

          protected boolean standardRemoveAll(java.util.Collection<?> collection)

      A sensible definition of `removeAll(java.util.Collection<?>)` in terms of `iterator()`, using the iterator's `remove` method. If you override `iterator()`, you may wish to override `removeAll(java.util.Collection<?>)` to forward to this implementation.
      Since:
        7.0

    - #### standardRetainAll

          protected boolean standardRetainAll(java.util.Collection<?> collection)

      A sensible definition of `retainAll(java.util.Collection<?>)` in terms of `iterator()`, using the iterator's `remove` method. If you override `iterator()`, you may wish to override `retainAll(java.util.Collection<?>)` to forward to this implementation.
      Since:
        7.0

    - #### standardClear

          protected void standardClear()

      A sensible definition of `clear()` in terms of `iterator()`, using the iterator's `remove` method. If you override `iterator()`, you may wish to override `clear()` to forward to this implementation.
      Since:
        7.0

    - #### standardIsEmpty

          protected boolean standardIsEmpty()

      A sensible definition of `isEmpty()` as `!iterator().hasNext`. If you override `isEmpty()`, you may wish to override `isEmpty()` to forward to this implementation. Alternately, it may be more efficient to implement `isEmpty` as `size() == 0`.
      Since:
        7.0

    - #### standardToString

          protected java.lang.String standardToString()

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

    - #### standardToArray

          protected java.lang.Object[] standardToArray()

      A sensible definition of `toArray()` in terms of `toArray(Object[])`. If you override `toArray(Object[])`, you may wish to override `toArray()` to forward to this implementation.
      Since:
        7.0

    - #### standardToArray

          protected <T> T[] standardToArray(T[] array)

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