EList (expressive 0.9.5 API)

Type Parameters:
T -

All Superinterfaces:

Collection<T>, Iterable<T>, List<T>

All Known Implementing Classes:

EListImpl
```
public interface EList<T>
extends List<T>
```
EList is an extension of the Java Collections List interface designed to allow for easy use and manipulation.

It implements convenience methods, and defines new methods analagous to the Java Collections operations to support a fluid, or chainable, interface.

Convenience methods defined by EList:
Methods that redefine standard Collection and List methods to support method call chaining:
- addItems(Object...)
- #addItems(Collection...)
- insertItems(int, Object...)
- #insertItems(int, Collection...)
- removeItems(Object...)
- #removeItems(Collection...)
- retainItems(Object...)
- #retainItems(Collection...)
See Also:
Expressive.list(Object...), Expressive#list(Collection...)

Method Summary

Methods
Modifier and Type	Method and Description
`EList<T>`	`addItems(Collection<? extends T> collection)` Appends all of the elements in the specific collections onto the end of this list.
`EList<T>`	`addItems(T... values)` Appends all of the specified elements onto the end of this list.
`T`	`at(int index)` Returns the element at the given index, or null if the element does not exist.
`EList<T>`	`duplicate()` Creates a copy of this `EList` containing the same elements.
`T`	`first()` Returns the first element of this list, or null if none exists.
`EList<T>`	`getItems(EPredicate<T> predicate)`
`EList<T>`	`getItems(int index, int size)` Returns a list of the items from the given index for the given size.
`EList<T>`	`insertItems(int index, Collection<? extends T> values)` Inserts all of the elements in the specified collections of elements into this list at the specified position.
`EList<T>`	`insertItems(int index, T... values)` Inserts all of the elements in the specified elements into this list at the specified position.
`T`	`last()` Returns the last element of this list, or null if none exists.
`EList<T>`	`removeItems(Collection<? extends T> values)` Removes from this list all of the elements in the specified collections.
`EList<T>`	`removeItems(EPredicate<T> predicate)`
`EList<T>`	`removeItems(T... values)` Removes from this list all of the specified elements.
`EList<T>`	`retainItems(Collection<? extends T> values)` Retains only the elements in this list that are contained in the specified collections.
`EList<T>`	`retainItems(EPredicate<T> predicate)`
`EList<T>`	`retainItems(T... values)` Retains only the elements in this list that are specified.
`EList<T>`	`sort(Comparator<T> comparator)` Sorts this `EList` in place using the given comparator.
`Pair<EList<T>,EList<T>>`	`split(EPredicate<T> predicate)`
`EList<T>`	`subList(int fromIndex, int toIndex)` Redefines `List.subList(int, int)` to return an `EList`

Methods inherited from interface java.util.List
add, add, addAll, addAll, clear, contains, containsAll, equals, get, hashCode, indexOf, isEmpty, iterator, lastIndexOf, listIterator, listIterator, remove, remove, removeAll, retainAll, set, size, toArray, toArray

- Method Detail
  - first
```
T first()
```
    Returns the first element of this list, or null if none exists.
    
    Returns:
  - last
```
T last()
```
    Returns the last element of this list, or null if none exists.
    
    Returns:
  - at
```
T at(int index)
```
    Returns the element at the given index, or null if the element does not exist. That is this method will not throw an exception for entries outside the bounds of the list.
    
    Parameters:
    index -
    
    Returns:
  - insertItems
```
EList<T> insertItems(int index,
                   T... values)
```
    Inserts all of the elements in the specified elements into this list at the specified position. Shifts the element currently at that position (if any) and any subsequent elements to the right (increases their indices). The new elements will appear in this list in the order that they specified.
    
    Parameters:
    index - index at which to insert the first element from the specified collection
    values - element(s) to be added to this list
    
    Returns:
    this list for method chaining
    
    Throws:
    
    IndexOutOfBoundsException - if the index is out of range ( index < 0 || index > size())
  - insertItems
```
EList<T> insertItems(int index,
                   Collection<? extends T> values)
```
    Inserts all of the elements in the specified collections of elements into this list at the specified position. Shifts the element currently at that position (if any) and any subsequent elements to the right (increases their indices). The new elements will appear in this list in the order that the collections they reside in specify.
    
    Parameters:
    index - index at which to insert the first element from the specified collection
    values - collections containing the element(s) to be added to this list
    
    Returns:
    this list for method chaining
    
    Throws:
    
    IndexOutOfBoundsException - if the index is out of range ( index < 0 || index > size())
  - addItems
```
EList<T> addItems(T... values)
```
    Appends all of the specified elements onto the end of this list. The new elements will appear in this list in the order that the collections they reside in specify.
    
    Parameters:
    values - element(s) to be appended to this list
    
    Returns:
    this list for method chaining
  - addItems
```
EList<T> addItems(Collection<? extends T> collection)
```
    Appends all of the elements in the specific collections onto the end of this list.
    
    The new elements will appear in this list in the order that the collections they reside in specify.
    
    Parameters:
    values - element(s) to be appended to this list
    
    Returns:
    this list for method chaining
  - removeItems
```
EList<T> removeItems(T... values)
```
    Removes from this list all of the specified elements.
    
    Parameters:
    values - the elements to be removed from this list
    
    Returns:
    this list for method chaining
  - removeItems
```
EList<T> removeItems(Collection<? extends T> values)
```
    Removes from this list all of the elements in the specified collections.
    
    Parameters:
    values - collections containing the elements to be removed from this list
    
    Returns:
    this list for method chaining
  - removeItems
```
EList<T> removeItems(EPredicate<T> predicate)
```
  - retainItems
```
EList<T> retainItems(T... values)
```
    Retains only the elements in this list that are specified.
    
    Parameters:
    values -
    
    Returns:
    this list for method chaining
    See Also:
    List.retainAll(Collection)
  - retainItems
```
EList<T> retainItems(Collection<? extends T> values)
```
    Retains only the elements in this list that are contained in the specified collections.
    
    Parameters:
    values -
    
    Returns:
    this list for method chaining
    See Also:
    List.retainAll(Collection)
  - retainItems
```
EList<T> retainItems(EPredicate<T> predicate)
```
  - duplicate
```
EList<T> duplicate()
```
    Creates a copy of this EList containing the same elements.
    
    Returns:
    a duplicate of this list, that is one which contains the same elements
  - subList
```
EList<T> subList(int fromIndex,
               int toIndex)
```
    Redefines List.subList(int, int) to return an EList
    
    Specified by:
    
    subList in interface List<T>
    
    See Also:
    List.subList(int, int)
  - getItems
```
EList<T> getItems(int index,
                int size)
```
    Returns a list of the items from the given index for the given size. If the index + size is out of bounds, the returned list will be shorter than the specified size, including only existing elements. If size if negative, an empty list is returned. If the given index is negative, the returned list will contain results as though it wasn't. Any 'negative' elements will be omitted, but the resulting size will match them as though they exists. e.g. The following test snippet would pass
```
 
 EList<String> list = Expressive.list("A","B","C");
 EList<String> items = list.getItems(-2,3);
 assertThat(items.size(), is(1));
 assertThat(items, is(list("A")));
 
 
```
    Parameters:
    index -
    size -
    
    Returns:
    a list of 'size' items starting from the given index, or as many as can be provided based on the list contents.
  - getItems
```
EList<T> getItems(EPredicate<T> predicate)
```
  - sort
```
EList<T> sort(Comparator<T> comparator)
```
    Sorts this EList in place using the given comparator.
    
    Parameters:
    comparator -
    
    Returns:
    this list
    See Also:
    Collections.sort(List)
  - split
```
Pair<EList<T>,EList<T>> split(EPredicate<T> predicate)
```

Interface EList<T>

Method Summary

Methods inherited from interface java.util.List

Method Detail

first

last

at

insertItems

insertItems

addItems

addItems

removeItems

removeItems

removeItems

retainItems

retainItems

retainItems

duplicate

subList

getItems

getItems

sort

split