org.apache.commons.collections4.list

## Class PredicatedList<E>

- java.lang.Object
- - org.apache.commons.collections4.collection.AbstractCollectionDecorator<E>
  - - org.apache.commons.collections4.collection.PredicatedCollection<E>
    - - org.apache.commons.collections4.list.PredicatedList<E>

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

      public class PredicatedList<E>
      extends PredicatedCollection<E>
      implements List<E>

  Decorates another `List` to validate that all additions match a specified predicate.

  This list exists to provide validation for the decorated list. It is normally created to decorate an empty list. If an object cannot be added to the list, an IllegalArgumentException is thrown.

  One usage would be to ensure that no null entries are added to the list.

       List<String> list =
         PredicatedList.predicatedList(new ArrayList<String>(), PredicateUtils.notNullPredicate());

  This class is Serializable from Commons Collections 3.1.

  Since:
    3.0
  Version:
    $Id: PredicatedList.java 1686855 2015-06-22 13:00:27Z tn $
  See Also:
    Serialized Form

- - ### Nested Class Summary

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

    - ### Nested classes/interfaces inherited from class org.apache.commons.collections4.collection.PredicatedCollection

      `PredicatedCollection.Builder<E>`

  - ### Field Summary

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

      `predicate`

  - ### Constructor Summary

    Constructors
    Modifier | Constructor and Description
    --- | ---
    `protected` | `PredicatedList(List<E> list, Predicate<? super E> predicate)` 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)`
    `protected List<E>` | `decorated()` Gets the list being decorated.
    `boolean` | `equals(Object object)`
    `E` | `get(int index)`
    `int` | `hashCode()`
    `int` | `indexOf(Object object)`
    `int` | `lastIndexOf(Object object)`
    `ListIterator<E>` | `listIterator()`
    `ListIterator<E>` | `listIterator(int i)`
    `static <T> PredicatedList<T>` | `predicatedList(List<T> list, Predicate<? super T> predicate)` Factory method to create a predicated (validating) list.
    `E` | `remove(int index)`
    `E` | `set(int index, E object)`
    `List<E>` | `subList(int fromIndex, int toIndex)`

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

      `add, addAll, builder, notNullBuilder, predicatedCollection, validate`

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

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

- - ### Constructor Detail

    - #### PredicatedList

          protected PredicatedList(List<E> list,
                        Predicate<? super E> predicate)

      Constructor that wraps (not copies).

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

      Parameters:
        `list` - the list to decorate, must not be null
        `predicate` - the predicate to use for validation, must not be null
      Throws:
        `NullPointerException` - if list or predicate is null
        `IllegalArgumentException` - if the list contains invalid elements

  - ### Method Detail

    - #### predicatedList

          public static <T> PredicatedList<T> predicatedList(List<T> list,
                                             Predicate<? super T> predicate)

      Factory method to create a predicated (validating) list.

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

      Type Parameters:
        `T` - the type of the elements in the list
      Parameters:
        `list` - the list to decorate, must not be null
        `predicate` - the predicate to use for validation, must not be null
      Returns:
        a new predicated list
      Throws:
        `NullPointerException` - if list or predicate is null
        `IllegalArgumentException` - if the list contains invalid elements
      Since:
        4.0

    - #### decorated

          protected List<E> decorated()

      Gets the list being decorated.
      Overrides:
        `decorated` in class `AbstractCollectionDecorator<E>`
      Returns:
        the decorated list

    - #### equals

          public boolean equals(Object object)

      Specified by:
        `equals` in interface `Collection<E>`
      Specified by:
        `equals` in interface `List<E>`
      Overrides:
        `equals` in class `Object`

    - #### hashCode

          public int hashCode()

      Specified by:
        `hashCode` in interface `Collection<E>`
      Specified by:
        `hashCode` in interface `List<E>`
      Overrides:
        `hashCode` in class `Object`

    - #### 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–2015 The Apache Software Foundation. All rights reserved.