| Return type | Name and parameters |
|---|---|
boolean | addAll(Iterable items)Adds all items from the iterable to the Collection. |
boolean | addAll(Object[] items)Modifies the collection by adding all the elements in the specified arrayto the collection. |
boolean | addAll(Iterator items)Adds all items from the iterator to the Collection. |
boolean | asBoolean()Coerce a collection instance to a boolean value. |
Collection | asChecked(Class type)Creates a checked view of a Collection. |
Collection | asImmutable()A convenience method for creating an immutable Collection. |
Collection | asSynchronized()Creates a synchronized view of a Collection. |
Object | asType(Class clazz)Converts the given collection to another type. |
Collection | asUnmodifiable()Creates an unmodifiable view of a Collection. |
List | collectNested(Closure transform)Recursively iterates through this collection transforming each non-Collection valueinto a new value using the closure as a transformer. |
Collection | each(Closure closure)Iterates through a Collection, passing each item to the given closure. |
Collection | eachWithIndex(Closure closure)Iterates through a Collection,passing each item and the item's index (a counter starting atzero) to the given closure. |
Object | find()Finds the first item matching the IDENTITY Closure (i.e. matching Groovy truth). |
Object | find(Closure closure)Finds the first value matching the closure condition. |
Collection | findAll()Finds the items matching the IDENTITY Closure (i.e. matching Groovy truth). |
Collection | findAll(Closure closure)Finds all values matching the closure condition. |
Collection | flatten()Flatten a Collection. |
List | getAt(String property)Support the subscript operator for Collection. |
IntRange | getIndices()Returns indices of the collection. |
Collection | grep()Iterates over the collection returning each element that matchesusing the IDENTITY Closure as a filter - effectively returning all elements which satisfy Groovy truth. |
Collection | grep(Object filter)Iterates over the collection of items and returns each item that matchesthe given filter - calling the Object#isCase(java.lang.Object)method used by switch statements. method can be used with differentkinds of filters like regular expressions, classes, ranges etc. |
Collection | intersect(Collection right)Create a Collection composed of the intersection of both collections. |
Collection | intersect(Collection right,Comparator comparator)Create a Collection composed of the intersection of both collections. |
boolean | isCase(Object switchValue)Special 'case' implementation for collections which tests if the 'switch'operand is contained in any of the 'case' values. |
boolean | isNotCase(Object switchValue) |
Collection | leftShift(Object value)Overloads the left shift operator to provide an easy way to appendobjects to a Collection. |
Collection | minus(Collection removeMe)Create a new Collection composed of the elements of the first Collection minusevery occurrence of elements of the given Collection. |
Collection | plus(Iterable right)Create a Collection as a union of a Collection and an Iterable. |
Collection | plus(Object right)Create a collection as a union of a Collection and an Object. |
Collection | plus(Collection right)Create a Collection as a union of two collections. |
boolean | removeAll(Closure condition)Modifies this collection by removing the elements that are matched accordingto the specified closure condition. |
boolean | removeAll(Object[] items)Modifies this collection by removing its elements that are containedwithin the specified object array. |
boolean | removeElement(Object o)Modifies this collection by removing a single instance of the specifiedelement from this collection, if it is present. |
boolean | retainAll(Closure condition)Modifies this collection so that it retains only its elementsthat are matched according to the specified closure condition. |
boolean | retainAll(Object[] items)Modifies this collection so that it retains only its elements that are containedin the specified array. |
Collection | split(Closure closure)Splits all items into two collections based on the closure condition. |
String | toListString()Returns the string representation of the given list. |
String | toListString(int maxSize)Returns the string representation of the given list. |
Set | toSet()Convert a Collection to a Set. |
Collection | union(Collection right)Create a Collection composed of the union of both collections. |
Collection | union(Collection right,Comparator comparator)Create a Collection composed of the union of both collections. |
Collection | unique()Modifies this collection to remove all duplicated items, using Groovy'sdefault number-aware comparator. |
Collection | unique(boolean mutate)Remove all duplicates from a given Collection using Groovy's default number-aware comparator. |
Collection | unique(boolean mutate,Closure closure)A convenience method for making a collection unique using a Closure to determine duplicate (equal) items. |
Collection | unique(boolean mutate,Comparator comparator)Remove all duplicates from a given Collection. |
Collection | unique(Closure closure)A convenience method for making a collection unique using a Closureto determine duplicate (equal) items. |
Collection | unique(Comparator comparator)Remove all duplicates from a given Collection. |
any,asCollection,asList,asType,average,average,bufferedIterator,chop,chop,collate,collate,collate,collate,collect,collect,collect,collectEntries,collectEntries,collectEntries,collectEntries,collectEntries,collectEntries,collectMany,collectMany,collectMany,collectNested,collectNested,combinations,combinations,contains,containsAll,count,count,count,countBy,countBy,disjoint,drop,dropRight,dropWhile,each,eachCombination,eachPermutation,eachWithIndex,every,findIndexOf,findIndexOf,findIndexValues,findIndexValues,findLastIndexOf,findLastIndexOf,findResult,findResult,findResult,findResult,findResults,findResults,first,flatten,flatten,flatten,flatten,flattenMany,getAt,groupBy,groupBy,groupBy,head,indexed,indexed,init,inits,inject,inject,injectAll,injectAll,interleave,interleave,intersect,intersect,intersect,isCase,isEmpty,join,join,last,max,max,max,min,min,min,minus,minus,minus,minus,multiply,permutations,permutations,plus,plus,repeat,repeat,size,sort,sort,sort,sort,sort,stream,sum,sum,sum,sum,tail,tails,take,takeRight,takeWhile,toList,toSet,toSorted,toSorted,toSorted,toSpreadMap,toUnique,toUnique,toUnique,union,union,union,withCollectedKeys,withCollectedKeys,withCollectedValues,withCollectedValues,withIndex,withIndex,zip,zipAll
Adds all items from the iterable to the Collection.
items - the items to addModifies the collection by adding all the elements in the specified arrayto the collection. The behavior of this operation is undefined if thespecified array is modified while the operation is in progress.
See alsoplus or the '+' operator if wanting to produce a new collectioncontaining additional items but while leaving the original collection unchanged.
items - array containing elements to be added to this collectionAdds all items from the iterator to the Collection.
items - the items to addCoerce a collection instance to a boolean value.A collection is coerced to false if it's empty, and to true otherwise.
assert [1,2].asBoolean() == true
assert [].asBoolean() == false
Creates a checked view of a Collection.
A convenience method for creating an immutable Collection.
Creates a synchronized view of a Collection.
Converts the given collection to another type. A default concretetype is used for List, Set, or SortedSet. If the given type hasa constructor taking a collection, that is used. Otherwise, thecall is deferred to Object#asType(Class). If thiscollection is already of the given type, the same instance isreturned.
clazz - the desired classCreates an unmodifiable view of a Collection.
Recursively iterates through this collection transforming each non-Collection valueinto a new value using the closure as a transformer. Returns a potentially nestedlist 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 collectionIterates through a Collection, passing each item to the given closure.
closure - the closure applied on each element foundIterates through a Collection,passing each item and the item's index (a counter starting atzero) to the given closure.
closure - a Closure to operate on each itemFinds the first item matching the IDENTITY Closure (i.e. matching Groovy truth).
Example:
def items = [null, 0, 0.0, false, '', [], 42, 43]assert items.find() == 42
Finds the first value matching the closure condition. Example:
def list = [1,2,3]assert 2 == list.find { it> 1 }closure - a closure conditionFinds the items matching the IDENTITY Closure (i.e. matching Groovy truth).
Example:
def items = [1, 2, 0, false, true, '', 'foo', [], [4, 5], null]assert items.findAll() == [1, 2, true, 'foo', [4, 5]]
Finds all values matching the closure condition.
assert [2,4] == [1,2,3,4].findAll { it % 2 == 0 }closure - a closure conditionFlatten a Collection. This Collection and any nested arrays orcollections have their contents (recursively) added to the new collection.
assert [1,2,3,4,5] == [1,[2,3],[[4]],[],5].flatten()
Support the subscript operator for Collection.
assert [String, Long, Integer] == ["a",5L,2]["class"]
property - a StringReturns indices of the collection.
Example:
assert 0..2 == [5, 6, 7].indices
Iterates over the collection returning each element that matchesusing the IDENTITY Closure as a filter - effectively returning all elements which satisfy Groovy truth.
Example:
def items = [1, 2, 0, false, true, '', 'foo', [], [4, 5], null]assert items.grep() == [1, 2, true, 'foo', [4, 5]]
Iterates over the collection of items and returns each item that matchesthe given filter - calling theObject#isCase(java.lang.Object)method used by switch statements. method can be used with differentkinds of filters like regular expressions, classes, ranges etc.Example:
def list = ['a', 'b', 'aa', 'bc', 3, 4.5]assert list.grep( ~/a+/ ) == ['a', 'aa']assert list.grep( ~/../ ) == ['aa', 'bc']assert list.grep( Number ) == [ 3, 4.5 ]assert list.grep{ it.toString().size() == 1 } == [ 'a', 'b', 3 ]filter - the filter to perform on each element of the collection (using theObject#isCase(java.lang.Object) method)Create a Collection composed of the intersection of both collections. Anyelements that exist in both collections are added to the resultant collection.For collections of custom objects; the objects should implement java.lang.Comparable
assert [4,5] == [1,2,3,4,5].intersect([4,5,6,7,8])By default, Groovy uses a NumberAwareComparator when determining if anelement exists in both collections.
right - a CollectionCreate a Collection composed of the intersection of both collections. Anyelements that exist in both collections are added to the resultant collection.For collections of custom objects; the objects should implement java.lang.Comparable
assert [3,4] == [1,2,3,4].intersect([3,4,5,6], Comparator.naturalOrder())assert [2,4] == [1,2,3,4].intersect([4,8,12,16,20], (x, y)-> x * x<=> y)def one = ['a', 'B', 'c', 'd']def two = ['b', 'C', 'd', 'e']def compareIgnoreCase = { a, b-> a.toLowerCase()<=> b.toLowerCase() }assert one.intersect(two) == ['d']assert two.intersect(one) == ['d']assert one.intersect(two, compareIgnoreCase) == ['B', 'c', 'd']assert two.intersect(one, compareIgnoreCase) == ['b', 'C', 'd']right - a Collectioncomparator - a ComparatorSpecial 'case' implementation for collections which tests if the 'switch'operand is contained in any of the 'case' values. For example:
switch( 3 ) { case [1,3,5]: assert true break default: assert false}switchValue - the switch valueOverloads the left shift operator to provide an easy way to appendobjects to a Collection.
def list = [1,2]list << 3assert list == [1,2,3]
value - an Object to be added to the collection.Create a new Collection composed of the elements of the first Collection minusevery occurrence of elements of the given Collection.
assert [1, "a", true, true, false, 5.3] - [true, 5.3] == [1, "a", false]
removeMe - a Collection of elements to removeCreate a Collection as a union of a Collection and an Iterable. If the left collectionis a Set, then the returned collection will be a Set otherwise a List.This operation will always create a new object for the result,while the operands remain unchanged.
right - the right IterableCreate a collection as a union of a Collection and an Object. If the collectionis a Set, then the returned collection will be a Set otherwise a List.This operation will always create a new object for the result,while the operands remain unchanged.
assert [1,2,3] == [1,2] + 3
right - an object to add/appendCreate a Collection as a union of two collections. If the left collectionis a Set, then the returned collection will be a Set otherwise a List.This operation will always create a new object for the result,while the operands remain unchanged.
assert [1,2,3,4] == [1,2] + [3,4]
right - the right CollectionModifies this collection by removing the elements that are matched accordingto the specified closure condition.
def list = ['a', 'b']list.removeAll { it == 'b' }assert list == ['a']See alsofindAll andgrep when wanting to produce a new listcontaining items which match some criteria but leaving the original collection unchanged.condition - a closure conditionModifies this collection by removing its elements that are containedwithin the specified object array.See alsofindAll andgrep when wanting to produce a new listcontaining items which don't match some criteria while leaving the original collection unchanged.
items - array containing elements to be removed from this collectionModifies this collection by removing a single instance of the specifiedelement from this collection, if it is present. Essentially an alias forCollection#remove(Object) but with no ambiguity for Collection<Integer>.
Example:def list = [1, 2, 3, 2]list.removeElement(2)assert [1, 3, 2] == list
o - element to be removed from this collection, if presentModifies this collection so that it retains only its elementsthat are matched according to the specified closure condition. In other words,removes from this collection all of its elements that don't match.
def list = ['a', 'b']list.retainAll { it == 'b' }assert list == ['b']See alsofindAll andgrep when wanting to produce a new listcontaining items which match some criteria but leaving the original collection unchanged.condition - a closure conditionModifies this collection so that it retains only its elements that are containedin the specified array. In other words, removes from this collection all ofits elements that are not contained in the specified array.See alsogrep andfindAll when wanting to produce a new listcontaining items which match some specified items but leaving the original collection unchanged.
items - array containing elements to be retained from this collectionSplits all items into two collections based on the closure condition.The first list contains all items which match the closure expression.The second list all those that don't.
Example usage:
assert [[2,4],[1,3]] == [1,2,3,4].split { it % 2 == 0 }closure - a closure conditionReturns the string representation of the given list. The stringdisplays the contents of the list, similar to a list literal, i.e.[1, 2, a].
Returns the string representation of the given list. The stringdisplays the contents of the list, similar to a list literal, i.e.[1, 2, a].
maxSize - stop after approximately this many characters and append '...'Convert a Collection to a Set. Always returns a new Seteven if the Collection is already a Set.
Example usage:
def result = [1, 2, 2, 2, 3].toSet()assert result instanceof Setassert result == [1, 2, 3] as Set
Create a Collection composed of the union of both collections. Anyelements that exist in either collections are added to the resultant collection, suchthat no elements are duplicated in the resultant collection.For collections of custom objects; the objects should implement java.lang.Comparable
assert [1,2,3,4,5,6,7,8] == [1,2,3,4,5].union([4,5,6,7,8])By default, Groovy uses a NumberAwareComparator when determining if anelement exists in the resultant collection.
right - a CollectionCreate a Collection composed of the union of both collections. Anyelements that exist in either collections are added to the resultant collection, suchthat no elements are duplicated in the resultant collection.For collections of custom objects; the objects should implement java.lang.Comparable
assert [1,2,3,4,5,6] == [1,2,3,4].union([3,4,5,6], Comparator.naturalOrder())assert [4,8,12,16,20,1,3] == [4,8,12,16,20].union([1,2,3,4], (x, y)-> x * x<=> y)def one = ['a', 'B', 'c', 'd']def two = ['b', 'C', 'd', 'e']def compareIgnoreCase = { a, b-> a.toLowerCase()<=> b.toLowerCase() }assert one.union(two) == ['a', 'B', 'c', 'd', 'b', 'C', 'e']assert two.union(one) == ['b', 'C', 'd', 'e', 'a', 'B', 'c']assert one.union(two, compareIgnoreCase) == ['a', 'B', 'c', 'd', 'e']assert two.union(one, compareIgnoreCase) == ['b', 'C', 'd', 'e', 'a']right - a Collectioncomparator - a ComparatorModifies this collection to remove all duplicated items, using Groovy'sdefault number-aware comparator.
assert [1,3] == [1,3,3].unique()
Remove all duplicates from a given Collection using Groovy's default number-aware comparator.If mutate is true, it works by modifying the original object (and also returning it).If mutate is false, a new collection is returned leaving the original unchanged.
assert [1,3] == [1,3,3].unique()
def orig = [1, 3, 2, 3]def uniq = orig.unique(false)assert orig == [1, 3, 2, 3]assert uniq == [1, 3, 2]
mutate - false will return a new collection containing the unique items from the collection, true will mutate collections in place and return the original collectionA convenience method for making a collection unique using a Closure to determine duplicate (equal) items.If mutate is true, it works on the receiver object and returns it. If mutate is false, a new collection is returned.
If the closure takes a single parameter, each element from the Collection will be passed to the closure. The closureshould return a value used for comparison (either usingComparable#compareTo(java.lang.Object) orObject#equals(java.lang.Object)). If the closure takes two parameters, two items from the collectionwill be passed as arguments, and the closure should return an int value (with 0 indicating the items are not unique).
def orig = [1, 3, 4, 5]def uniq = orig.unique(false) { it % 2 }assert orig == [1, 3, 4, 5]assert uniq == [1, 4]def orig = [2, 3, 3, 4]def uniq = orig.unique(false) { a, b-> a<=> b }assert orig == [2, 3, 3, 4]assert uniq == [2, 3, 4]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 unique itemsRemove all duplicates from a given Collection.If mutate is true, it works on the original object (and also returns it). If mutate is false, a new collection is returned.The order of members in the Collection are compared by the given Comparator.For each duplicate, the first member which is returnedby the given Collection's iterator is retained, but all other ones are removed.The given Collection's original order is preserved.
class Person { def fname, lname String toString() { return fname + " " + lname }}class PersonComparator implements Comparator { int compare(Object o1, Object o2) { Person p1 = (Person) o1 Person p2 = (Person) o2 if (p1.lname != p2.lname) return p1.lname.compareTo(p2.lname) else return p1.fname.compareTo(p2.fname) } boolean equals(Object obj) { return this.equals(obj) }}Person a = new Person(fname:"John", lname:"Taylor")Person b = new Person(fname:"Clark", lname:"Taylor")Person c = new Person(fname:"Tom", lname:"Cruz")Person d = new Person(fname:"Clark", lname:"Taylor")def list = [a, b, c, d]List list2 = list.unique(false, new PersonComparator())assert( list2 != list&& list2 == [a, b, c] )mutate - false will always cause a new collection to be created, true will mutate collections in placecomparator - a ComparatorA convenience method for making a collection unique using a Closureto determine duplicate (equal) items.
If the closure takes a single parameter, theargument passed will be each element, and the closureshould return a value used for comparison (either usingComparable#compareTo(java.lang.Object) orObject#equals(java.lang.Object)).If the closure takes two parameters, two items from the collectionwill be passed as arguments, and the closure should return anint value (with 0 indicating the items are not unique).
assert [1,4] == [1,3,4,5].unique { it % 2 }assert [2,3,4] == [2,3,3,4].unique { a, b-> a<=> b }closure - a 1 or 2 arg Closure used to determine unique itemsRemove all duplicates from a given Collection.Works on the original object (and also returns it).The order of members in the Collection are compared by the given Comparator.For each duplicate, the first member which is returnedby the given Collection's iterator is retained, but all other ones are removed.The given Collection's original order is preserved.
class Person { def fname, lname String toString() { return fname + " " + lname }}class PersonComparator implements Comparator { int compare(Object o1, Object o2) { Person p1 = (Person) o1 Person p2 = (Person) o2 if (p1.lname != p2.lname) return p1.lname.compareTo(p2.lname) else return p1.fname.compareTo(p2.fname) } boolean equals(Object obj) { return this.equals(obj) }}Person a = new Person(fname:"John", lname:"Taylor")Person b = new Person(fname:"Clark", lname:"Taylor")Person c = new Person(fname:"Tom", lname:"Cruz")Person d = new Person(fname:"Clark", lname:"Taylor")def list = [a, b, c, d]List list2 = list.unique(new PersonComparator())assert( list2 == list&& list == [a, b, c] )comparator - a Comparator