| Return type | Name and parameters |
|---|---|
boolean
|
any(Closure closure)
Iterates over the contents of an iterable, and checks whether a predicate is valid for at least one element. |
List
|
asList()
Converts this Iterable to a List. |
Map
|
collectEntries()
A variant of collectEntries for Iterable objects using the identity closure as the transform. |
Map
|
collectEntries(Closure transform)
Iterates through this Iterable transforming each item using the transform closure
and returning a map of the resulting transformed entries.
|
Map
|
collectEntries(Map collector)
A variant of collectEntries for Iterables using the identity closure as the transform and a supplied map as the destination of transformed entries. |
Map
|
collectEntries(Map collector, Closure transform)
Iterates through this Iterable transforming each item using the closure as a transformer into a map entry, returning the supplied map with all of the transformed entries added to it. |
List
|
collectMany(Closure projection)
Projects each item from a source Iterable to a collection and concatenates (flattens) the resulting collections into a single list. |
Collection
|
collectMany(Collection collector, Closure projection)
Projects each item from a source collection to a result collection and concatenates (flattens) the resulting collections adding them into the collector.
|
List
|
collectNested(Closure transform)
Recursively iterates through this Iterable transforming each non-Collection value into a new value using the closure as a transformer. |
Collection
|
collectNested(Collection collector, Closure transform)
Recursively iterates through this Iterable transforming each non-Collection value into a new value using the transform closure.
|
List
|
combinations()
Adds GroovyCollections#combinations(Iterable) as a method on Iterables. |
List
|
combinations(Closure function)
Adds GroovyCollections#combinations(Iterable, Closure) as a method on collections. |
Number
|
count(Closure closure)
Counts the number of occurrences which satisfy the given closure from inside this Iterable. |
Number
|
count(Object value)
Counts the number of occurrences of the given value inside this Iterable. |
Map
|
countBy(Closure closure)
Sorts all collection members into groups determined by the supplied mapping closure and counts the group size. |
List
|
drop(int num)
Drops the given number of elements from the head of this Iterable. |
List
|
dropWhile(Closure condition)
Returns a suffix of this Iterable where elements are dropped from the front while the given closure evaluates to true. |
Iterable
|
each(Closure closure)
|
void
|
eachCombination(Closure function)
Applies a function on each combination of the input lists. |
Iterable
|
eachWithIndex(Closure closure)
Iterates through an iterable type, passing each item and the item's index (a counter starting at zero) to the given closure. |
boolean
|
every(Closure closure)
Used to determine if the given predicate closure is valid (i.e. |
Collection
|
findResults(Closure filteringTransform)
Iterates through the Iterable transforming items using the supplied closure and collecting any non-null results. |
Object
|
first()
Returns the first item from the Iterable. |
Collection
|
flatten()
Flatten an Iterable. |
Collection
|
flatten(Closure flattenUsing)
Flatten an Iterable. |
Object
|
getAt(int idx)
Support the subscript operator for an Iterable. |
Map
|
groupBy(Closure closure)
Sorts all Iterable members into groups determined by the supplied mapping closure. |
Map
|
groupBy(Object closures)
Sorts all Iterable members into (sub)groups determined by the supplied mapping closures. |
Map
|
groupBy(List closures)
Sorts all Iterable members into (sub)groups determined by the supplied mapping closures. |
String
|
join(String separator)
Concatenates the toString() representation of each
item in this Iterable, with the given String as a separator between each item.
|
Object
|
last()
Returns the last item from the Iterable. |
Object
|
max()
Adds max() method to Iterable objects. |
Object
|
max(Closure closure)
Selects an item in the collection having the maximum value as determined by the supplied closure. |
Object
|
max(Comparator comparator)
Selects the maximum value found in the Iterable using the given comparator. |
Object
|
min()
Adds min() method to Collection objects. |
Object
|
min(Closure closure)
Selects an item in the collection having the minimum value as determined by the supplied closure. |
Object
|
min(Comparator comparator)
Selects the minimum value found in the Iterable using the given comparator. |
List
|
sort()
Sorts the Collection. |
List
|
sort(boolean mutate)
Sorts the Iterable. |
List
|
sort(boolean mutate, Closure closure)
Sorts this Iterable using the given Closure to determine the correct ordering. |
List
|
sort(boolean mutate, Comparator comparator)
Sorts the Iterable using the given Comparator. |
List
|
sort(Closure closure)
Sorts this Iterable using the given Closure to determine the correct ordering. |
Object
|
sum()
Sums the items in an Iterable. |
Object
|
sum(Closure closure)
Sums the result of apply a closure to each item of an Iterable. |
Object
|
sum(Object initialValue)
Sums the items in an Iterable, adding the result to some initial value. |
Object
|
sum(Object initialValue, Closure closure)
Sums the result of applying a closure to each item of an Iterable to some initial value. |
List
|
take(int num)
Returns the first num elements from the head of this Iterable.
|
List
|
takeWhile(Closure condition)
Returns a List containing the longest prefix of the elements from this Iterable where each element passed to the given closure evaluates to true. |
List
|
toList()
Convert an Iterable to a List. |
Iterates over the contents of an iterable, and checks whether a predicate is valid for at least one element.
closure - the closure predicate used for matchingConverts this Iterable to a List. Returns the original Iterable if it is already a List.
Example usage:
assert new HashSet().asList() instanceof List
A variant of collectEntries for Iterable objects using the identity closure as the transform.
The source Iterable should contain a list of [key, value] tuples or Map.Entry objects.
def nums = [1, 10, 100, 1000]
def tuples = nums.collect{ [it, it.toString().size()] }
assert tuples == [[1, 1], [10, 2], [100, 3], [1000, 4]]
def map = tuples.collectEntries()
assert map == [1:1, 10:2, 100:3, 1000:4]
Iterates through this Iterable transforming each item using the transform closure
and returning a map of the resulting transformed entries.
def letters = "abc"
// collect letters with index using list style
assert (0..2).collectEntries { index -> [index, letters[index]] } == [0:'a', 1:'b', 2:'c']
// collect letters with index using map style
assert (0..2).collectEntries { index -> [(index): letters[index]] } == [0:'a', 1:'b', 2:'c']
transform
- the closure used for transforming, which has an item from self as the parameter and
should return a Map.Entry, a Map or a two-element list containing the resulting key and valueA variant of collectEntries for Iterables using the identity closure as the transform and a supplied map as the destination of transformed entries.
collector - the Map into which the transformed entries are putIterates through this Iterable transforming each item using the closure as a transformer into a map entry, returning the supplied map with all of the transformed entries added to it.
def letters = "abc"
// collect letters with index
assert (0..2).collectEntries( [:] ) { index -> [index, letters[index]] } == [0:'a', 1:'b', 2:'c']
assert (0..2).collectEntries( [4:'d'] ) { index ->
[(index+1): letters[index]] } == [1:'a', 2:'b', 3:'c', 4:'d']
collector - the Map into which the transformed entries are puttransform
- the closure used for transforming, which has an item from self as the parameter and
should return a Map.Entry, a Map or a two-element list containing the resulting key and valueProjects each item from a source Iterable to a collection and concatenates (flattens) the resulting collections into a single list.
def nums = 1..10
def squaresAndCubesOfEvens = nums.collectMany{ it % 2 ? [] : [it**2, it**3] }
assert squaresAndCubesOfEvens == [4, 8, 16, 64, 36, 216, 64, 512, 100, 1000]
def animals = ['CAT', 'DOG', 'ELEPHANT'] as Set
def smallAnimals = animals.collectMany{ it.size() > 3 ? [] : [it.toLowerCase()] }
assert smallAnimals == ['cat', 'dog']
def orig = nums as Set
def origPlusIncrements = orig.collectMany{ [it, it+1] }
assert origPlusIncrements.size() == orig.size() * 2
assert origPlusIncrements.unique().size() == orig.size() + 1
projection - a projecting Closure returning a collection of itemsProjects each item from a source collection to a result collection and concatenates (flattens) the resulting
collections adding them into the collector.
def animals = ['CAT', 'DOG', 'ELEPHANT'] as Set
def smallAnimals = animals.collectMany(['ant', 'bee']){ it.size() > 3 ? [] : [it.toLowerCase()] }
assert smallAnimals == ['ant', 'bee', 'cat', 'dog']
def nums = 1..5
def origPlusIncrements = nums.collectMany([] as Set){ [it, it+1] }
assert origPlusIncrements.size() == nums.size() + 1
collector - an initial collection to add the projected items toprojection - a projecting Closure returning a collection of itemsRecursively iterates through this Iterable transforming each non-Collection value into a new value using the closure as a transformer. Returns a potentially nested list of transformed values.
assert [2,[4,6],[8],[]] == [1,[2,3],[4],[]].collectNested { it * 2 }
transform - the closure used to transform each item of the IterableRecursively iterates through this Iterable transforming each non-Collection value
into a new value using the transform closure. Returns a potentially nested
collection of transformed values.
def x = [1,[2,3],[4],[]].collectNested(new Vector()) { it * 2 }
assert x == [2,[4,6],[8],[]]
assert x instanceof Vector
collector - an initial Collection to which the transformed values are addedtransform - the closure used to transform each element of the IterableAdds GroovyCollections#combinations(Iterable) as a method on Iterables.
Example usage:
assert [['a', 'b'],[1, 2, 3]].combinations() == [['a', 1], ['b', 1], ['a', 2], ['b', 2], ['a', 3], ['b', 3]]
Adds GroovyCollections#combinations(Iterable, Closure) as a method on collections.
Example usage:
assert [[2, 3],[4, 5, 6]].combinations {x,y -> x*y } == [8, 12, 10, 15, 12, 18]
function - a closure to be called on each combinationCounts the number of occurrences which satisfy the given closure from inside this Iterable.
Example usage:
assert [2,4,2,1,3,5,2,4,3].count{ it % 2 == 0 } == 5
closure - a closure conditionCounts the number of occurrences of the given value inside this Iterable.
Comparison is done using Groovy's == operator (using
compareTo(value) == 0 or equals(value) ).
Example usage:
assert [2,4,2,1,3,5,2,4,3].count(4) == 2
value - the value being searched forSorts all collection members into groups determined by the supplied mapping closure and counts the group size. The closure should return the key that each item should be grouped by. The returned Map will have an entry for each distinct key returned from the closure, with each value being the frequency of items occurring for that group.
Example usage:
assert [0:2, 1:3] == [1,2,3,4,5].countBy { it % 2 }
closure - a closure mapping items to the frequency keysDrops the given number of elements from the head of this Iterable.
class AbcIterable implements Iterable{ Iterator iterator() { "abc".iterator() } } def abc = new AbcIterable() assert abc.drop(0) == ['a', 'b', 'c'] assert abc.drop(1) == ['b', 'c'] assert abc.drop(3) == [] assert abc.drop(5) == []
num - the number of elements to drop from this Iterablenum elements,
or an empty list if it has less then num elements.Returns a suffix of this Iterable where elements are dropped from the front while the given closure evaluates to true.
class AbcIterable implements Iterable{ Iterator iterator() { "abc".iterator() } } def abc = new AbcIterable() assert abc.dropWhile{ it < 'b' } == ['b', 'c'] assert abc.dropWhile{ it <= 'b' } == ['c']
condition - the closure that must evaluate to true to continue dropping elementsApplies a function on each combination of the input lists.
Example usage:
[[2, 3],[4, 5, 6]].eachCombination { println "Found $it" }
function - a closure to be called on each combinationIterates through an iterable type, passing each item and the item's index (a counter starting at zero) to the given closure.
closure - a Closure to operate on each itemUsed to determine if the given predicate closure is valid (i.e.&nsbp;returns
true for all items in this iterable).
A simple example for a list:
def list = [3,4,5]
def greaterThanTwo = list.every { it > 2 }
closure - the closure predicate used for matchingIterates through the Iterable transforming items using the supplied closure and collecting any non-null results.
Example:
def list = [1,2,3]
def result = list.findResults { it > 1 ? "Found $it" : null }
assert result == ["Found 2", "Found 3"]
filteringTransform - a Closure that should return either a non-null transformed value or null for items which should be discardedReturns the first item from the Iterable.
def set = [3, 4, 2] as LinkedHashSet assert set.first() == 3 // check original is unaltered assert set == [3, 4, 2] as SetThe first element returned by the Iterable's iterator is returned. If the Iterable doesn't guarantee a defined order it may appear like a random element is returned.
Flatten an Iterable. This Iterable and any nested arrays or collections have their contents (recursively) added to the new collection.
assert [1,2,3,4,5] == [1,[2,3],[[4]],[],5].flatten()
Flatten an Iterable. This Iterable and any nested arrays or collections have their contents (recursively) added to the new collection. For any non-Array, non-Collection object which represents some sort of collective type, the supplied closure should yield the contained items; otherwise, the closure should just return any element which corresponds to a leaf.
flattenUsing - a closure to determine how to flatten non-Array, non-Collection elementsSupport the subscript operator for an Iterable. Typical usage:
// custom Iterable example:
class MyIterable implements Iterable {
Iterator iterator() { [1, 2, 3].iterator() }
}
def myIterable = new MyIterable()
assert myIterable[1] == 2
// Set example:
def set = [1,2,3] as LinkedHashSet
assert set[1] == 2
idx - an index value (-self.size() <= idx < self.size()) but using -ve index values will be inefficientSorts all Iterable members into groups determined by the supplied mapping closure. The closure should return the key that this item should be grouped by. The returned LinkedHashMap will have an entry for each distinct key returned from the closure, with each value being a list of items for that group.
Example usage:
assert [0:[2,4,6], 1:[1,3,5]] == [1,2,3,4,5,6].groupBy { it % 2 }
closure - a closure mapping entries on keysSorts all Iterable members into (sub)groups determined by the supplied mapping closures. Each closure should return the key that this item should be grouped by. The returned LinkedHashMap will have an entry for each distinct 'key path' returned from the closures, with each value being a list of items for that 'group path'. Example usage:
def result = [1,2,3,4,5,6].groupBy({ it % 2 }, { it < 4 })
assert result == [1:[(true):[1, 3], (false):[5]], 0:[(true):[2], (false):[4, 6]]]
Another example:
def sql = groovy.sql.Sql.newInstance(/* ... */)
def data = sql.rows("SELECT * FROM a_table").groupBy({ it.column1 }, { it.column2 }, { it.column3 })
if (data.val1.val2.val3) {
// there exists a record where:
// a_table.column1 == val1
// a_table.column2 == val2, and
// a_table.column3 == val3
} else {
// there is no such record
}
If an empty array of closures is supplied the IDENTITY Closure will be used.
closures - an array of closures, each mapping entries on keysSorts all Iterable members into (sub)groups determined by the supplied mapping closures. Each closure should return the key that this item should be grouped by. The returned LinkedHashMap will have an entry for each distinct 'key path' returned from the closures, with each value being a list of items for that 'group path'. Example usage:
def result = [1,2,3,4,5,6].groupBy([{ it % 2 }, { it < 4 }])
assert result == [1:[(true):[1, 3], (false):[5]], 0:[(true):[2], (false):[4, 6]]]
Another example:
def sql = groovy.sql.Sql.newInstance(/* ... */)
def data = sql.rows("SELECT * FROM a_table").groupBy([{ it.column1 }, { it.column2 }, { it.column3 }])
if (data.val1.val2.val3) {
// there exists a record where:
// a_table.column1 == val1
// a_table.column2 == val2, and
// a_table.column3 == val3
} else {
// there is no such record
}
If an empty list of closures is supplied the IDENTITY Closure will be used.
closures - a list of closures, each mapping entries on keysConcatenates the toString() representation of each
item in this Iterable, with the given String as a separator between each item.
assert "1, 2, 3" == [1,2,3].join(", ")
separator - a String separatorReturns the last item from the Iterable.
def set = [3, 4, 2] as LinkedHashSet assert set.last() == 2 // check original unaltered assert set == [3, 4, 2] as SetThe first element returned by the Iterable's iterator is returned. If the Iterable doesn't guarantee a defined order it may appear like a random element is returned.
Adds max() method to Iterable objects.
assert 5 == [2,3,1,5,4].max()
Selects an item in the collection having the maximum value as determined by the supplied closure. If more than one item has the maximum value, an arbitrary choice is made between the items having the maximum value.
If the closure has two parameters it is used like a traditional Comparator. I.e. it should compare its two parameters for order, returning a negative integer, zero, or a positive integer when the first parameter is less than, equal to, or greater than the second respectively. Otherwise, the Closure is assumed to take a single parameter and return a Comparable (typically an Integer) which is then used for further comparison.
assert "hello" == ["hello","hi","hey"].max { it.length() }
assert "hello" == ["hello","hi","hey"].max { a, b -> a.length() <=> b.length() }
def pets = ['dog', 'elephant', 'anaconda']
def longestName = pets.max{ it.size() } // one of 'elephant' or 'anaconda'
assert longestName.size() == 8
closure - a 1 or 2 arg Closure used to determine the correct orderingSelects the maximum value found in the Iterable using the given comparator.
assert "hello" == ["hello","hi","hey"].max( { a, b -> a.length() <=> b.length() } as Comparator )
comparator - a ComparatorAdds min() method to Collection objects.
assert 2 == [4,2,5].min()
Selects an item in the collection having the minimum value as determined by the supplied closure. If more than one item has the minimum value, an arbitrary choice is made between the items having the minimum value.
If the closure has two parameters it is used like a traditional Comparator. I.e. it should compare its two parameters for order, returning a negative integer, zero, or a positive integer when the first parameter is less than, equal to, or greater than the second respectively. Otherwise, the Closure is assumed to take a single parameter and return a Comparable (typically an Integer) which is then used for further comparison.
assert "hi" == ["hello","hi","hey"].min { it.length() }
def lastDigit = { a, b -> a % 10 <=> b % 10 }
assert [19, 55, 91].min(lastDigit) == 91
def pets = ['dog', 'cat', 'anaconda']
def shortestName = pets.min{ it.size() } // one of 'dog' or 'cat'
assert shortestName.size() == 3
closure - a 1 or 2 arg Closure used to determine the correct orderingSelects the minimum value found in the Iterable using the given comparator.
assert "hi" == ["hello","hi","hey"].min( { a, b -> a.length() <=> b.length() } as Comparator )
comparator - a ComparatorSorts the Collection. Assumes that the collection items are comparable and uses their natural ordering to determine the resulting order. If the Collection is a List, it is sorted in place and returned. Otherwise, the elements are first placed into a new list which is then sorted and returned - leaving the original Collection unchanged.
assert [1,2,3] == [3,1,2].sort()
Sorts the Iterable. Assumes that the Iterable items are comparable and uses their natural ordering to determine the resulting order. If the Iterable is a List and mutate is true, it is sorted in place and returned. Otherwise, the elements are first placed into a new list which is then sorted and returned - leaving the original Iterable unchanged.
assert [1,2,3] == [3,1,2].sort()
def orig = [1, 3, 2] def sorted = orig.sort(false) assert orig == [1, 3, 2] assert sorted == [1, 2, 3]
mutate - false will always cause a new list to be created, true will mutate lists in placeSorts this Iterable using the given Closure to determine the correct ordering. If the Iterable is a List and mutate is true, it is sorted in place and returned. Otherwise, the elements are first placed into a new list which is then sorted and returned - leaving the original Iterable unchanged.
If the closure has two parameters it is used like a traditional Comparator. I.e. it should compare its two parameters for order, returning a negative integer, zero, or a positive integer when the first parameter is less than, equal to, or greater than the second respectively. Otherwise, the Closure is assumed to take a single parameter and return a Comparable (typically an Integer) which is then used for further comparison.
assert ["hi","hey","hello"] == ["hello","hi","hey"].sort { it.length() }
assert ["hi","hey","hello"] == ["hello","hi","hey"].sort { a, b -> a.length() <=> b.length() }
def orig = ["hello","hi","Hey"]
def sorted = orig.sort(false) { it.toUpperCase() }
assert orig == ["hello","hi","Hey"]
assert sorted == ["hello","Hey","hi"]
mutate - false will always cause a new list to be created, true will mutate lists in placeclosure - a 1 or 2 arg Closure used to determine the correct orderingSorts the Iterable using the given Comparator. If the Iterable is a List and mutate is true, it is sorted in place and returned. Otherwise, the elements are first placed into a new list which is then sorted and returned - leaving the original Iterable unchanged.
assert ["hi","hey","hello"] == ["hello","hi","hey"].sort( { a, b -> a.length() <=> b.length() } as Comparator )
def orig = ["hello","hi","Hey"] def sorted = orig.sort(false, String.CASE_INSENSITIVE_ORDER) assert orig == ["hello","hi","Hey"] assert sorted == ["hello","Hey","hi"]
mutate - false will always cause a new list to be created, true will mutate lists in placecomparator - a Comparator used for the comparisonSorts this Iterable using the given Closure to determine the correct ordering. If the Iterable is a List, it is sorted in place and returned. Otherwise, the elements are first placed into a new list which is then sorted and returned - leaving the original Iterable unchanged.
If the Closure has two parameters it is used like a traditional Comparator. I.e. it should compare its two parameters for order, returning a negative integer, zero, or a positive integer when the first parameter is less than, equal to, or greater than the second respectively. Otherwise, the Closure is assumed to take a single parameter and return a Comparable (typically an Integer) which is then used for further comparison.
assert ["hi","hey","hello"] == ["hello","hi","hey"].sort { it.length() }
assert ["hi","hey","hello"] == ["hello","hi","hey"].sort { a, b -> a.length() <=> b.length() }
closure - a 1 or 2 arg Closure used to determine the correct orderingSums the items in an Iterable. This is equivalent to invoking the "plus" method on all items in the Iterable.
assert 1+2+3+4 == [1,2,3,4].sum()
Sums the result of apply a closure to each item of an Iterable.
coll.sum(closure) is equivalent to:
coll.collect(closure).sum().
assert 4+6+10+12 == [2,3,5,6].sum() { it * 2 }
closure - a single parameter closure that returns a numeric value.Sums the items in an Iterable, adding the result to some initial value.
assert 5+1+2+3+4 == [1,2,3,4].sum(5)
initialValue - the items in the collection will be summed to this initial valueSums the result of applying a closure to each item of an Iterable to some initial value.
coll.sum(initVal, closure) is equivalent to:
coll.collect(closure).sum(initVal).
assert 50+4+6+10+12 == [2,3,5,6].sum(50) { it * 2 }
closure - a single parameter closure that returns a numeric value.initialValue - the closure results will be summed to this initial valueReturns the first num elements from the head of this Iterable.
class AbcIterable implements Iterable{ Iterator iterator() { "abc".iterator() } } def abc = new AbcIterable() assert abc.take(0) == [] assert abc.take(1) == ['a'] assert abc.take(3) == ['a', 'b', 'c'] assert abc.take(5) == ['a', 'b', 'c']
num - the number of elements to take from this Iterablenum elements from this Iterable,
or else all the elements from the Iterable if it has less then num elements.Returns a List containing the longest prefix of the elements from this Iterable where each element passed to the given closure evaluates to true.
class AbcIterable implements Iterable{ Iterator iterator() { "abc".iterator() } } def abc = new AbcIterable() assert abc.takeWhile{ it < 'b' } == ['a'] assert abc.takeWhile{ it <= 'b' } == ['a', 'b']
condition
- the closure that must evaluate to true to
continue taking elementsConvert an Iterable to a List. The Iterable's iterator will become exhausted of elements after making this conversion.