public class GroovyCollections extends Object
A Collections utility class
| Type Params | Return Type | Name and description | 
|---|---|---|
 | 
                            public static List | 
                            combinations(Object[] collections)Finds all combinations of items from the given collections.  | 
                        
 | 
                            public static List | 
                            combinations(Collection collections)
  | 
                        
 | 
                            public static List | 
                            combinations(Iterable collections)Finds all combinations of items from the given Iterable aggregate of collections.  | 
                        
<T> | 
                            public static List<List<T>> | 
                            inits(Iterable<T> collections) | 
                        
<T> | 
                            public static T | 
                            max(T[] items)Selects the maximum value found in an array of items, so min([2, 4, 6] as Object[]) == 6.  | 
                        
<T> | 
                            public static T | 
                            max(Collection<T> items)
  | 
                        
<T> | 
                            public static T | 
                            max(Iterable<T> items)Selects the maximum value found in an Iterable.  | 
                        
<T> | 
                            public static T | 
                            min(T[] items)Selects the minimum value found in an array of items, so min([2, 4, 6] as Object[]) == 2.  | 
                        
<T> | 
                            public static T | 
                            min(Collection<T> items)
  | 
                        
<T> | 
                            public static T | 
                            min(Iterable<T> items)Selects the minimum value found in an Iterable of items.  | 
                        
<T> | 
                            public static Set<List<T>> | 
                            subsequences(List<T> items)Finds all non-null subsequences of a list.  | 
                        
 | 
                            public static Object | 
                            sum(Object[] items)Sums all the items from an array of items.  | 
                        
 | 
                            public static Object | 
                            sum(Collection items)
  | 
                        
 | 
                            public static Object | 
                            sum(Iterable items)Sums all the given items.  | 
                        
<T> | 
                            public static List<List<T>> | 
                            tails(Iterable<T> collections) | 
                        
 | 
                            public static List | 
                            transpose(Object[] lists)Transposes an array of lists.  | 
                        
 | 
                            public static List | 
                            transpose(List lists)Transposes the given lists.  | 
                        
Finds all combinations of items from the given collections.
collections -  the given collectionscollections -  the given collections Finds all combinations of items from the given Iterable aggregate of collections.
 So, combinations([[true, false], [true, false]])
 is [[true, true], [false, true], [true, false], [false, false]]
 and combinations([['a', 'b'],[1, 2, 3]])
 is [['a', 1], ['b', 1], ['a', 2], ['b', 2], ['a', 3], ['b', 3]].
 If a non-collection item is given, it is treated as a singleton collection,
 i.e. combinations([[1, 2], 'x']) is [[1, 'x'], [2, 'x']].
 If an empty collection is found within the given collections, the result will be an empty list.
      
collections -  the Iterable of given collectionsSelects the maximum value found in an array of items, so min([2, 4, 6] as Object[]) == 6.
items -  an array of itemsSelects the maximum value found in an Iterable.
items -  a CollectionSelects the minimum value found in an array of items, so min([2, 4, 6] as Object[]) == 2.
items -  an array of itemsSelects the minimum value found in an Iterable of items.
items -  an Iterable Finds all non-null subsequences of a list.
 E.g. subsequences([1, 2, 3]) would be:
 [[1, 2, 3], [1, 3], [2, 3], [1, 2], [1], [2], [3]]
      
items -  the List of itemsSums all the items from an array of items.
items -  an array of itemsSums all the given items.
items -  an Iterable of itemsTransposes an array of lists.
lists -  the given lists