org.apache.commons.collections4.list

## Class TransformedList<E>

- java.lang.Object
- - org.apache.commons.collections4.collection.AbstractCollectionDecorator<E>
  - - org.apache.commons.collections4.collection.TransformedCollection<E>
    - - org.apache.commons.collections4.list.TransformedList<E>

- All Implemented Interfaces:
    Serializable, Iterable<E>, Collection<E>, List<E>

      public class TransformedList<E>
      extends TransformedCollection<E>
      implements List<E>

  Decorates another `List` to transform objects that are added.

  The add and set methods are affected by this class. Thus objects must be removed or searched for using their transformed form. For example, if the transformation converts Strings to Integers, you must use the Integer form to remove objects.

  This class is Serializable from Commons Collections 3.1.

  Since:
    3.0
  Version:
    $Id: TransformedList.java 1494280 2013-06-18 20:07:04Z tn $
  See Also:
    Serialized Form

- - ### Nested Class Summary

    Nested Classes
    Modifier and Type | Class and Description
    --- | ---
    `protected class` | `TransformedList.TransformedListIterator` Inner class Iterator for the TransformedList

  - ### Field Summary

    - ### Fields inherited from class org.apache.commons.collections4.collection.TransformedCollection

      `transformer`

  - ### Constructor Summary

    Constructors
    Modifier | Constructor and Description
    --- | ---
    `protected` | `TransformedList(List<E> list, Transformer<? super E,? extends E> transformer)` Constructor that wraps (not copies).

  - ### Method Summary

    Methods
    Modifier and Type | Method and Description
    --- | ---
    `void` | `add(int index, E object)`
    `boolean` | `addAll(int index, Collection<? extends E> coll)`
    `E` | `get(int index)`
    `protected List<E>` | `getList()` Gets the decorated list.
    `int` | `indexOf(Object object)`
    `int` | `lastIndexOf(Object object)`
    `ListIterator<E>` | `listIterator()`
    `ListIterator<E>` | `listIterator(int i)`
    `E` | `remove(int index)`
    `E` | `set(int index, E object)`
    `List<E>` | `subList(int fromIndex, int toIndex)`
    `static <E> TransformedList<E>` | `transformedList(List<E> list, Transformer<? super E,? extends E> transformer)` Factory method to create a transforming list that will transform existing contents of the specified list.
    `static <E> TransformedList<E>` | `transformingList(List<E> list, Transformer<? super E,? extends E> transformer)` Factory method to create a transforming list.

    - ### Methods inherited from class org.apache.commons.collections4.collection.TransformedCollection

      `add, addAll, transform, transform, transformedCollection, transformingCollection`

    - ### Methods inherited from class org.apache.commons.collections4.collection.AbstractCollectionDecorator

      `clear, contains, containsAll, decorated, equals, hashCode, isEmpty, iterator, remove, removeAll, retainAll, setCollection, size, toArray, toArray, 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, equals, hashCode, isEmpty, iterator, remove, removeAll, retainAll, size, toArray, toArray`

- - ### Constructor Detail

    - #### TransformedList

          protected TransformedList(List<E> list,
                         Transformer<? super E,? extends E> transformer)

      Constructor that wraps (not copies).

      If there are any elements already in the list being decorated, they are NOT transformed.

      Parameters:
        `list` - the list to decorate, must not be null
        `transformer` - the transformer to use for conversion, must not be null
      Throws:
        `IllegalArgumentException` - if list or transformer is null

  - ### Method Detail

    - #### transformingList

          public static <E> TransformedList<E> transformingList(List<E> list,
                                                Transformer<? super E,? extends E> transformer)

      Factory method to create a transforming list.

      If there are any elements already in the list being decorated, they are NOT transformed. Contrast this with `transformedList(List, Transformer)`.

      Type Parameters:
        `E` - the type of the elements in the list
      Parameters:
        `list` - the list to decorate, must not be null
        `transformer` - the transformer to use for conversion, must not be null
      Returns:
        a new transformed list
      Throws:
        `IllegalArgumentException` - if list or transformer is null
      Since:
        4.0

    - #### transformedList

          public static <E> TransformedList<E> transformedList(List<E> list,
                                               Transformer<? super E,? extends E> transformer)

      Factory method to create a transforming list that will transform existing contents of the specified list.

      If there are any elements already in the list being decorated, they will be transformed by this method. Contrast this with `transformingList(List, Transformer)`.

      Type Parameters:
        `E` - the type of the elements in the list
      Parameters:
        `list` - the list to decorate, must not be null
        `transformer` - the transformer to use for conversion, must not be null
      Returns:
        a new transformed List
      Throws:
        `IllegalArgumentException` - if list or transformer is null
      Since:
        4.0

    - #### getList

          protected List<E> getList()

      Gets the decorated list.
      Returns:
        the decorated list

    - #### get

          public E get(int index)

      Specified by:
        `get` in interface `List<E>`

    - #### indexOf

          public int indexOf(Object object)

      Specified by:
        `indexOf` in interface `List<E>`

    - #### lastIndexOf

          public int lastIndexOf(Object object)

      Specified by:
        `lastIndexOf` in interface `List<E>`

    - #### remove

          public E remove(int index)

      Specified by:
        `remove` in interface `List<E>`

    - #### add

          public void add(int index,
                 E object)

      Specified by:
        `add` in interface `List<E>`

    - #### addAll

          public boolean addAll(int index,
                       Collection<? extends E> coll)

      Specified by:
        `addAll` in interface `List<E>`

    - #### listIterator

          public ListIterator<E> listIterator()

      Specified by:
        `listIterator` in interface `List<E>`

    - #### listIterator

          public ListIterator<E> listIterator(int i)

      Specified by:
        `listIterator` in interface `List<E>`

    - #### set

          public E set(int index,
              E object)

      Specified by:
        `set` in interface `List<E>`

    - #### subList

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

      Specified by:
        `subList` in interface `List<E>`

Copyright © 2001–2013 The Apache Software Foundation. All rights reserved.