Lambda (lambdaj 2.4 API)

java.lang.Object
- ch.lambdaj.Lambda

```
public final class Lambda
extends Object
```
This class consists exclusively of static methods that allow to use all the core features of the lambdaj library.

Author:

Mario Fusco

Field Summary

Fields
Modifier and Type Field and Description

static int DESCENDING

static int IGNORE_CASE

Fields
Modifier and Type	Field and Description
`static int`	`DESCENDING`
`static int`	`IGNORE_CASE`

Method Summary

Methods
Modifier and Type	Method and Description
`static <T> T`	`aggregate(Object iterable, Aggregator<T> aggregator)` Aggregates the items in the given iterable using the given `Aggregator`.
`static <T,A> T`	`aggregate(Object iterable, Aggregator<T> aggregator, A argument)` For each item in the given iterable collects the value defined by the given argument and then aggregates them iterable using the given `Aggregator`.
`static <T,A> T`	`aggregateFrom(Iterable<T> iterable, Aggregator<A> aggregator)` Returns a lambda function defined as: aggregateFrom : (aggregator, iterable) => lambda : (convert : object => object) => object It is then possibly to curry this function by selecting the convert function that defines how each item must be converted in the object to be aggregated.
`static <T,A> T`	`aggregateFrom(Iterable<T> iterable, Class<?> clazz, Aggregator<A> aggregator)` Returns a lambda function defined as: aggregateFrom : (aggregator, iterable) => lambda : (convert : object => object) => object It is then possibly to curry this function by selecting the convert function that defines how each item must be converted in the object to be aggregated.
`static <T> Argument<T>`	`argument(T argumentPlaceholder)` Returns the actual argument of the methods invocation sequence defined through the `on(Class)` method.
`static <F> Converter<F,Map.Entry<String,Object>>`	`as(Object argument)` Creates a converter that projects the value of the argument of an object using as alias the argument property name as defined by `Argument.getInkvokedPropertyName()`
`static <F> Converter<F,Map.Entry<String,Object>>`	`as(String alias, Object argument)` Creates a converter that projects the value of the argument of an object using as the given alias
`static Number`	`avg(Object iterable)` Calculates the average of the items in the given iterable of Numbers or the iterable itself if it actually is already a single number.
`static <T> T`	`avg(Object iterable, T argument)` Calculates the average of the property values of the items in the given iterable defined by the given argument.
`static <T> T`	`avgFrom(Iterable<T> iterable)` Returns a lambda function defined as: avgFrom : (avg, iterable) => lambda : (convert : object => number) => number It is then possibly to curry this function by selecting the convert function that defines of each item must be converted in a number.
`static <T> T`	`avgFrom(Iterable<T> iterable, Class<?> clazz)` Returns a lambda function defined as: avgFrom : (avg, iterable) => lambda : (convert : object => number) => number It is then possibly to curry this function by selecting the convert function that defines of each item must be converted in a number.
`static <T> ArgumentGroupCondition<T>`	`by(T argument)` Creates a GroupCondition that allows to group items based on the value they have on a given argument
`static Closure`	`closure()` Creates a generic (not typed) closure and binds it to the current thread
`static <A> Closure1<A>`	`closure(Class<A> type1)` Creates a closure with a single free variable and binds it to the current thread
`static <A,B> Closure2<A,B>`	`closure(Class<A> type1, Class<B> type2)` Creates a closure with two free variables and binds it to the current thread
`static <A,B,C> Closure3<A,B,C>`	`closure(Class<A> type1, Class<B> type2, Class<C> type3)` Creates a closure with three free variables and binds it to the current thread
`static <A,B,C,D> Closure4<A,B,C,D>`	`closure(Class<A> type1, Class<B> type2, Class<C> type3, Class<D> type4)` Creates a closure with four free variables and binds it to the current thread
`static <T> List<? extends T>`	`collect(Object iterable)` Collects the items in the given iterable putting them in a List.
`static <T> List<T>`	`collect(Object iterable, T argument)` For each item in the given iterable collects the value defined by the given argument and put them in a List.
`static <F,T> List<T>`	`convert(Object iterable, Converter<F,T> converter)` Converts all the object in the iterable using the given `Converter`.
`static <F,T> Iterator<T>`	`convertIterator(Object iterable, Converter<F,T> converter)` Converts all the object in the iterable using the given `Converter`.
`static <K,F,T> Map<K,T>`	`convertMap(Map<K,F> map, Converter<F,T> converter)` Converts all the values in the map using the given `Converter`.
`static <K,F,T> Map<K,T>`	`convertMap(Map<K,F> map, T argument)` Converts all the values in the map extracting the property defined by the given argument.
`static <T> Map<T,Integer>`	`count(Object iterable)` Counts the number of occurrencies of the objects in the given iterable Actually it handles also Maps, Arrays and Iterator by collecting their values.
`static <A> Map<A,Integer>`	`count(Object iterable, A argument)` Counts the number of occurrencies of the argument's value in the objects of the given iterable Actually it handles also Maps, Arrays and Iterator by collecting their values.
`static <T> ClosureResult<T>`	`delayedClosure(DelayedClosure<T> delayedClosure)` Returns the result of the invocation of the method that uses the given delayed closure
`static void`	`enableJitting(boolean enable)` Enable or disable the JIT optimization of lambdaj's arguments.
`static boolean`	`exists(Object iterable, org.hamcrest.Matcher<?> matcher)` Returns true if the given iterable contains at least an item that matches the given hamcrest Matcher Actually it handles also Maps, Arrays and Iterator by collecting their values.
`static <F,T> List<T>`	`extract(Object iterable, T argument)` Converts all the object in the iterable extracting the property defined by the given argument.
`static <F,T> Iterator<T>`	`extractIterator(Object iterable, T argument)` Converts all the object in the iterable extracting the property defined by the given argument.
`static <F,T> List<T>`	`extractProperty(Object iterable, String propertyName)` Converts all the object in the iterable extracting the named property.
`static List<String>`	`extractString(Object iterable)` Converts all the object in the iterable in its String representation.
`static <T> List<T>`	`filter(org.hamcrest.Matcher<?> matcher, Iterable<T> iterable)` Filters all the objects in the given iterable that match the given hamcrest Matcher
`static <T> List<T>`	`filter(org.hamcrest.Matcher<?> matcher, T... array)` Filters all the objects in the given array that match the given hamcrest Matcher
`static <T> List<T>`	`flatten(Object iterable)` Flattens the given iterable by recursively descending through its nested Collections and create a flat List of all of the leaves.
`static <T> T`	`forEach(Class<T> clazz, T... array)` Transforms an array of Ts in a single object having the same methods of a single instance of T.
`static <T> T`	`forEach(Iterable<? extends T> iterable)` Transforms a collection of Ts in a single object having the same methods of a single instance of T.
`static <T> T`	`forEach(Iterable<? extends T> iterable, Class<T> clazz)` Transforms a collection of Ts in a single object having the same methods of a single instance of T.
`static <T> T`	`forEach(Iterator<? extends T> iterator)` Transforms a collection of Ts in a single object having the same methods of a single instance of T.
`static <T> T`	`forEach(Iterator<? extends T> iterator, Class<T> clazz)` Transforms an iterator of Ts in a single object having the same methods of a single instance of T.
`static <T> T`	`forEach(T... array)` Transforms an array of Ts in a single object having the same methods of a single instance of T.
`static <T> Group<T>`	`group(Iterable<T> iterable, Collection<? extends GroupCondition<?>> conditions)` Organizes the given list of items in (hierarchy of) groups based on the given grouping conditions
`static <T> Group<T>`	`group(Iterable<T> iterable, GroupCondition<?>... conditions)` Organizes the given list of items in (hierarchy of) groups based on the given grouping conditions
`static <T> Group<T>`	`group(Iterable<T> iterable, String... groupers)` Organizes the given list of items in (hierarchy of) groups based on the values they have on the named JavaBean proprties
`static <T,A> HasArgumentWithValue<T,A>`	`having(A argument, org.hamcrest.Matcher<?> matcher)` Creates an hamcrest matcher that is evalued to true if the value of the given argument satisfies the condition defined by the passed matcher.
`static <T> HasArgumentWithValue<T,Boolean>`	`having(Boolean argument)` Creates an hamcrest matcher that is evalued to true accordingly to the value of the passed argument
`static <F,T> Map<T,F>`	`index(Object iterable, T argument)` Indexes the objects in the given iterable based on the value of their argument.
`static String`	`join(Object iterable)` Joins all the object in the given iterable by concatenating all their String representation.
`static String`	`join(Object iterable, String separator)` Joins all the object in the given iterable by concatenating all their String representation.
`static <T> T`	`joinFrom(Iterable<T> iterable)` Returns a lambda function defined as: joinFrom : (concat, iterable) => lambda : (convert : object => object) => string It is then possibly to curry this function by selecting the convert function that defines of each item must be converted in a String.
`static <T> T`	`joinFrom(Iterable<T> iterable, Class<?> clazz)` Returns a lambda function defined as: joinFrom : (concat, iterable) => lambda : (convert : object => object) => string It is then possibly to curry this function by selecting the convert function that defines of each item must be converted in a String.
`static <T> T`	`joinFrom(Iterable<T> iterable, Class<?> clazz, String separator)` Returns a lambda function defined as: joinFrom : (concat, iterable) => lambda : (convert : object => object) => string It is then possibly to curry this function by selecting the convert function that defines of each item must be converted in a String.
`static <T> T`	`joinFrom(Iterable<T> iterable, String separator)` Returns a lambda function defined as: joinFrom : (concat, iterable) => lambda : (convert : object => object) => string It is then possibly to curry this function by selecting the convert function that defines of each item must be converted in a String.
`static <F,T> Map<T,F>`	`map(Object iterable, Converter<F,T> converter)` Maps the objects in the given iterable on the value extracted using the given `Converter`.
`static <T> T`	`max(Object iterable)` Finds the maximum item in the given iterable.
`static <T> T`	`max(Object iterable, T argument)` Finds the maximum item in the given iterable defined by the given argument.
`static <T> T`	`maxFrom(Iterable<T> iterable)` Returns a lambda function defined as: maxFrom : (max, iterable) => lambda : (convert : object => object) => object It is then possibly to curry this function by selecting the convert function that defines how each item must be converted in the object of which a maximum value needs to be found.
`static <T> T`	`maxFrom(Iterable<T> iterable, Class<?> clazz)` Returns a lambda function defined as: maxFrom : (max, iterable) => lambda : (convert : object => object) => object It is then possibly to curry this function by selecting the convert function that defines how each item must be converted in the object of which a maximum value needs to be found.
`static <T> T`	`min(Object iterable)` Finds the minimum item in the given iterable.
`static <T> T`	`min(Object iterable, T argument)` Finds the minimum item in the given iterable defined by the given argument.
`static <T> T`	`minFrom(Iterable<T> iterable)` Returns a lambda function defined as: minFrom : (min, iterable) => lambda : (convert : object => object) => object It is then possibly to curry this function by selecting the convert function that defines how each item must be converted in the object of which a minimum value needs to be found.
`static <T> T`	`minFrom(Iterable<T> iterable, Class<?> clazz)` Returns a lambda function defined as: minFrom : (min, iterable) => lambda : (convert : object => object) => object It is then possibly to curry this function by selecting the convert function that defines how each item must be converted in the object of which a minimum value needs to be found.
`static <T> T`	`of(Class<T> closedClass)` Binds a free variable of the given class to the active closure that is the last one created in the current thread.
`static <T> T`	`of(T closed)` Binds an object to the active closure that is the last one created in the current thread.
`static <T> T`	`of(T closed, Class<T> closedClass)` Binds an object to the active closure that is the last one created in the current thread.
`static <T> T`	`on(Class<T> clazz)` Constructs a proxy object that mocks the given Class registering all the subsequent invocations on the object.
`static <T> List<T>`	`project(Object iterable, Class<T> targetClass, Object... arguments)` Converts the objects in the given iterable in objects of the given target Class.
`static <F> List<Map<String,Object>>`	`project(Object iterable, Converter<F,Map.Entry<String,Object>>... projectors)` Projects the objects in the given iterable by converting each of them in a set of key/value pairs.
`static <T> void`	`registerFinalClassArgumentCreator(Class<T> clazz, FinalClassArgumentCreator<T> creator)` Register a custom argument creator factory for an unknown final class
`static <T> List<T>`	`select(Iterable<T> iterable, org.hamcrest.Matcher<?> matcher)` Selects all the objects in the given iterable that match the given hamcrest Matcher
`static <T> List<T>`	`select(Iterator<T> iterator, org.hamcrest.Matcher<?> matcher)` Selects all the objects in the given iterator that match the given hamcrest Matcher
`static <T> List<T>`	`select(Object iterable, org.hamcrest.Matcher<?> matcher)` Selects all the objects in the given iterable that match the given hamcrest Matcher Actually it handles also Maps, Arrays and Iterator by collecting their values.
`static <T> Collection<T>`	`selectDistinct(Iterable<T> iterable)` Filters away all the duplicated items in the given iterable.
`static <T> Collection<T>`	`selectDistinct(Object iterable)` Filters away all the duplicated items in the given iterable.
`static <T> Collection<T>`	`selectDistinct(Object iterable, Comparator<T> comparator)` Filters away all the duplicated items in the given iterable based on the given comparator.
`static <T> Collection<T>`	`selectDistinct(Object iterable, String propertyName)` Selects all the items in the given iterable having a different value in the named property.
`static <T,A> Collection<T>`	`selectDistinctArgument(Object iterable, A argument)` Selects all the items in the given iterable having a different value on the given argument defined using the on method.
`static <T> T`	`selectFirst(Object iterable, org.hamcrest.Matcher<?> matcher)` Selects the first object in the given iterable that matches the given hamcrest Matcher Actually it handles also Maps, Arrays and Iterator by collecting their values.
`static <T> Iterator<T>`	`selectIterator(Object iterable, org.hamcrest.Matcher<?> matcher)` Selects all the objects in the given iterable that match the given hamcrest Matcher Actually it handles also Maps, Arrays and Iterator by collecting their values.
`static <T,A> T`	`selectMax(Object iterable, A argument)` Selects the item in the given iterable having the highest value on the given argument defined using the on method.
`static <T,A> T`	`selectMin(Object iterable, A argument)` Selects the item in the given iterable having the lowest value on the given argument defined using the on method.
`static <T> T`	`selectUnique(Object iterable, org.hamcrest.Matcher<?> matcher)` Selects the unique object in the given iterable that matches the given hamcrest Matcher Actually it handles also Maps, Arrays and Iterator by collecting their values.
`static <T,A> List<T>`	`sort(Object iterable, A argument, Comparator<A> comparator)` Sorts all the items in the given iterable on the respective values of the given argument comparing them with the given comparator.
`static <T> List<T>`	`sort(Object iterable, Object argument)` Sorts all the items in the given iterable on the respective values of the given argument.
`static <T> List<T>`	`sort(Object iterable, Object argument, int option)` Sorts all the items in the given iterable on the respective values of the given argument.
`static Number`	`sum(Object iterable)` Sums the items in the given iterable of Numbers or the iterable itself if it actually is already a single number.
`static <T> T`	`sum(Object iterable, T argument)` Sums the property values of the items in the given iterable defined by the given argument.
`static <T> T`	`sumFrom(Iterable<T> iterable)` Returns a lambda function defined as: sumFrom : (+, iterable) => lambda : (convert : object => number) => number It is then possibly to curry this function by selecting the convert function that defines of each item must be converted in a number.
`static <T> T`	`sumFrom(Iterable<T> iterable, Class<?> clazz)` Returns a lambda function defined as: sumFrom : (+, iterable) => lambda : (convert : object => number) => number It is then possibly to curry this function by selecting the convert function that defines of each item must be converted in a number.
`static <T> T`	`var(Class<T> clazz)` Defines a free variable of the given Class for the currently active closure

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

- Field Detail
  - DESCENDING
```
public static final int DESCENDING
```
    See Also:
    Constant Field Values
  - IGNORE_CASE
```
public static final int IGNORE_CASE
```
    See Also:
    Constant Field Values
- Method Detail
  - enableJitting
```
public static void enableJitting(boolean enable)
```
    Enable or disable the JIT optimization of lambdaj's arguments. Disabled by default
    
    Parameters:
    enable - True to enable the JIT optimization, false to disable it
  - registerFinalClassArgumentCreator
```
public static <T> void registerFinalClassArgumentCreator(Class<T> clazz,
                                         FinalClassArgumentCreator<T> creator)
```
    Register a custom argument creator factory for an unknown final class
    
    Type Parameters:
    T -
    Parameters:
    clazz - The class for which this factory should be used
    creator - The argument factory
  - on
```
public static <T> T on(Class<T> clazz)
```
    Constructs a proxy object that mocks the given Class registering all the subsequent invocations on the object.
    
    Parameters:
    clazz - The class of the object to be mocked
    
    Returns:
    An object of the given class that register all the invocations made on it
  - argument
```
public static <T> Argument<T> argument(T argumentPlaceholder)
```
    Returns the actual argument of the methods invocation sequence defined through the on(Class) method.
    
    Parameters:
    argumentPlaceholder - The placeholder for this argument created using the on(Class) method
    
    Returns:
    The actual argument of the methods invocation sequence defined through the on(Class) method
  - forEach
```
public static <T> T forEach(Iterable<? extends T> iterable)
```
    Transforms a collection of Ts in a single object having the same methods of a single instance of T. That allows to invoke a method on each T in the collection with a single strong typed method call as in the following example:
```
                List<Person> personInFamily = asList(new Person("Domenico"), new Person("Mario"), new Person("Irma"));
                forEach(personInFamily).setLastName("Fusco");
 
```
    The actual class of T is inferred from the class of the first iterable's item, but you can specify a particular class by using the overloaded method.
    Type Parameters:
    T - The type of the items in the iterable
    Parameters:
    iterable - The iterable to be transformed
    
    Returns:
    An object that proxies all the item in the iterable or null if the iterable is null or empty
    
    Throws:
    
    IllegalArgumentException - if the iterable is null or empty
  - forEach
```
public static <T> T forEach(Iterator<? extends T> iterator)
```
    Transforms a collection of Ts in a single object having the same methods of a single instance of T. That allows to invoke a method on each T in the collection with a single strong typed method call. The actual class of T is inferred from the class of the first iterable's item, but you can specify a particular class by using the overloaded method.
    
    Type Parameters:
    T - The type of the items in the iterable
    Parameters:
    iterator - The iterator to be transformed
    
    Returns:
    An object that proxies all the item in the iterator or null if the iterator is null or empty
    
    Throws:
    
    IllegalArgumentException - if the iterable is null or empty
  - forEach
```
public static <T> T forEach(Iterable<? extends T> iterable,
            Class<T> clazz)
```
    Transforms a collection of Ts in a single object having the same methods of a single instance of T. That allows to invoke a method on each T in the collection with a single strong typed method call as in the following example:
```
                List<Person> personInFamily = asList(new Person("Domenico"), new Person("Mario"), new Person("Irma"));
                forEach(personInFamily, Person.class).setLastName("Fusco");
 
```
    The given class represents the proxied by the returned object, so it should be a superclass of all the objects in the iterable. This overloaded version should be always used when it is not insured that the given iterable is null or empty.
    Type Parameters:
    T - The type of the items in the iterable
    Parameters:
    iterable - The iterable to be transformed
    clazz - The class proxied by the returned object
    
    Returns:
    An object that proxies all the item in the iterable. If the given iterable is null or empty it returns an instance of T that actually proxies an empty Iterable of Ts
  - forEach
```
public static <T> T forEach(Iterator<? extends T> iterator,
            Class<T> clazz)
```
    Transforms an iterator of Ts in a single object having the same methods of a single instance of T. That allows to invoke a method on each T in the iterator with a single strong typed method call. The actual class of T is inferred from the class of the first iterable's item, but you can specify a particular class by using the overloaded method.
    
    Type Parameters:
    T - The type of the items in the iterator
    Parameters:
    iterator - The iterator to be transformed
    clazz - The class proxied by the returned object
    
    Returns:
    An object that proxies all the item in the iterator or null if the iterator is null or empty
    
    Throws:
    
    IllegalArgumentException - if the iterator is null or empty
  - forEach
```
public static <T> T forEach(T... array)
```
    Transforms an array of Ts in a single object having the same methods of a single instance of T. That allows to invoke a method on each T in the array with a single strong typed method call.
    
    Type Parameters:
    T - The type of the items in the array
    Parameters:
    array - The array to be transformed
    
    Returns:
    An object that proxies all the item in the array
  - forEach
```
public static <T> T forEach(Class<T> clazz,
            T... array)
```
    Transforms an array of Ts in a single object having the same methods of a single instance of T. That allows to invoke a method on each T in the array with a single strong typed method call.
    
    Type Parameters:
    T - The type of the items in the array
    Parameters:
    clazz - The class proxied by the returned object
    array - The array to be transformed
    
    Returns:
    An object that proxies all the item in the array
  - flatten
```
public static <T> List<T> flatten(Object iterable)
```
    Flattens the given iterable by recursively descending through its nested Collections and create a flat List of all of the leaves. This method also works with Maps (by collecting their values) and arrays.
    
    Parameters:
    iterable - The iterable to be flattened
    
    Returns:
    The flattened iterable
  - collect
```
public static <T> List<? extends T> collect(Object iterable)
```
    Collects the items in the given iterable putting them in a List. Actually it handles also Maps, Arrays and Iterator by collecting their values. Note that this method accepts an Object in order to be used in conjunction with the forEach(Iterable).
    
    Parameters:
    iterable - The iterable of which the items should be collected
    
    Returns:
    A List containing all the items collected from the give iterable
    
    Throws:
    
    IllegalArgumentException - if the iterable is not an Iterable or a Map
  - collect
```
public static <T> List<T> collect(Object iterable,
                  T argument)
```
    For each item in the given iterable collects the value defined by the given argument and put them in a List. For example the following code:
```
                List<Person> myFriends = asList(new Person("Biagio", 39), new Person("Luca", 29), new Person("Celestino", 29));
                List<Integer> ages = collect(meAndMyFriends, on(Person.class).getAge());
 
```
    extracts the ages of all the Persons in the list and put them in a List of Integer.
    Actually it handles also Maps, Arrays and Iterator by collecting their values. Note that this method accepts an Object in order to be used in conjunction with the forEach(Iterable).
    Parameters:
    iterable - The iterable of which the items should be collected
    argument - An argument defined using the on(Class) method
    
    Returns:
    A List containing all the items collected from the give iterable
    
    Throws:
    
    RuntimeException - if the iterable is not an Iterable or a Map
  - sort
```
public static <T> List<T> sort(Object iterable,
               Object argument)
```
    Sorts all the items in the given iterable on the respective values of the given argument. Actually it handles also Maps, Arrays and Iterator by collecting their values. Note that this method accepts an Object in order to be used in conjunction with the forEach(Iterable).
    
    Parameters:
    iterable - The iterable of objects to be sorted
    argument - An argument defined using the on(Class) method
    
    Returns:
    A List with the same items of the given iterable sorted on the respective value of the given argument
  - sort
```
public static <T> List<T> sort(Object iterable,
               Object argument,
               int option)
```
    Sorts all the items in the given iterable on the respective values of the given argument. Actually it handles also Maps, Arrays and Iterator by collecting their values. Note that this method accepts an Object in order to be used in conjunction with the forEach(Iterable).
    
    Parameters:
    iterable - The iterable of objects to be sorted
    argument - An argument defined using the on(Class) method
    option - Sorting option e.g.: DESCENDING + IGNORE_CASE
    
    Returns:
    A List with the same items of the given iterable sorted on the respective value of the given argument
  - sort
```
public static <T,A> List<T> sort(Object iterable,
                 A argument,
                 Comparator<A> comparator)
```
    Sorts all the items in the given iterable on the respective values of the given argument comparing them with the given comparator. Actually it handles also Maps, Arrays and Iterator by collecting their values. Note that this method accepts an Object in order to be used in conjunction with the forEach(Iterable).
    
    Parameters:
    iterable - The iterable of objects to be sorted
    argument - An argument defined using the on(Class) method
    comparator - The comparator to determine the order of the list. A null value indicates that the elements' natural ordering should be used
    
    Returns:
    A List with the same items of the given iterable sorted on the respective value of the given argument
  - count
```
public static <T> Map<T,Integer> count(Object iterable)
```
    Counts the number of occurrencies of the objects in the given iterable Actually it handles also Maps, Arrays and Iterator by collecting their values. Note that this method accepts an Object in order to be used in conjunction with the forEach(Iterable).
    
    Parameters:
    iterable - The iterable of objects to be counted
    
    Returns:
    A map having as values the number of occurrencies of the corresponding key in the given iterable
  - count
```
public static <A> Map<A,Integer> count(Object iterable,
                       A argument)
```
    Counts the number of occurrencies of the argument's value in the objects of the given iterable Actually it handles also Maps, Arrays and Iterator by collecting their values. Note that this method accepts an Object in order to be used in conjunction with the forEach(Iterable).
    
    Parameters:
    iterable - The iterable of objects' arguments to be counted
    argument - An argument defined using the on(Class) method
    
    Returns:
    A map having as values the number of occurrencies of the corresponding object's argument in the given iterable
  - filter
```
public static <T> List<T> filter(org.hamcrest.Matcher<?> matcher,
                 Iterable<T> iterable)
```
    Filters all the objects in the given iterable that match the given hamcrest Matcher
    
    Parameters:
    matcher - The hamcrest Matcher used to filter the given iterable
    iterable - The iterable of objects to be filtered
    
    Returns:
    A sublist of the given iterable containing all the objects that match the given hamcrest Matcher
  - filter
```
public static <T> List<T> filter(org.hamcrest.Matcher<?> matcher,
                 T... array)
```
    Filters all the objects in the given array that match the given hamcrest Matcher
    
    Parameters:
    matcher - The hamcrest Matcher used to filter the given array
    array - The array of objects to be filtered
    
    Returns:
    A sublist of the given array containing all the objects that match the given hamcrest Matcher
  - select
```
public static <T> List<T> select(Iterator<T> iterator,
                 org.hamcrest.Matcher<?> matcher)
```
    Selects all the objects in the given iterator that match the given hamcrest Matcher
    
    Parameters:
    iterator - The iterator of objects to be filtered
    matcher - The hamcrest Matcher used to filter the given iterable
    
    Returns:
    A sublist of the given iterable containing all the objects that match the given hamcrest Matcher
  - select
```
public static <T> List<T> select(Iterable<T> iterable,
                 org.hamcrest.Matcher<?> matcher)
```
    Selects all the objects in the given iterable that match the given hamcrest Matcher
    
    Parameters:
    iterable - The iterable of objects to be filtered
    matcher - The hamcrest Matcher used to filter the given iterable
    
    Returns:
    A sublist of the given iterable containing all the objects that match the given hamcrest Matcher
  - select
```
public static <T> List<T> select(Object iterable,
                 org.hamcrest.Matcher<?> matcher)
```
    Selects all the objects in the given iterable that match the given hamcrest Matcher Actually it handles also Maps, Arrays and Iterator by collecting their values. Note that this method accepts an Object in order to be used in conjunction with the forEach(Iterable).
    
    Parameters:
    iterable - The iterable of objects to be filtered
    matcher - The hamcrest Matcher used to filter the given iterable
    
    Returns:
    A sublist of the given iterable containing all the objects that match the given hamcrest Matcher
  - selectIterator
```
public static <T> Iterator<T> selectIterator(Object iterable,
                             org.hamcrest.Matcher<?> matcher)
```
    Selects all the objects in the given iterable that match the given hamcrest Matcher Actually it handles also Maps, Arrays and Iterator by collecting their values. Note that this method accepts an Object in order to be used in conjunction with the forEach(Iterable). Unlike the method select(Iterable, Matcher) this one doesn't build a new collection, and the selection is done while iterating the returned iterator.
    
    Parameters:
    iterable - The iterable of objects to be filtered
    matcher - The hamcrest Matcher used to filter the given iterable
    
    Returns:
    An iterator containing all the objects in the given iterable converted using the given Converter
  - selectUnique
```
public static <T> T selectUnique(Object iterable,
                 org.hamcrest.Matcher<?> matcher)
```
    Selects the unique object in the given iterable that matches the given hamcrest Matcher Actually it handles also Maps, Arrays and Iterator by collecting their values. Note that this method accepts an Object in order to be used in conjunction with the forEach(Iterable).
    
    Parameters:
    iterable - The iterable of objects to be filtered
    matcher - The hamcrest Matcher used to filter the given iterable
    
    Returns:
    The only object in the given iterable that matches the given hamcrest Matcher or null if there is no such object
    
    Throws:
    
    NotUniqueItemException - if there is more than one object that matches the given hamcrest Matcher
  - exists
```
public static boolean exists(Object iterable,
             org.hamcrest.Matcher<?> matcher)
```
    Returns true if the given iterable contains at least an item that matches the given hamcrest Matcher Actually it handles also Maps, Arrays and Iterator by collecting their values. Note that this method accepts an Object in order to be used in conjunction with the forEach(Iterable).
    
    Parameters:
    iterable - The iterable of objects to be filtered
    matcher - The hamcrest Matcher used to filter the given iterable
    
    Returns:
    True if the given iterable contains at least an item that matches the given hamcrest Matcher false otherwise
  - selectFirst
```
public static <T> T selectFirst(Object iterable,
                org.hamcrest.Matcher<?> matcher)
```
    Selects the first object in the given iterable that matches the given hamcrest Matcher Actually it handles also Maps, Arrays and Iterator by collecting their values. Note that this method accepts an Object in order to be used in conjunction with the forEach(Iterable).
    
    Parameters:
    iterable - The iterable of objects to be filtered
    matcher - The hamcrest Matcher used to filter the given iterable
    
    Returns:
    The first object in the given iterable that matches the given hamcrest Matcher or null if there is no such object
  - selectDistinct
```
public static <T> Collection<T> selectDistinct(Iterable<T> iterable)
```
    Filters away all the duplicated items in the given iterable.
    
    Parameters:
    iterable - The iterable of objects to be filtered
    
    Returns:
    A Collection with the same items of the given iterable but containing no duplicate elements
  - selectDistinct
```
public static <T> Collection<T> selectDistinct(Object iterable)
```
    Filters away all the duplicated items in the given iterable. Note that this method accepts an Object in order to be used in conjunction with the forEach(Iterable).
    
    Parameters:
    iterable - The iterable of objects to be filtered
    
    Returns:
    A Collection with the same items of the given iterable but containing no duplicate elements
  - selectDistinct
```
public static <T> Collection<T> selectDistinct(Object iterable,
                               String propertyName)
```
    Selects all the items in the given iterable having a different value in the named property. Note that this method accepts an Object in order to be used in conjunction with the forEach(Iterable).
    
    Parameters:
    iterable - The iterable of objects to be filtered
    propertyName - The name of the item's property on which the item must have no duplicated value
    
    Returns:
    A Collection with the same items of the given iterable but containing no duplicate values on the named property
  - selectDistinctArgument
```
public static <T,A> Collection<T> selectDistinctArgument(Object iterable,
                                         A argument)
```
    Selects all the items in the given iterable having a different value on the given argument defined using the on method. Note that this method accepts an Object in order to be used in conjunction with the forEach(Iterable).
    
    Parameters:
    iterable - The iterable of objects to be filtered
    argument - An argument defined using the on(Class) method
    
    Returns:
    A Collection with the same items of the given iterable but containing no duplicate values on the given argument
  - selectDistinct
```
public static <T> Collection<T> selectDistinct(Object iterable,
                               Comparator<T> comparator)
```
    Filters away all the duplicated items in the given iterable based on the given comparator. Actually it handles also Maps, Arrays and Iterator by collecting their values. Note that this method accepts an Object in order to be used in conjunction with the forEach(Iterable).
    
    Parameters:
    iterable - The iterable of objects to be filtered
    comparator - The comparator used to decide if 2 items are different or not
    
    Returns:
    A Collection with the same items of the given iterable but containing no duplicate elements
  - selectMin
```
public static <T,A> T selectMin(Object iterable,
                A argument)
```
    Selects the item in the given iterable having the lowest value on the given argument defined using the on method. Actually it handles also Maps, Arrays and Iterator by collecting their values. Note that this method accepts an Object in order to be used in conjunction with the forEach(Iterable).
    
    Parameters:
    iterable - The iterable of objects to be filtered
    argument - An argument defined using the on(Class) method
    
    Returns:
    The item in the given iterable with the minimum value on the given argument
  - selectMax
```
public static <T,A> T selectMax(Object iterable,
                A argument)
```
    Selects the item in the given iterable having the highest value on the given argument defined using the on method. Actually it handles also Maps, Arrays and Iterator by collecting their values. Note that this method accepts an Object in order to be used in conjunction with the forEach(Iterable).
    
    Parameters:
    iterable - The iterable of objects to be filtered
    argument - An argument defined using the on(Class) method
    
    Returns:
    The item in the given iterable with the maximum value on the given argument
  - aggregate
```
public static <T> T aggregate(Object iterable,
              Aggregator<T> aggregator)
```
    Aggregates the items in the given iterable using the given Aggregator. Actually it handles also Maps, Arrays and Iterator by collecting their values. Note that this method accepts an Object in order to be used in conjunction with the forEach(Iterable).
    
    Parameters:
    iterable - The iterable of numbers to be summed
    aggregator - The function that defines how the objects in this iterable have to be aggregated
    
    Returns:
    The result of the aggregation of all the items in the given iterable
    
    Throws:
    
    RuntimeException - if the iterable is not an Iterable
  - aggregate
```
public static <T,A> T aggregate(Object iterable,
                Aggregator<T> aggregator,
                A argument)
```
    For each item in the given iterable collects the value defined by the given argument and then aggregates them iterable using the given Aggregator. Actually it handles also Maps, Arrays and Iterator by collecting their values. Note that this method accepts an Object in order to be used in conjunction with the forEach(Iterable).
    
    Parameters:
    iterable - The iterable of numbers to be summed
    aggregator - The function that defines how the objects in this iterable have to be aggregated
    argument - An argument defined using the on(Class) method
    
    Returns:
    The result of the aggregation of all the items in the given iterable
    
    Throws:
    
    RuntimeException - if the iterable is not an Iterable
  - aggregateFrom
```
public static <T,A> T aggregateFrom(Iterable<T> iterable,
                    Aggregator<A> aggregator)
```
    Returns a lambda function defined as:
    aggregateFrom : (aggregator, iterable) => lambda : (convert : object => object) => object
    It is then possibly to curry this function by selecting the convert function that defines how each item must be converted in the object to be aggregated. This is done by invoking on that returned object the method that returns the values of the property to be aggregated.
    
    Parameters:
    iterable - The iterable of the objects to containing the property to be aggregated.
    aggregator - The function that defines how the objects in this iterable have to be aggregated
    
    Returns:
    A proxy of the class of the first object in the iterable representing an aggregation lambda function
    
    Throws:
    
    IllegalArgumentException - if the iterable is null or empty
  - aggregateFrom
```
public static <T,A> T aggregateFrom(Iterable<T> iterable,
                    Class<?> clazz,
                    Aggregator<A> aggregator)
```
    Returns a lambda function defined as:
    aggregateFrom : (aggregator, iterable) => lambda : (convert : object => object) => object
    It is then possibly to curry this function by selecting the convert function that defines how each item must be converted in the object to be aggregated. This is done by invoking on that returned object the method that returns the values of the property to be aggregated. This overloaded version should be always used when it is not insured that the given iterable is null or empty.
    
    Parameters:
    iterable - The iterable of the objects to containing the property to be aggregated.
    clazz - The class proxied by the returned object
    aggregator - The function that defines how the objects in this iterable have to be aggregated
    
    Returns:
    A proxy of the class of the first object in the iterable representing an aggregation lambda function
  - sum
```
public static Number sum(Object iterable)
```
    Sums the items in the given iterable of Numbers or the iterable itself if it actually is already a single number. Actually it handles also Maps, Arrays and Iterator by collecting their values. Note that this method accepts an Object in order to be used in conjunction with the forEach(Iterable).
    
    Parameters:
    iterable - The iterable of numbers to be summed
    
    Returns:
    The sum of all the Number in the given iterable or the iterable itself if it actually is already a single number
    
    Throws:
    
    IllegalArgumentException - if the iterable is not neither an Iterable nor a Number
  - sum
```
public static <T> T sum(Object iterable,
        T argument)
```
    Sums the property values of the items in the given iterable defined by the given argument. Actually it handles also Maps, Arrays and Iterator by collecting their values. Note that this method accepts an Object in order to be used in conjunction with the forEach(Iterable).
    
    Parameters:
    iterable - The iterable of items containing the property of which the values have to be summed.
    argument - An argument defined using the on(Class) method
    
    Returns:
    The sum of the property values extracted from all the items in the given iterable
    
    Throws:
    
    IllegalArgumentException - if the iterable is not an Iterable
  - sumFrom
```
public static <T> T sumFrom(Iterable<T> iterable)
```
    Returns a lambda function defined as:
    sumFrom : (+, iterable) => lambda : (convert : object => number) => number
    It is then possibly to curry this function by selecting the convert function that defines of each item must be converted in a number. This is done by invoking on that returned object the method that returns the values of the property to be summed as in the following example
    int totalAge = sumFrom(persons).getAge();
    The actual class of T is inferred from the class of the first iterable's item, but you can specify a particular class by using the overloaded method.
    
    Parameters:
    iterable - The iterable of the objects to containing the property to be summed.
    
    Returns:
    A proxy of the class of the first object in the iterable representing a sum lambda function
    
    Throws:
    
    IllegalArgumentException - if the iterable is null or empty
  - sumFrom
```
public static <T> T sumFrom(Iterable<T> iterable,
            Class<?> clazz)
```
    Returns a lambda function defined as:
    sumFrom : (+, iterable) => lambda : (convert : object => number) => number
    It is then possibly to curry this function by selecting the convert function that defines of each item must be converted in a number. This is done by invoking on that returned object the method that returns the values of the property to be summed as in the following example
    int totalAge = sumFrom(persons, Person.class).getAge();
    This overloaded version should be always used when it is not insured that the given iterable is null or empty.
    
    Parameters:
    iterable - The iterable of the objects to containing the property to be summed.
    clazz - The class proxied by the returned object
    
    Returns:
    A proxy of the class of the first object in the iterable representing a sum lambda function
  - avg
```
public static Number avg(Object iterable)
```
    Calculates the average of the items in the given iterable of Numbers or the iterable itself if it actually is already a single number. Actually it handles also Maps, Arrays and Iterator by collecting their values. Note that this method accepts an Object in order to be used in conjunction with the forEach(Iterable).
    
    Parameters:
    iterable - The iterable of numbers to be summed
    
    Returns:
    The average of all the Number in the given iterable or the iterable itself if it actually is already a single number
    
    Throws:
    
    IllegalArgumentException - if the iterable is not neither an Iterable nor a Number
  - avg
```
public static <T> T avg(Object iterable,
        T argument)
```
    Calculates the average of the property values of the items in the given iterable defined by the given argument. Actually it handles also Maps, Arrays and Iterator by collecting their values. Note that this method accepts an Object in order to be used in conjunction with the forEach(Iterable).
    
    Parameters:
    iterable - The iterable of items containing the property for which the average of its the values has to be calculated.
    argument - An argument defined using the on(Class) method
    
    Returns:
    The average of the property values extracted from all the items in the given iterable
    
    Throws:
    
    IllegalArgumentException - if the iterable is not an Iterable
  - avgFrom
```
public static <T> T avgFrom(Iterable<T> iterable)
```
    Returns a lambda function defined as:
    avgFrom : (avg, iterable) => lambda : (convert : object => number) => number
    It is then possibly to curry this function by selecting the convert function that defines of each item must be converted in a number. This is done by invoking on that returned object the method that returns the values of the property fro which the average has to be calculated as in the following example
    int averageAge = avgFrom(persons).getAge();
    The actual class of T is inferred from the class of the first iterable's item, but you can specify a particular class by using the overloaded method.
    
    Parameters:
    iterable - The iterable of the objects to containing the property for which the average has to be calculated.
    
    Returns:
    A proxy of the class of the first object in the iterable representing a sum lambda function
    
    Throws:
    
    IllegalArgumentException - if the iterable is null or empty
  - avgFrom
```
public static <T> T avgFrom(Iterable<T> iterable,
            Class<?> clazz)
```
    Returns a lambda function defined as:
    avgFrom : (avg, iterable) => lambda : (convert : object => number) => number
    It is then possibly to curry this function by selecting the convert function that defines of each item must be converted in a number. This is done by invoking on that returned object the method that returns the values of the property fro which the average has to be calculated as in the following example
    int averageAge = avgFrom(persons, Person.class).getAge();
    This overloaded version should be always used when it is not insured that the given iterable is null or empty.
    
    Parameters:
    iterable - The iterable of the objects to containing the property for which the average has to be calculated.
    clazz - The class proxied by the returned object
    
    Returns:
    A proxy of the class of the first object in the iterable representing a sum lambda function
  - min
```
public static <T> T min(Object iterable)
```
    Finds the minimum item in the given iterable. Actually it handles also Maps, Arrays and Iterator by collecting their values. Note that this method accepts an Object in order to be used in conjunction with the forEach(Iterable).
    
    Parameters:
    iterable - The iterable of numbers to be summed
    
    Returns:
    The minimum of all the Object in the given iterable
    
    Throws:
    
    IllegalArgumentException - if the iterable is not an Iterable
  - min
```
public static <T> T min(Object iterable,
        T argument)
```
    Finds the minimum item in the given iterable defined by the given argument. Actually it handles also Maps, Arrays and Iterator by collecting their values. Note that this method accepts an Object in order to be used in conjunction with the forEach(Iterable).
    
    Parameters:
    iterable - The iterable of objects on which the minimum should be found
    argument - An argument defined using the on(Class) method
    
    Returns:
    The minimum of all the Object in the given iterable
    
    Throws:
    
    IllegalArgumentException - if the iterable is not an Iterable
  - minFrom
```
public static <T> T minFrom(Iterable<T> iterable)
```
    Returns a lambda function defined as:
    minFrom : (min, iterable) => lambda : (convert : object => object) => object
    It is then possibly to curry this function by selecting the convert function that defines how each item must be converted in the object of which a minimum value needs to be found. This is done by invoking on that returned object the method that returns the values of the property to be aggregated.
    int minAge = maxFrom(persons).getAge();
    The actual class of T is inferred from the class of the first iterable's item, but you can specify a particular class by using the overloaded method.
    
    Parameters:
    iterable - The iterable of objects on which the minimum should be found
    
    Returns:
    A proxy of the class of the first object in the iterable representing a min lambda function
    
    Throws:
    
    IllegalArgumentException - if the iterable is null or empty
  - minFrom
```
public static <T> T minFrom(Iterable<T> iterable,
            Class<?> clazz)
```
    Returns a lambda function defined as:
    minFrom : (min, iterable) => lambda : (convert : object => object) => object
    It is then possibly to curry this function by selecting the convert function that defines how each item must be converted in the object of which a minimum value needs to be found. This is done by invoking on that returned object the method that returns the values of the property to be aggregated.
    int minAge = minFrom(persons).getAge();
    This overloaded version should be always used when it is not insured that the given iterable is null or empty.
    
    Parameters:
    iterable - The iterable of the objects containing the property of which the minimum should be found.
    clazz - The class proxied by the returned object
    
    Returns:
    A proxy of the class of the first object in the iterable representing a min lambda function
  - max
```
public static <T> T max(Object iterable)
```
    Finds the maximum item in the given iterable. Actually it handles also Maps, Arrays and Iterator by collecting their values. Note that this method accepts an Object in order to be used in conjunction with the forEach(Iterable).
    
    Parameters:
    iterable - The iterable of objects on which the maximum should be found
    
    Returns:
    The maximum of all the Object in the given iterable
    
    Throws:
    
    IllegalArgumentException - if the iterable is not an Iterable
  - max
```
public static <T> T max(Object iterable,
        T argument)
```
    Finds the maximum item in the given iterable defined by the given argument. Actually it handles also Maps, Arrays and Iterator by collecting their values. Note that this method accepts an Object in order to be used in conjunction with the forEach(Iterable).
    
    Parameters:
    iterable - The iterable of objects on which the maximum should be found
    argument - An argument defined using the on(Class) method
    
    Returns:
    The maximum of all the Object in the given iterable
    
    Throws:
    
    IllegalArgumentException - if the iterable is not an Iterable
  - maxFrom
```
public static <T> T maxFrom(Iterable<T> iterable)
```
    Returns a lambda function defined as:
    maxFrom : (max, iterable) => lambda : (convert : object => object) => object
    It is then possibly to curry this function by selecting the convert function that defines how each item must be converted in the object of which a maximum value needs to be found. This is done by invoking on that returned object the method that returns the values of the property to be aggregated.
    int maxAge = maxFrom(persons).getAge();
    The actual class of T is inferred from the class of the first iterable's item, but you can specify a particular class by using the overloaded method.
    
    Parameters:
    iterable - The iterable of objects on which the maximum should be found
    
    Returns:
    A proxy of the class of the first object in the iterable representing a max lambda function
    
    Throws:
    
    IllegalArgumentException - if the iterable is null or empty
  - maxFrom
```
public static <T> T maxFrom(Iterable<T> iterable,
            Class<?> clazz)
```
    Returns a lambda function defined as:
    maxFrom : (max, iterable) => lambda : (convert : object => object) => object
    It is then possibly to curry this function by selecting the convert function that defines how each item must be converted in the object of which a maximum value needs to be found. This is done by invoking on that returned object the method that returns the values of the property to be aggregated.
    int maxAge = maxFrom(persons).getAge();
    This overloaded version should be always used when it is not insured that the given iterable is null or empty.
    
    Parameters:
    iterable - The iterable of the objects containing the property of which the maximum should be found.
    clazz - The class proxied by the returned object
    
    Returns:
    A proxy of the class of the first object in the iterable representing a max lambda function
  - joinFrom
```
public static <T> T joinFrom(Iterable<T> iterable)
```
    Returns a lambda function defined as:
    joinFrom : (concat, iterable) => lambda : (convert : object => object) => string
    It is then possibly to curry this function by selecting the convert function that defines of each item must be converted in a String. This is done by invoking on that returned object the method that returns the values of the property to be summed as in the following example
    String names = joinFrom(persons).getFirstName();
    The actual class of T is inferred from the class of the first iterable's item, but you can specify a particular class by using the overloaded method.
    
    Parameters:
    iterable - The iterable of the objects to containing the property to be joined.
    
    Returns:
    A proxy of the class of the first object in the iterable representing a join lambda function
    
    Throws:
    
    IllegalArgumentException - if the iterable is null or empty
  - joinFrom
```
public static <T> T joinFrom(Iterable<T> iterable,
             String separator)
```
    Returns a lambda function defined as:
    joinFrom : (concat, iterable) => lambda : (convert : object => object) => string
    It is then possibly to curry this function by selecting the convert function that defines of each item must be converted in a String. This is done by invoking on that returned object the method that returns the values of the property to be summed as in the following example
    String names = joinFrom(persons, " - ").getFirstName();
    The actual class of T is inferred from the class of the first iterable's item, but you can specify a particular class by using the overloaded method.
    
    Parameters:
    iterable - The iterable of the objects to containing the property to be joined.
    separator - The String used to separe the Strings produced by this lambda function
    
    Returns:
    A proxy of the class of the first object in the iterable representing a join lambda function
    
    Throws:
    
    IllegalArgumentException - if the iterable is null or empty
  - joinFrom
```
public static <T> T joinFrom(Iterable<T> iterable,
             Class<?> clazz)
```
    Returns a lambda function defined as:
    joinFrom : (concat, iterable) => lambda : (convert : object => object) => string
    It is then possibly to curry this function by selecting the convert function that defines of each item must be converted in a String. This is done by invoking on that returned object the method that returns the values of the property to be summed as in the following example
    String names = joinFrom(persons, Person.class).getFirstName();
    The actual class of T is inferred from the class of the first iterable's item, but you can specify a particular class by using the overloaded method. This overloaded version should be always used when it is not insured that the given iterable is null or empty.
    
    Parameters:
    iterable - The iterable of the objects to containing the property to be joined.
    clazz - The class proxied by the returned object
    
    Returns:
    A proxy of the class of the first object in the iterable representing a join lambda function
  - joinFrom
```
public static <T> T joinFrom(Iterable<T> iterable,
             Class<?> clazz,
             String separator)
```
    Returns a lambda function defined as:
    joinFrom : (concat, iterable) => lambda : (convert : object => object) => string
    It is then possibly to curry this function by selecting the convert function that defines of each item must be converted in a String. This is done by invoking on that returned object the method that returns the values of the property to be summed as in the following example
    String names = joinFrom(persons, Person.class, " - ").getFirstName();
    The actual class of T is inferred from the class of the first iterable's item, but you can specify a particular class by using the overloaded method. This overloaded version should be always used when it is not insured that the given iterable is null or empty.
    
    Parameters:
    iterable - The iterable of the objects to containing the property to be joined.
    clazz - The class proxied by the returned object
    separator - The String used to separe the Strings produced by this lambda function
    
    Returns:
    A proxy of the class of the first object in the iterable representing a join lambda function
  - join
```
public static String join(Object iterable)
```
    Joins all the object in the given iterable by concatenating all their String representation. It invokes toString() an all the objects and concatening them using the default separator ", ". Actually it handles also Maps, Arrays and Iterator by collecting their values. Note that this method accepts an Object in order to be used in conjunction with the forEach(Iterable).
    
    Parameters:
    iterable - The iterable containing the objects to be joined
    
    Returns:
    The concatenation of the String representation of all the objects in the given iterable or an empty String if the iterable is null or empty
  - join
```
public static String join(Object iterable,
          String separator)
```
    Joins all the object in the given iterable by concatenating all their String representation. It invokes toString() an all the objects and concatening them using the given separator. Actually it handles also Maps, Arrays and Iterator by collecting their values. Note that this method accepts an Object in order to be used in conjunction with the forEach(Iterable).
    
    Parameters:
    iterable - The iterable containing the objects to be joined
    separator - The String used to separe the item's String representation
    
    Returns:
    The concatenation of the String representation of all the objects in the given iterable or an empty String if the iterable is null or empty
  - convert
```
public static <F,T> List<T> convert(Object iterable,
                    Converter<F,T> converter)
```
    Converts all the object in the iterable using the given Converter. Actually it handles also Maps, Arrays and Iterator by collecting their values. Note that this method accepts an Object in order to be used in conjunction with the forEach(Iterable).
    
    Parameters:
    iterable - The iterable containing the objects to be converted
    converter - The converter that specifies how each object in the iterable must be converted
    
    Returns:
    A list containing all the objects in the given iterable converted using the given Converter
  - convertIterator
```
public static <F,T> Iterator<T> convertIterator(Object iterable,
                                Converter<F,T> converter)
```
    Converts all the object in the iterable using the given Converter. Actually it handles also Maps, Arrays and Iterator by collecting their values. Note that this method accepts an Object in order to be used in conjunction with the forEach(Iterable).
    
    Parameters:
    iterable - The iterable containing the objects to be converted
    converter - The converter that specifies how each object in the iterable must be converted
    
    Returns:
    An Iterator on all the objects in the given iterable converted using the given Converter
  - convertMap
```
public static <K,F,T> Map<K,T> convertMap(Map<K,F> map,
                          Converter<F,T> converter)
```
    Converts all the values in the map using the given Converter.
    
    Parameters:
    map - The map containing the values to be converted
    converter - The converter that specifies how each map's value must be converted
    
    Returns:
    A Map containing the same keys of the original one and the value converted from the ones in the corresponding entry of the map
  - convertMap
```
public static <K,F,T> Map<K,T> convertMap(Map<K,F> map,
                          T argument)
```
    Converts all the values in the map extracting the property defined by the given argument.
    
    Parameters:
    map - The map containing the values to be converted
    argument - An argument defined using the on(Class) method
    
    Returns:
    A Map containing the same keys of the original one and the argument's value extracted from the value in the corresponding entry of the map
  - extract
```
public static <F,T> List<T> extract(Object iterable,
                    T argument)
```
    Converts all the object in the iterable extracting the property defined by the given argument. Actually it handles also Maps, Arrays and Iterator by collecting their values. Note that this method accepts an Object in order to be used in conjunction with the forEach(Iterable).
    
    Parameters:
    iterable - The iterable containing the objects to be converted
    argument - An argument defined using the on(Class) method
    
    Returns:
    A list containing the argument's value extracted from the object in the given iterable
  - extractIterator
```
public static <F,T> Iterator<T> extractIterator(Object iterable,
                                T argument)
```
    Converts all the object in the iterable extracting the property defined by the given argument. Actually it handles also Maps, Arrays and Iterator by collecting their values. Unlike the method extract(Object, Object) this one doesn't build a new collection, and the extraction is done only when someone iterates over the returned iterator. Note that this method accepts an Object in order to be used in conjunction with the forEach(Iterable).
    
    Parameters:
    iterable - The iterable containing the objects to be converted
    argument - An argument defined using the on(Class) method
    
    Returns:
    A list containing the argument's value extracted from the object in the given iterable
  - extractString
```
public static List<String> extractString(Object iterable)
```
    Converts all the object in the iterable in its String representation. Actually it handles also Maps, Arrays and Iterator by collecting their values. Note that this method accepts an Object in order to be used in conjunction with the forEach(Iterable).
    
    Parameters:
    iterable - The iterable containing the objects to be converted in strings
    
    Returns:
    A list containing the String representation of the objects in the given iterable
  - extractProperty
```
public static <F,T> List<T> extractProperty(Object iterable,
                            String propertyName)
```
    Converts all the object in the iterable extracting the named property. Actually it handles also Maps, Arrays and Iterator by collecting their values. Note that this method accepts an Object in order to be used in conjunction with the forEach(Iterable).
    
    Parameters:
    iterable - The iterable containing the objects to be converted
    propertyName - The name of the item's property on which the item must have no duplicated value
    
    Returns:
    A list containing the property's value extracted from the object in the given iterable
  - map
```
public static <F,T> Map<T,F> map(Object iterable,
                 Converter<F,T> converter)
```
    Maps the objects in the given iterable on the value extracted using the given Converter. Actually it handles also Maps, Arrays and Iterator by collecting their values. Note that this method accepts an Object in order to be used in conjunction with the forEach(Iterable).
    
    Parameters:
    iterable - The iterable containing the objects to be mapped
    converter - The converter that specifies the key on which each object should be mapped
    
    Returns:
    A map having as keys the argument value extracted from the objects in the given iterable and as values the corresponding objects
  - index
```
public static <F,T> Map<T,F> index(Object iterable,
                   T argument)
```
    Indexes the objects in the given iterable based on the value of their argument. Actually it handles also Maps, Arrays and Iterator by collecting their values. Note that this method accepts an Object in order to be used in conjunction with the forEach(Iterable).
    
    Parameters:
    iterable - The iterable containing the objects to be indexed
    argument - An argument defined using the on(Class) method
    
    Returns:
    A map having as keys the argument value extracted from the objects in the given iterable and as values the corresponding objects
  - project
```
public static <T> List<T> project(Object iterable,
                  Class<T> targetClass,
                  Object... arguments)
```
    Converts the objects in the given iterable in objects of the given target Class. The objects are created by invoking its constructor passing to it the values taken from the object to be converted using the given arguments. Actually it handles also Maps, Arrays and Iterator by collecting their values. Note that this method accepts an Object in order to be used in conjunction with the forEach(Iterable).
    
    Parameters:
    iterable - The iterable containing the objects to be projected
    targetClass - The class in which the objects in the given iterable must be converted
    arguments - The arguments of the objects to be converted that will be used to create the objects of the target class
    
    Returns:
    A list of map where each map is the result of the projection of an object in the iterable
  - project
```
public static <F> List<Map<String,Object>> project(Object iterable,
                                   Converter<F,Map.Entry<String,Object>>... projectors)
```
    Projects the objects in the given iterable by converting each of them in a set of key/value pairs. Actually it handles also Maps, Arrays and Iterator by collecting their values. Note that this method accepts an Object in order to be used in conjunction with the forEach(Iterable).
    
    Parameters:
    iterable - The iterable containing the objects to be projected
    projectors - The converters that define how each object should be projected
    
    Returns:
    A list of map where each map is the result of the projection of an object in the iterable
  - as
```
public static <F> Converter<F,Map.Entry<String,Object>> as(Object argument)
```
    Creates a converter that projects the value of the argument of an object using as alias the argument property name as defined by Argument.getInkvokedPropertyName()
    
    Parameters:
    argument - An argument defined using the on(Class) method
    
    Returns:
    A converter that can be used as projector in the project(Object, Converter[]) method
  - as
```
public static <F> Converter<F,Map.Entry<String,Object>> as(String alias,
                                           Object argument)
```
    Creates a converter that projects the value of the argument of an object using as the given alias
    
    Parameters:
    alias - The key on which the argument value is paired
    argument - An argument defined using the on(Class) method
    
    Returns:
    A converter that can be used as projector in the project(Object, Converter[]) method
  - having
```
public static <T> HasArgumentWithValue<T,Boolean> having(Boolean argument)
```
    Creates an hamcrest matcher that is evalued to true accordingly to the value of the passed argument
    
    Parameters:
    argument - The boolean argument defined using the on(Class) method that has to be matched
    
    Returns:
    The hamcrest matcher that is evalued to true accordingly to the value of the passed argument
  - having
```
public static <T,A> HasArgumentWithValue<T,A> having(A argument,
                                     org.hamcrest.Matcher<?> matcher)
```
    Creates an hamcrest matcher that is evalued to true if the value of the given argument satisfies the condition defined by the passed matcher.
    
    Parameters:
    argument - The argument defined using the on(Class) method that has to be matched
    matcher - The matcher against which the value of the given argument has to be compared
    
    Returns:
    The hamcrest matcher that is evalued to true if the value of the passed argument matches the given matcher
  - by
```
public static <T> ArgumentGroupCondition<T> by(T argument)
```
    Creates a GroupCondition that allows to group items based on the value they have on a given argument
    
    Parameters:
    argument - The argument defined using the on(Class) method on which the items have to be grouped
    
    Returns:
    A GroupCondition that can be used to group items through the Groups.group(Iterable, ch.lambdaj.group.GroupCondition[]) method
  - group
```
public static <T> Group<T> group(Iterable<T> iterable,
                 Collection<? extends GroupCondition<?>> conditions)
```
    Organizes the given list of items in (hierarchy of) groups based on the given grouping conditions
    
    Parameters:
    iterable - The items to be grouped
    conditions - The conditions that define how the items have to be grouped
    
    Returns:
    The items grouped by the given conditions
  - group
```
public static <T> Group<T> group(Iterable<T> iterable,
                 String... groupers)
```
    Organizes the given list of items in (hierarchy of) groups based on the values they have on the named JavaBean proprties
    
    Parameters:
    iterable - The items to be grouped
    groupers - The names of the properties on which the items have to be grouped
    
    Returns:
    The items grouped on the values of their JavaBean properties
  - group
```
public static <T> Group<T> group(Iterable<T> iterable,
                 GroupCondition<?>... conditions)
```
    Organizes the given list of items in (hierarchy of) groups based on the given grouping conditions
    
    Parameters:
    iterable - The items to be grouped
    conditions - The conditions that define how the items have to be grouped
    
    Returns:
    The items grouped by the given conditions
  - of
```
public static <T> T of(T closed)
```
    Binds an object to the active closure that is the last one created in the current thread.
    
    Parameters:
    closed - The object that has to be bound to the active closure
    
    Returns:
    A proxy of the same class of the passed object used to register all the invocation on the closed object
  - of
```
public static <T> T of(Class<T> closedClass)
```
    Binds a free variable of the given class to the active closure that is the last one created in the current thread.
    
    Parameters:
    closedClass - The type of the free variable to be bound to the active closure
    
    Returns:
    A proxy of the same class of the passed class used to register all the invocation on the closed object
  - of
```
public static <T> T of(T closed,
       Class<T> closedClass)
```
    Binds an object to the active closure that is the last one created in the current thread.
    
    Parameters:
    closed - The object that has to be bound to the active closure
    closedClass - The actual class of the proxied object
    
    Returns:
    An instance of the closedClass that is actually a proxy used to register all the invocation on the closed object
  - var
```
public static <T> T var(Class<T> clazz)
```
    Defines a free variable of the given Class for the currently active closure
    
    Parameters:
    clazz - The Class of the new argument
    
    Returns:
    A placeholder that represent a free closure variable of the given Class
  - closure
```
public static Closure closure()
```
    Creates a generic (not typed) closure and binds it to the current thread
    
    Returns:
    The newly created closure
  - closure
```
public static <A> Closure1<A> closure(Class<A> type1)
```
    Creates a closure with a single free variable and binds it to the current thread
    
    Parameters:
    type1 - The type of the free parameter of the newly created closure
    
    Returns:
    The newly created closure
  - closure
```
public static <A,B> Closure2<A,B> closure(Class<A> type1,
                          Class<B> type2)
```
    Creates a closure with two free variables and binds it to the current thread
    
    Parameters:
    type1 - The type of the first free variable of the newly created closure
    type2 - The type of the second free variable of the newly created closure
    
    Returns:
    The newly created closure
  - closure
```
public static <A,B,C> Closure3<A,B,C> closure(Class<A> type1,
                              Class<B> type2,
                              Class<C> type3)
```
    Creates a closure with three free variables and binds it to the current thread
    
    Parameters:
    type1 - The type of the first free variable of the newly created closure
    type2 - The type of the second free variable of the newly created closure
    type3 - The type of the third free variable of the newly created closure
    
    Returns:
    The newly created closure
  - closure
```
public static <A,B,C,D> Closure4<A,B,C,D> closure(Class<A> type1,
                                  Class<B> type2,
                                  Class<C> type3,
                                  Class<D> type4)
```
    Creates a closure with four free variables and binds it to the current thread
    
    Parameters:
    type1 - The type of the first free variable of the newly created closure
    type2 - The type of the second free variable of the newly created closure
    type3 - The type of the third free variable of the newly created closure
    type4 - The type of the fourth free variable of the newly created closure
    
    Returns:
    The newly created closure
  - delayedClosure
```
public static <T> ClosureResult<T> delayedClosure(DelayedClosure<T> delayedClosure)
```
    Returns the result of the invocation of the method that uses the given delayed closure
    
    Parameters:
    delayedClosure - The closure defined through the DelayedClosure syntax
    
    Returns:
    The result of the invocation of the method that uses the given delayed closure

Class Lambda

Field Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

DESCENDING

IGNORE_CASE

Method Detail

enableJitting

registerFinalClassArgumentCreator

on

argument

forEach

forEach

forEach

forEach

forEach

forEach

flatten

collect

collect

sort

sort

sort

count

count

filter

filter

select

select

select

selectIterator

selectUnique

exists

selectFirst

selectDistinct

selectDistinct

selectDistinct

selectDistinctArgument

selectDistinct

selectMin

selectMax

aggregate

aggregate

aggregateFrom

aggregateFrom

sum

sum

sumFrom

sumFrom

avg

avg

avgFrom

avgFrom

min

min

minFrom

minFrom

max

max

maxFrom

maxFrom

joinFrom

joinFrom

joinFrom

joinFrom

join

join

convert

convertIterator

convertMap

convertMap

extract

extractIterator

extractString

extractProperty

map

index

project

project