Expressive (expressive 0.9.5 API)

java.lang.Object
- com.atomicleopard.expressive.Expressive

```
public class Expressive
extends Object
```
Expressive is designed to allow coders to write more expressive code, focusing on what they want to do with collections of objects, rather than the mechanics of the manipulation of the Java Collections API.

In this vein, Expressive supplies static methods for the easy creation of different collection types, and returns types compatible with the Java Collections API that allow for easier use and manipulation.

See Also:
EList

Nested Class Summary

Nested Classes
Modifier and Type	Class and Description
`static class`	`Expressive.Comparators` Provides common implementations of comparators.
`static class`	`Expressive.Filter` Filter operations return views on an Iterable or Collection by applying a given `EPredicate` to them.
`static class`	`Expressive.Predicate` Provides common implementations of `EPredicate`.
`static class`	`Expressive.Transformers` Provides convenience access to `ETransformer`s that are of common use.

Method Summary

Methods
Modifier and Type	Method and Description
`static <T> T[]`	`array(Collection<T> values)` Convenience method for creating an array from a collection.
`static <T> T[]`	`array(T... values)` Convenience method for creating an array.
`static <T> Collection<T>`	`collection(T... values)` Convenience method for creating a collection.
`static <T> EList<T>`	`flatten(Collection<? extends Collection<? extends T>> collectionOfCollection)` Flattens the given collections of collections into a single list containing all entries.
`static <T> EList<T>`	`flatten(Collection<? extends T>... collectionOfCollection)` Flattens the given varargs of collections into a single list containing all entries.
`static <T> EList<T>`	`flatten(T[]... values)` Convenience method for creating an array containing the concatenated contents of the given set of arrays.
`static <T> boolean`	`isEmpty(Collection<T> collection)` Returns true if the given `Collection` is empty or null
`static <T> boolean`	`isEmpty(Iterable<T> iterable)` Returns true if the given `Iterable` is empty or null
`static <K,V> boolean`	`isEmpty(Map<K,V> map)` Returns true if the given `Map` is empty or null
`static <T> boolean`	`isNotEmpty(Collection<T> collection)` Returns true if the given `Collection` is not null and is not empty
`static <T> boolean`	`isNotEmpty(Iterable<T> iterable)` Returns true if the given `Iterable` is not null and is not empty
`static <K,V> boolean`	`isNotEmpty(Map<K,V> map)` Returns true if the given `Map` is not null empty and is not null
`static <T> Iterable<T>`	`iterable(Enumeration<T> enumeration)` Convenience method for creating an `Iterable` from an `Enumeration` so that it can easily be used in a for each loop.
`static <T> Iterable<T>`	`iterable(Iterator<T> iterator)` Convenience method for creating an `Iterable` from an `Iterator` so that it can easily be used in a for each loop.
`static <T> EList<T>`	`list(Collection<? extends T> values)` Convenience method for creating an `EList` from a `Collection`.
`static <T> EList<T>`	`list(Iterable<? extends T> values)` Convenience method for creating an `EList` from an `Iterable`.
`static <T> EList<T>`	`list(Iterator<? extends T> values)` Convenience method for creating an `EList` from an `Iterator`.
`static <T> EList<T>`	`list(T... values)` Convenience method for creating an `EList`.
`static <K,V> Map<K,V>`	`map(Object... values)` Returns a map based on the inputs interpreted as key-value pairs.
`static <K> MapKeys<K>`	`mapKeys(K... keys)` Supports a fluid syntax for creating maps conveniently.
`static <K> MapKeys<K>`	`mapKeys(List<K> keys)` Supports a fluid syntax for creating maps conveniently.
`static <K,V> Map<V,Set<K>>`	`reverse(Map<K,V> map)` Reverses a `Map`.
`static <K,V> Map<V,K>`	`reverseUnique(Map<K,V> map)` Reverses a `Map`, mapping each value in the given map to a single key value.
`static <T> Set<T>`	`set(T... values)` Convenience method for creating a `Set`.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - array
```
public static <T> T[] array(T... values)
```
    Convenience method for creating an array.
    
    Type Parameters:
    T -
    Parameters:
    values - the objects to be placed in an array
    
    Returns:
    an array containing of the given items in the given order
  - array
```
public static <T> T[] array(Collection<T> values)
```
    Convenience method for creating an array from a collection.
    
    Type Parameters:
    T -
    Parameters:
    values - a collection of objects to be placed in an array
    
    Returns:
    an array containing of the given items in the given order
    See Also:
    Collection.toArray()
  - collection
```
public static <T> Collection<T> collection(T... values)
```
    Convenience method for creating a collection.
    
    Type Parameters:
    T -
    Parameters:
    values - the objects to be placed in a collection
    
    Returns:
    a collection containing the given items
  - set
```
public static <T> Set<T> set(T... values)
```
    Convenience method for creating a Set.
    
    Type Parameters:
    T -
    Parameters:
    values - the objects to be placed in a set
    
    Returns:
    a Set containing the given items
  - map
```
public static <K,V> Map<K,V> map(Object... values)
```
    Returns a map based on the inputs interpreted as key-value pairs.
    i.e.
```
 Map<String, Integer> result = map(key1, value1, key2, value2)
 
```
    Due to the nature of mixed type arrays, any object can be used as a key or value pair, regardless of whether it matches the key or value generic types for the resulting map. Inserting the incorrect type will not result in a failure. Care should be taken, or class cast exceptions can occur at execution time. For compile time type safery, prefer mapKeys(Object...)
    
    If an uneven number of values are supplied, the final key will be omitted from the map.
    Parameters:
    values - an alternating set of key/value pairs matching the desired resulting generic types
  - mapKeys
```
public static <K> MapKeys<K> mapKeys(List<K> keys)
```
    Supports a fluid syntax for creating maps conveniently. Unlike #map(List), also ensures compile time type safety using generics.
    
    Returns a MapKeys, which will produce a Map when the MapKeys.to(List) method is invoked.
    
    Type Parameters:
    K -
    Parameters:
    keys - the set of keys to be present in the map produced by the resulting MapKeys
    
    Returns:
    a MapKeys with the specified keys
    See Also:
    MapKeys.to(List)
  - mapKeys
```
public static <K> MapKeys<K> mapKeys(K... keys)
```
    Supports a fluid syntax for creating maps conveniently. Unlike map(Object...), also ensures compile time type safety using generics.
    
    Returns a MapKeys, which will produce a Map when the MapKeys.to(Object...) method is invoked.
    
    Type Parameters:
    K -
    Parameters:
    keys - the set of keys to be present in the map produced by the resulting MapKeys
    
    Returns:
    a MapKeys with the specified keys
    See Also:
    MapKeys.to(List)
  - flatten
```
public static <T> EList<T> flatten(T[]... values)
```
    Convenience method for creating an array containing the concatenated contents of the given set of arrays.
    
    Parameters:
    values - the set of arrays to be concatenated together. Null array entries will be ignored.
    
    Returns:
    an EList containing of the contents of the given items in the given order
  - flatten
```
public static <T> EList<T> flatten(Collection<? extends Collection<? extends T>> collectionOfCollection)
```
    Flattens the given collections of collections into a single list containing all entries.
    
    This is useful in the scenario where we have grouped or categorised collections, such as a map of lists, when we want to search, sort, or iterate all entries.
    
    For example:
```
 Map<String, List<String>> referenceInformation;
 Collection<List<String>> values = referenceInformation.values();
 EList<String> allValues = flatten(values);
 
```
    Type Parameters:
    T -
    Parameters:
    collectionOfCollection -
    
    Returns:
  - flatten
```
public static <T> EList<T> flatten(Collection<? extends T>... collectionOfCollection)
```
    Flattens the given varargs of collections into a single list containing all entries.
    
    This scenario is useful generally in test code where we want to assemble specific sets of collections from expected and unexpected values
    
    For example:
```
 
 List<String> expected = list("A", "E", "Y");
 List<String> notExpected = list("B", "D", "Z");
 List<String> vowels = giveMeOnlyVowels(flatten(expected, notExpected));
 assertThat(vowels, is(expected));
 
 
```
    Type Parameters:
    T -
    Parameters:
    collectionOfCollection -
    
    Returns:
  - list
```
public static <T> EList<T> list(T... values)
```
    Convenience method for creating an EList.
    
    This can also be used to create a List as an alternative to Arrays.asList(Object...).
    
    Type Parameters:
    T -
    Parameters:
    values - the objects to be placed in a list
    
    Returns:
    an EList containing the given items in the given order
  - list
```
public static <T> EList<T> list(Collection<? extends T> values)
```
    Convenience method for creating an EList from a Collection. The resulting EList will contain all elements from the given Collections.
    
    The resulting order of the items is dependent on the order defined by the supplied collection.
    
    Type Parameters:
    T -
    Parameters:
    values - the objects to be placed in a collection
    
    Returns:
    an EList containing the given items in the given order
  - list
```
public static <T> EList<T> list(Iterable<? extends T> values)
```
    Convenience method for creating an EList from an Iterable. The resulting EList will contain all elements available from the Iterator obtained from the Iterable.
    
    The resulting order of the items is dependent on the order defined by the Iterator underlying the Iterable
    
    Type Parameters:
    T -
    Parameters:
    values - the iterable containing the objects to be placed in a list
    
    Returns:
    an EList containing the given items in the given order
  - list
```
public static <T> EList<T> list(Iterator<? extends T> values)
```
    Convenience method for creating an EList from an Iterator.
    
    The resulting order of the items is dependent on the order of the Iterator.
    
    The given iterator should be considered stale once passed to this method. If Iterator.next() has already been called on the given iterator, those elements will not be present in the resulting list.
    
    Type Parameters:
    T -
    Parameters:
    values - the iterator containing the objects to be placed in a list
    
    Returns:
    an EList containing the given items in the given order
  - isEmpty
```
public static <T> boolean isEmpty(Iterable<T> iterable)
```
    Returns true if the given Iterable is empty or null
    
    Parameters:
    iterable - an iterable, or null
    
    Returns:
    true if the given Iterable is empty or null
  - isEmpty
```
public static <T> boolean isEmpty(Collection<T> collection)
```
    Returns true if the given Collection is empty or null
    
    Parameters:
    collection - a collection, or null
    
    Returns:
    true if the given Collection is empty or null
  - isEmpty
```
public static <K,V> boolean isEmpty(Map<K,V> map)
```
    Returns true if the given Map is empty or null
    
    Parameters:
    map - a map, or null
    
    Returns:
    true if the given Map is empty or null
  - isNotEmpty
```
public static <T> boolean isNotEmpty(Iterable<T> iterable)
```
    Returns true if the given Iterable is not null and is not empty
    
    Parameters:
    iterable - a iterable, or null
    
    Returns:
    true if the given Iterable is not null and is not empty
  - isNotEmpty
```
public static <T> boolean isNotEmpty(Collection<T> collection)
```
    Returns true if the given Collection is not null and is not empty
    
    Parameters:
    collection - a collection, or null
    
    Returns:
    true if the given Collection is not null and is not empty
  - isNotEmpty
```
public static <K,V> boolean isNotEmpty(Map<K,V> map)
```
    Returns true if the given Map is not null empty and is not null
    
    Parameters:
    map - a map, or null
    
    Returns:
    true if the given Map is not null and is not empty
  - reverse
```
public static <K,V> Map<V,Set<K>> reverse(Map<K,V> map)
```
    Reverses a Map. Returns a new map where the values of the given map are mapped to the set of keys. This function is similar to the reverseUnique(Map) function, but can handle multiple keys of the input map having a single value.
    
    Parameters:
    map -
    
    Returns:
    See Also:
    reverseUnique(Map)
  - reverseUnique
```
public static <K,V> Map<V,K> reverseUnique(Map<K,V> map)
```
    Reverses a Map, mapping each value in the given map to a single key value. If a value may appear more than once, reverse(Map) should be used instead.
    
    Parameters:
    map -
    
    Returns:
    See Also:
    reverse(Map)
  - iterable
```
public static <T> Iterable<T> iterable(Iterator<T> iterator)
```
    Convenience method for creating an Iterable from an Iterator so that it can easily be used in a for each loop.
    
    Iterators used in this fashion should be discarded, as their state will be altered permanently once they are accessed (the for loop is executed).
    Likewise, the resulting Iterable should only have Iterable.iterator() invoked once.
    
    The Iterator returned from the resulting Iterable is the same as the supplied instance, and as such supports Iterator.remove() if the given iterator does.
```
 e.g.
 public boolean supportsColorModel(ImageReader reader, ColorModel colorModel) throws IOException {
 Iterator<ImageTypeSpecifier> imageTypes = reader.getImageTypes(0);
        for (ImageTypeSpecifier imageTypeSpecifier : iterable(imageTypes)) {
                if (colorModel.equals(imageTypeSpecifier.getColorModel())) {
                        return true;
                }
        }
        return false;
 }
 
```
    Type Parameters:
    T -
    Parameters:
    iterator - the Iterator to wrap in an Iterable
    
    Returns:
  - iterable
```
public static <T> Iterable<T> iterable(Enumeration<T> enumeration)
```
    Convenience method for creating an Iterable from an Enumeration so that it can easily be used in a for each loop.
    
    Enumerations used in this fashion should be discarded, as their state will be altered once the for loop is executed.
    Likewise, the resulting Iterable should only have Iterable.iterator() invoked once.
    
    The iterator created by the resulting iterable does not support Iterator.remove()
    
    e.g.
```
 NetworkInterface networkInterface;
        Enumeration<InetAddress> inetAddresses = networkInterface.getInetAddresses();
        for (InetAddress inetAddress : Expressive.iterable(inetAddresses)) {
                ...
        }
 
```
    Type Parameters:
    T -
    Parameters:
    enumeration - the enumeration to wrap in an iterable
    
    Returns:

Class Expressive

Nested Class Summary

Method Summary

Methods inherited from class java.lang.Object

Method Detail

array

array

collection

set

map

mapKeys

mapKeys

flatten

flatten

flatten

list

list

list

list

isEmpty

isEmpty

isEmpty

isNotEmpty

isNotEmpty

isNotEmpty

reverse

reverseUnique

iterable

iterable