net.emaze.dysfunctional

Class Groups

java.lang.Object

net.emaze.dysfunctional.Groups

public abstract class Groups
extends Object

groupBy, partition, indexBy.

Author:

rferranti

Constructor Summary

Constructors

Constructor and Description
Groups()

Method Summary

Methods

Modifier and Type	Method and Description
static <K,V> Map<K,List<V>>	groupBy(Iterable<V> groupies, Delegate<K,V> grouper) Groups elements from an iterable in the key evaluated from the passed delegate.
static <C extends Collection<V>,K,V> Map<K,C>	groupBy(Iterable<V> groupies, Delegate<K,V> grouper, Provider<C> collectionProvider) Groups elements from an iterable in the key evaluated from the passed delegate.
static <M extends Map<K,C>,C extends Collection<V>,K,V> Map<K,C>	groupBy(Iterable<V> groupies, Delegate<K,V> grouper, Provider<C> collectionProvider, Provider<M> mapProvider) Groups elements from an iterable in the key evaluated from the passed delegate.
static <K,V> Map<K,List<V>>	groupBy(Iterator<V> groupies, Delegate<K,V> grouper) Groups elements from an iterator in the key evaluated from the passed delegate.
static <C extends Collection<V>,K,V> Map<K,C>	groupBy(Iterator<V> groupies, Delegate<K,V> grouper, Provider<C> collectionProvider) Groups elements from an iterator in the key evaluated from the passed delegate.
static <M extends Map<K,C>,C extends Collection<V>,K,V> Map<K,C>	groupBy(Iterator<V> groupies, Delegate<K,V> grouper, Provider<C> collectionProvider, Provider<M> mapProvider) Groups elements from an iterator in the key evaluated from the passed delegate.
static <K,V> Map<K,List<V>>	groupBy(V[] groupies, Delegate<K,V> grouper) Groups elements from an array in the key evaluated from the passed delegate.
static <C extends Collection<V>,K,V> Map<K,C>	groupBy(V[] groupies, Delegate<K,V> grouper, Provider<C> collectionProvider) Groups elements from an array in the key evaluated from the passed delegate.
static <M extends Map<K,C>,C extends Collection<V>,K,V> Map<K,C>	groupBy(V[] groupies, Delegate<K,V> grouper, Provider<C> collectionProvider, Provider<M> mapProvider) Groups elements from an array in the key evaluated from the passed delegate.
static <K,V> Map<K,V>	indexBy(Iterable<V> groupies, Delegate<K,V> indexer) Indexes elements from the iterable using passed delegate.
static <M extends Map<K,V>,K,V> Map<K,V>	indexBy(Iterable<V> groupies, Delegate<K,V> indexer, Provider<M> mapProvider) Indexes elements from the iterable using passed delegate.
static <K,V> Map<K,V>	indexBy(Iterator<V> groupies, Delegate<K,V> indexer) Indexes elements from the iterator using passed delegate.
static <M extends Map<K,V>,K,V> Map<K,V>	indexBy(Iterator<V> groupies, Delegate<K,V> indexer, Provider<M> mapProvider) Indexes elements from the iterator using passed delegate.
static <K,V> Map<K,V>	indexBy(V[] groupies, Delegate<K,V> indexer) Indexes elements from the array using passed delegate.
static <M extends Map<K,V>,K,V> Map<K,V>	indexBy(V[] groupies, Delegate<K,V> indexer, Provider<M> mapProvider) Indexes elements from the array using passed delegate.
static <T> Pair<List<T>,List<T>>	partition(Iterable<T> values, Predicate<T> partitioner) Partitions elements from the iterable into two collections containing elements that match the predicate (left side collection) and elements that don't (right side collection).
static <C extends Collection<T>,T> Pair<C,C>	partition(Iterable<T> values, Predicate<T> partitioner, Provider<C> collectionsProvider) Partitions elements from the iterable into two collections containing elements that match the predicate (left side collection) and elements that don't (right side collection).
static <CA extends Collection<T>,CR extends Collection<T>,T> Pair<CA,CR>	partition(Iterable<T> values, Predicate<T> partitioner, Provider<CA> acceptedCollectionProvider, Provider<CR> refusedCollectionProvider) Partitions elements from the iterable into two collections containing elements that match the predicate (left side collection) and elements that don't (right side collection).
static <T> Pair<List<T>,List<T>>	partition(Iterator<T> values, Predicate<T> partitioner) Partitions elements from the iterator into two collections containing elements that match the predicate (left side collection) and elements that don't (right side collection).
static <C extends Collection<T>,T> Pair<C,C>	partition(Iterator<T> values, Predicate<T> partitioner, Provider<C> collectionsProvider) Partitions elements from the iterator into two collections containing elements that match the predicate (left side collection) and elements that don't (right side collection).
static <CA extends Collection<T>,CR extends Collection<T>,T> Pair<CA,CR>	partition(Iterator<T> values, Predicate<T> partitioner, Provider<CA> acceptedCollectionProvider, Provider<CR> refusedCollectionProvider) Partitions elements from the iterator into two collections containing elements that match the predicate (left side collection) and elements that don't (right side collection).
static <T> Pair<List<T>,List<T>>	partition(T[] values, Predicate<T> partitioner) Partitions elements from the array into two collections containing elements that match the predicate (left side collection) and elements that don't (right side collection).
static <C extends Collection<T>,T> Pair<C,C>	partition(T[] values, Predicate<T> partitioner, Provider<C> collectionsProvider) Partitions elements from the array into two collections containing elements that match the predicate (left side collection) and elements that don't (right side collection).
static <CA extends Collection<T>,CR extends Collection<T>,T> Pair<CA,CR>	partition(T[] values, Predicate<T> partitioner, Provider<CA> acceptedCollectionProvider, Provider<CR> refusedCollectionProvider) Partitions elements from the array into two collections containing elements that match the predicate (left side collection) and elements that don't (right side collection).

Methods inherited from class java.lang.Object

clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Constructor Detail

Groups

public Groups()

Method Detail

groupBy

public static <K,V> Map<K,List<V>> groupBy(Iterator<V> groupies,
                           Delegate<K,V> grouper)

Groups elements from an iterator in the key evaluated from the passed delegate. E.g: groupBy([1, 2, 3, 1], id) -> { 1: [1,1], 2: [2], 3: [3]}

Type Parameters:

K - the grouped key type

V - the grouped value type

Parameters:

groupies - the elements to be grouped

grouper - the delegate used to group elements

Returns:

a map containing grouped values

groupBy

public static <C extends Collection<V>,K,V> Map<K,C> groupBy(Iterator<V> groupies,
                                             Delegate<K,V> grouper,
                                             Provider<C> collectionProvider)

Groups elements from an iterator in the key evaluated from the passed delegate. E.g: groupBy([1, 2, 3, 1], id) -> { 1: [1,1], 2: [2], 3: [3]}

Type Parameters:

C - the collection type used as value of the map

K - the grouped key type

V - the grouped value type

Parameters:

groupies - the elements to be grouped

grouper - the delegate used to group elements

collectionProvider - the values collection provider

Returns:

a map containing grouped values

groupBy

public static <M extends Map<K,C>,C extends Collection<V>,K,V> Map<K,C> groupBy(Iterator<V> groupies,
                                                                Delegate<K,V> grouper,
                                                                Provider<C> collectionProvider,
                                                                Provider<M> mapProvider)

Groups elements from an iterator in the key evaluated from the passed delegate. E.g: groupBy([1, 2, 3, 1], id) -> { 1: [1,1], 2: [2], 3: [3]}

Type Parameters:

M - the result map type

C - the collection type used as value of the map

K - the grouped key type

V - the grouped value type

Parameters:

groupies - the elements to be grouped

grouper - the delegate used to group elements

collectionProvider - the values collection provider

mapProvider - the map collection provider

Returns:

a map containing grouped values

groupBy

public static <K,V> Map<K,List<V>> groupBy(Iterable<V> groupies,
                           Delegate<K,V> grouper)

Groups elements from an iterable in the key evaluated from the passed delegate. E.g: groupBy([1, 2, 3, 1], id) -> { 1: [1,1], 2: [2], 3: [3]}

Type Parameters:

K - the grouped key type

V - the grouped value type

Parameters:

groupies - the elements to be grouped

grouper - the delegate used to group elements

Returns:

a map containing grouped values

groupBy

public static <C extends Collection<V>,K,V> Map<K,C> groupBy(Iterable<V> groupies,
                                             Delegate<K,V> grouper,
                                             Provider<C> collectionProvider)

Groups elements from an iterable in the key evaluated from the passed delegate. E.g: groupBy([1, 2, 3, 1], id) -> { 1: [1,1], 2: [2], 3: [3]}

Type Parameters:

C - the collection type used as value of the map

K - the grouped key type

V - the grouped value type

Parameters:

groupies - the elements to be grouped

grouper - the delegate used to group elements

collectionProvider - the values collection provider

Returns:

a map containing grouped values

groupBy

public static <M extends Map<K,C>,C extends Collection<V>,K,V> Map<K,C> groupBy(Iterable<V> groupies,
                                                                Delegate<K,V> grouper,
                                                                Provider<C> collectionProvider,
                                                                Provider<M> mapProvider)

Groups elements from an iterable in the key evaluated from the passed delegate. E.g: groupBy([1, 2, 3, 1], id) -> { 1: [1,1], 2: [2], 3: [3]}

Type Parameters:

M - the result map type

C - the collection type used as value of the map

K - the grouped key type

V - the grouped value type

Parameters:

groupies - the elements to be grouped

grouper - the delegate used to group elements

collectionProvider - the values collection provider

mapProvider - the map collection provider

Returns:

a map containing grouped values

groupBy

public static <K,V> Map<K,List<V>> groupBy(V[] groupies,
                           Delegate<K,V> grouper)

Groups elements from an array in the key evaluated from the passed delegate. E.g: groupBy([1, 2, 3, 1], id) -> { 1: [1,1], 2: [2], 3: [3]}

Type Parameters:

K - the grouped key type

V - the grouped value type

Parameters:

groupies - the elements to be grouped

grouper - the delegate used to group elements

Returns:

a map containing grouped values

groupBy

public static <C extends Collection<V>,K,V> Map<K,C> groupBy(V[] groupies,
                                             Delegate<K,V> grouper,
                                             Provider<C> collectionProvider)

Groups elements from an array in the key evaluated from the passed delegate. E.g: groupBy([1, 2, 3, 1], id) -> { 1: [1,1], 2: [2], 3: [3]}

Type Parameters:

C - the collection type used as value of the map

K - the grouped key type

V - the grouped value type

Parameters:

groupies - the elements to be grouped

grouper - the delegate used to group elements

collectionProvider - the values collection provider

Returns:

a map containing grouped values

groupBy

public static <M extends Map<K,C>,C extends Collection<V>,K,V> Map<K,C> groupBy(V[] groupies,
                                                                Delegate<K,V> grouper,
                                                                Provider<C> collectionProvider,
                                                                Provider<M> mapProvider)

Groups elements from an array in the key evaluated from the passed delegate. E.g: groupBy([1, 2, 3, 1], id) -> { 1: [1,1], 2: [2], 3: [3]}

Type Parameters:

M - the result map type

C - the collection type used as value of the map

K - the grouped key type

V - the grouped value type

Parameters:

groupies - the elements to be grouped

grouper - the delegate used to group elements

collectionProvider - the values collection provider

mapProvider - the map collection provider

Returns:

a map containing grouped values

partition

public static <T> Pair<List<T>,List<T>> partition(Iterator<T> values,
                                  Predicate<T> partitioner)

Partitions elements from the iterator into two collections containing elements that match the predicate (left side collection) and elements that don't (right side collection). E.g: partition([1,2,3,4], isOdd) -> ([1,3],[2,4])

Type Parameters:

T - the element type

Parameters:

values - the values to be partitioned

partitioner - the predicate used to partition values

Returns:

the two partitioned collections in a pair.

partition

public static <C extends Collection<T>,T> Pair<C,C> partition(Iterator<T> values,
                                              Predicate<T> partitioner,
                                              Provider<C> collectionsProvider)

Partitions elements from the iterator into two collections containing elements that match the predicate (left side collection) and elements that don't (right side collection). E.g: partition([1,2,3,4], isOdd) -> ([1,3],[2,4])

Type Parameters:

C - the partitioned elements collection type

T - the element type

Parameters:

values - the values to be partitioned

partitioner - the predicate used to partition values

collectionsProvider - a collection provider used to create both elements collection

Returns:

the two partitioned collections in a pair.

partition

public static <CA extends Collection<T>,CR extends Collection<T>,T> Pair<CA,CR> partition(Iterator<T> values,
                                                                          Predicate<T> partitioner,
                                                                          Provider<CA> acceptedCollectionProvider,
                                                                          Provider<CR> refusedCollectionProvider)

Partitions elements from the iterator into two collections containing elements that match the predicate (left side collection) and elements that don't (right side collection). E.g: partition([1,2,3,4], isOdd) -> ([1,3],[2,4])

Type Parameters:

CA - the accepted elements collection type

CR - the refused elements collection type

T - the element type

Parameters:

values - the values to be partitioned

partitioner - the predicate used to partition values

acceptedCollectionProvider - a collection provider used to create accepted elements collection

refusedCollectionProvider - a collection provider used to create refused elements collection

Returns:

the two partitioned collections in a pair.

partition

public static <T> Pair<List<T>,List<T>> partition(Iterable<T> values,
                                  Predicate<T> partitioner)

Partitions elements from the iterable into two collections containing elements that match the predicate (left side collection) and elements that don't (right side collection). E.g: partition([1,2,3,4], isOdd) -> ([1,3],[2,4])

Type Parameters:

T - the element type

Parameters:

values - the values to be partitioned

partitioner - the predicate used to partition values

Returns:

the two partitioned collections in a pair.

partition

public static <C extends Collection<T>,T> Pair<C,C> partition(Iterable<T> values,
                                              Predicate<T> partitioner,
                                              Provider<C> collectionsProvider)

Partitions elements from the iterable into two collections containing elements that match the predicate (left side collection) and elements that don't (right side collection). E.g: partition([1,2,3,4], isOdd) -> ([1,3],[2,4])

Type Parameters:

C - the partitioned elements collection type

T - the element type

Parameters:

values - the values to be partitioned

partitioner - the predicate used to partition values

collectionsProvider - a collection provider used to create both elements collection

Returns:

the two partitioned collections in a pair.

partition

public static <CA extends Collection<T>,CR extends Collection<T>,T> Pair<CA,CR> partition(Iterable<T> values,
                                                                          Predicate<T> partitioner,
                                                                          Provider<CA> acceptedCollectionProvider,
                                                                          Provider<CR> refusedCollectionProvider)

Partitions elements from the iterable into two collections containing elements that match the predicate (left side collection) and elements that don't (right side collection). E.g: partition([1,2,3,4], isOdd) -> ([1,3],[2,4])

Type Parameters:

CA - the accepted elements collection type

CR - the refused elements collection type

T - the element type

Parameters:

values - the values to be partitioned

partitioner - the predicate used to partition values

acceptedCollectionProvider - a collection provider used to create accepted elements collection

refusedCollectionProvider - a collection provider used to create refused elements collection

Returns:

the two partitioned collections in a pair.

partition

public static <T> Pair<List<T>,List<T>> partition(T[] values,
                                  Predicate<T> partitioner)

Partitions elements from the array into two collections containing elements that match the predicate (left side collection) and elements that don't (right side collection). E.g: partition([1,2,3,4], isOdd) -> ([1,3],[2,4])

Type Parameters:

T - the element type

Parameters:

values - the values to be partitioned

partitioner - the predicate used to partition values

Returns:

the two partitioned collections in a pair.

partition

public static <C extends Collection<T>,T> Pair<C,C> partition(T[] values,
                                              Predicate<T> partitioner,
                                              Provider<C> collectionsProvider)

Partitions elements from the array into two collections containing elements that match the predicate (left side collection) and elements that don't (right side collection). E.g: partition([1,2,3,4], isOdd) -> ([1,3],[2,4])

Type Parameters:

C - the partitioned elements collection type

T - the element type

Parameters:

values - the values to be partitioned

partitioner - the predicate used to partition values

collectionsProvider - a collection provider used to create both elements collection

Returns:

the two partitioned collections in a pair.

partition

public static <CA extends Collection<T>,CR extends Collection<T>,T> Pair<CA,CR> partition(T[] values,
                                                                          Predicate<T> partitioner,
                                                                          Provider<CA> acceptedCollectionProvider,
                                                                          Provider<CR> refusedCollectionProvider)

Partitions elements from the array into two collections containing elements that match the predicate (left side collection) and elements that don't (right side collection). E.g: partition([1,2,3,4], isOdd) -> ([1,3],[2,4])

Type Parameters:

CA - the accepted elements collection type

CR - the refused elements collection type

T - the element type

Parameters:

values - the values to be partitioned

partitioner - the predicate used to partition values

acceptedCollectionProvider - a collection provider used to create accepted elements collection

refusedCollectionProvider - a collection provider used to create refused elements collection

Returns:

the two partitioned collections in a pair.

indexBy

public static <M extends Map<K,V>,K,V> Map<K,V> indexBy(Iterable<V> groupies,
                                        Delegate<K,V> indexer,
                                        Provider<M> mapProvider)

Indexes elements from the iterable using passed delegate. E.g: indexBy([1,2,3,4], id) -> {1:1, 2:2, 3:3, 4:4}

Type Parameters:

M - the map type

K - the key type

V - the value type

Parameters:

groupies - elements to be indexed

indexer - the delegate used to index elements

mapProvider - a provider used to create the resulting map

Returns:

indexed elements in a map

indexBy

public static <K,V> Map<K,V> indexBy(Iterable<V> groupies,
                     Delegate<K,V> indexer)

Indexes elements from the iterable using passed delegate. E.g: indexBy([1,2,3,4], id) -> {1:1, 2:2, 3:3, 4:4}

Type Parameters:

K - the key type

V - the value type

Parameters:

groupies - elements to be indexed

indexer - the delegate used to index elements

Returns:

indexed elements in a map

indexBy

public static <M extends Map<K,V>,K,V> Map<K,V> indexBy(Iterator<V> groupies,
                                        Delegate<K,V> indexer,
                                        Provider<M> mapProvider)

Indexes elements from the iterator using passed delegate. E.g: indexBy([1,2,3,4], id) -> {1:1, 2:2, 3:3, 4:4}

Type Parameters:

M - the map type

K - the key type

V - the value type

Parameters:

groupies - elements to be indexed

indexer - the delegate used to index elements

Returns:

indexed elements in a map

indexBy

public static <K,V> Map<K,V> indexBy(Iterator<V> groupies,
                     Delegate<K,V> indexer)

Indexes elements from the iterator using passed delegate. E.g: indexBy([1,2,3,4], id) -> {1:1, 2:2, 3:3, 4:4}

Type Parameters:

K - the key type

V - the value type

Parameters:

groupies - elements to be indexed

indexer - the delegate used to index elements

Returns:

indexed elements in a map

indexBy

public static <M extends Map<K,V>,K,V> Map<K,V> indexBy(V[] groupies,
                                        Delegate<K,V> indexer,
                                        Provider<M> mapProvider)

Indexes elements from the array using passed delegate. E.g: indexBy([1,2,3,4], id) -> {1:1, 2:2, 3:3, 4:4}

Type Parameters:

M - the map type

K - the key type

V - the value type

Parameters:

groupies - elements to be indexed

indexer - the delegate used to index elements

mapProvider - a provider used to create the resulting map

Returns:

indexed elements in a map

indexBy

public static <K,V> Map<K,V> indexBy(V[] groupies,
                     Delegate<K,V> indexer)

Indexes elements from the array using passed delegate. E.g: indexBy([1,2,3,4], id) -> {1:1, 2:2, 3:3, 4:4}

Type Parameters:

K - the key type

V - the value type

Parameters:

groupies - elements to be indexed

indexer - the delegate used to index elements

Returns:

indexed elements in a map