addAll (int index, Object[] items) Modifies this list by inserting all the elements in the specified array into the list at the specified position. bufferedIterator () Returns a BufferedIterator that allows examining the next element without consuming it. dropWhile ( Closure condition) Returns a suffix of this List where elements are dropped from the front while the given Closure evaluates to true. grep ( Object filter) Iterates over the collection of items and returns each item that matches the given filter - calling the Object#isCase(java.lang.Object) method used by switch statements. leftShift ( Object value) Overloads the left shift operator to provide an easy way to append objects to a List. minus ( Iterable removeMe) Create a new List composed of the elements of the first List minus every occurrence of elements of the given Iterable. minus ( Object removeMe) Create a new List composed of the elements of the first List minus every occurrence of the given element to remove. minus ( Collection removeMe) Create a List composed of the elements of the first list minus every occurrence of elements of the given Collection. multiply ( Number factor) Create a List composed of the elements of this Iterable, repeated a certain number of times. plus (int index, Iterable additions) Creates a new List by inserting all the elements in the given Iterable to the elements from this List at the specified index. plus (int index, Object[] items) Creates a new List by inserting all the elements in the specified array to the elements from the original List at the specified index. plus (int index, List additions) Creates a new List by inserting all the elements in the given additions List to the elements from the original List at the specified index. putAt ( IntRange range, Collection col) List subscript assignment operator when given a range as the index and the assignment operand is a collection. shuffled ( Random rnd) Creates a new list containing the elements of the specified list but in a random order using the specified random instance as the source of randomness.

Methods inherited from interface java.util. Collection

addAll , addAll , addAll , asBoolean , asImmutable , asSynchronized , asType , asUnmodifiable , collectNested , each , eachWithIndex , find , find , findAll , findAll , flatten , getAt , getIndices , grep , grep , inject , inject , intersect , intersect , isCase , isNotCase , leftShift , minus , plus , plus , plus , removeAll , removeAll , removeElement , retainAll , retainAll , split , toListString , toListString , toSet , unique , unique , unique , unique , unique , unique

Methods inherited from interface java.lang. Iterable

any , asCollection , asList , asType , average , average , bufferedIterator , chop , collate , collate , collate , collate , collect , collect , collect , collectEntries , collectEntries , collectEntries , collectEntries , collectMany , collectMany , collectNested , collectNested , combinations , combinations , contains , containsAll , count , count , count , 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 , getAt , groupBy , groupBy , groupBy , head , indexed , indexed , init , inits , intersect , intersect , intersect , isEmpty , join , last , max , max , max , min , min , min , minus , minus , minus , minus , multiply , permutations , permutations , plus , plus , 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 , withIndex , withIndex

public boolean addAll (int index, Object[] items)

Modifies this list by inserting all the elements in the specified array into the list at the specified position. Shifts the element currently at that position (if any) and any subsequent elements to the right (increases their indices). The new elements will appear in this list in the order that they occur in the array. The behavior of this operation is undefined if the specified array is modified while the operation is in progress. See also plus for similar functionality with copy semantics, i.e. which produces a new list after adding the additional items at the specified position but leaves the original list unchanged.

Parameters:

items - array containing elements to be added to this collection

index - index at which to insert the first element from the specified array

public List asReversed ()

Creates a view list with reversed order, and the order of original list will not change. def list = ["a", 6, true] assert list.asReversed() == [true, 6, "a"] assert list == ["a", 6, true]

public BufferedIterator bufferedIterator ()

Returns a BufferedIterator that allows examining the next element without consuming it. assert [1, 2, 3, 4].bufferedIterator().with { [head(), toList()] } == [1, [1, 2, 3, 4]]

public List drop (int num)

Drops the given number of elements from the head of this List. def strings = [ 'a', 'b', 'c' ] assert strings.drop( 0 ) == [ 'a', 'b', 'c' ] assert strings.drop( 2 ) == [ 'c' ] assert strings.drop( 5 ) == []

Returns:

a List consisting of all the elements of this Iterable minus the first num elements, or an empty list if it has less than num elements.

public List dropRight (int num)

Drops the given number of elements from the tail of this List. def strings = [ 'a', 'b', 'c' ] assert strings.dropRight( 0 ) == [ 'a', 'b', 'c' ] assert strings.dropRight( 2 ) == [ 'a' ] assert strings.dropRight( 5 ) == []

public List dropWhile ( Closure condition)

Returns a suffix of this List where elements are dropped from the front while the given Closure evaluates to true. Similar to Iterable#dropWhile(groovy.lang.Closure) except that it attempts to preserve the type of the original list. def nums = [ 1, 3, 2 ] assert nums.dropWhile{ it < 4 } == [] assert nums.dropWhile{ it < 3 } == [ 3, 2 ] assert nums.dropWhile{ it != 2 } == [ 2 ] assert nums.dropWhile{ it == 0 } == [ 1, 3, 2 ]

public boolean equals ( Object[] right)

Determines if the contents of this list are equal to the contents of the given array in the same order. This returns false if either collection is null .

assert [1, "a"].equals( [ 1, "a" ] as Object[] )

Parameters:

right - the Object[] being compared to

Compare the contents of two Lists. Order matters. If numbers exist in the Lists, then they are compared as numbers, for example 2 == 2L. If both lists are null , the result is true; otherwise if either list is null , the result is false .

assert ["a", 2].equals(["a", 2])
assert ![2, "a"].equals("a", 2)
assert [2.0, "a"].equals(2L, "a") // number comparison at work

Parameters:

right - the List being compared to

public Process execute ()

Executes the command specified by the given list. The toString() method is called for each item in the list to convert into a resulting String. The first item in the list is the command the others are the parameters.

For more control over Process construction you can use java.lang.ProcessBuilder .

public Process execute ( String[] envp, File dir)

Executes the command specified by the given list, with the environment defined by envp and under the working directory dir . The first item in the list is the command; the others are the parameters. The toString() method is called on items in the list to convert them to Strings.

For more control over Process construction you can use java.lang.ProcessBuilder .

Parameters:

- an array of Strings, each member of which has environment variable settings in the format name = value , or null if the subprocess should inherit the environment of the current process. - the working directory of the subprocess, or null if the subprocess should inherit the working directory of the current process.

public Process execute ( List envp, File dir)

Executes the command specified by the given list, with the environment defined by envp and under the working directory dir . The first item in the list is the command; the others are the parameters. The toString() method is called on items in the list to convert them to Strings.

For more control over Process construction you can use java.lang.ProcessBuilder .

Parameters:

- a List of Objects (converted to Strings using toString), each member of which has environment variable settings in the format name = value , or null if the subprocess should inherit the environment of the current process. - the working directory of the subprocess, or null if the subprocess should inherit the working directory of the current process.

public List findAll ()

Finds 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]]

Flatten a List. This List and any nested arrays or collections have their contents (recursively) added to the new List.

assert [1,2,3,4,5] == [1,[2,3],[[4]],[],5].flatten()

public List getAt ( Collection indices)

Select a List of items from a List using a Collection to identify the indices to be selected.

def list = [true, 1, 3.4, false]
assert list[1,0,2] == [1, true, 3.4]

Parameters:

indices - a Collection of indices

Iterates over the collection returning each element that matches using 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]]

public List grep ( Object filter)

Iterates over the collection of items and returns each item that matches the given filter - calling the Object#isCase(java.lang.Object) method used by switch statements. This method can be used with different kinds 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 ]

public List init ()

Returns the items from the List excluding the last item. Leaves the original List unchanged. def list = [3, 4, 2] assert list.init() == [3, 4] assert list == [3, 4, 2]

public List intersect ( Iterable right)

Create a List composed of the intersection of a List and an Iterable. Any elements that exist in both iterables are added to the resultant collection. assert [4,5] == [1,2,3,4,5].intersect([4,5,6,7,8]) By default, Groovy uses a NumberAwareComparator when determining if an element exists in both collections.

Parameters:

right - an Iterable

public List intersect ( Iterable right, Comparator comparator)

Create a List composed of the intersection of a List and an Iterable. Any elements that exist in both iterables are added to the resultant collection. assert [3,4] == [1,2,3,4].intersect([3,4,5,6])

public List leftShift ( Object value)

Overloads the left shift operator to provide an easy way to append objects to a List.

def list = [1,2]
list << 3
assert list == [1,2,3]

Parameters:

value - an Object to be added to the List.

public List minus ( Iterable removeMe)

Create a new List composed of the elements of the first List minus every occurrence of elements of the given Iterable.

assert [1, "a", true, true, false, 5.3] - [true, 5.3] == [1, "a", false]

Parameters:

removeMe - an Iterable of elements to remove

public List minus ( Object removeMe)

Create a new List composed of the elements of the first List minus every occurrence of the given element to remove.

assert ["a", 5, 5, true] - 5 == ["a", true]

Parameters:

removeMe - an element to remove from the List

public List minus ( Collection removeMe)

Create a List composed of the elements of the first list minus every occurrence of elements of the given Collection.

assert [1, "a", true, true, false, 5.3] - [true, 5.3] == [1, "a", false]

Parameters:

removeMe - a Collection of elements to remove

public List multiply ( Number factor)

Create a List composed of the elements of this Iterable, repeated a certain number of times. Note that for non-primitive elements, multiple references to the same instance will be added.

assert [1,2,3,1,2,3] == [1,2,3] * 2

Note: if the Iterable happens to not support duplicates, e.g. a Set, then the method will effectively return a Collection with a single copy of the Iterable's items.

Parameters:

factor - the number of times to append

public List plus (int index, Iterable additions)

Creates a new List by inserting all the elements in the given Iterable to the elements from this List at the specified index.

Parameters:

additions - an Iterable containing elements to be merged with the elements from the original List

index - index at which to insert the first element from the given additions Iterable

public List plus (int index, Object[] items)

Creates a new List by inserting all the elements in the specified array to the elements from the original List at the specified index. Shifts the element currently at that index (if any) and any subsequent elements to the right (increasing their indices). The new elements will appear in the resulting List in the order that they occur in the original array. The behavior of this operation is undefined if the list or array operands are modified while the operation is in progress. The original list and array operands remain unchanged. def items = [1, 2, 3] def newItems = items.plus(2, 'a'..'c' as String[]) assert newItems == [1, 2, 'a', 'b', 'c', 3] assert items == [1, 2, 3] See also addAll for similar functionality with modify semantics, i.e. which performs the changes on the original list itself.

Parameters:

items - array containing elements to be merged with elements from the original list

index - index at which to insert the first element from the specified array

public List plus (int index, List additions)

Creates a new List by inserting all the elements in the given additions List to the elements from the original List at the specified index. Shifts the element currently at that index (if any) and any subsequent elements to the right (increasing their indices). The new elements will appear in the resulting List in the order that they occur in the original lists. The behavior of this operation is undefined if the original lists are modified while the operation is in progress. The original lists remain unchanged. def items = [1, 2, 3] def newItems = items.plus(2, 'a'..'c') assert newItems == [1, 2, 'a', 'b', 'c', 3] assert items == [1, 2, 3] See also addAll for similar functionality with modify semantics, i.e. which performs the changes on the original list itself.

Parameters:

additions - a List containing elements to be merged with elements from the original List

index - index at which to insert the first element from the given additions List

Create a List as a union of a List and an Iterable. This operation will always create a new object for the result, while the operands remain unchanged.

Parameters:

right - the right Iterable

Create a List as a union of a List and an Object. This operation will always create a new object for the result, while the operands remain unchanged.

assert [1,2,3] == [1,2] + 3

Parameters:

right - an object to add/append

public List plus ( Collection right)

Create a List as a union of a List and a Collection. This operation will always create a new object for the result, while the operands remain unchanged.

Parameters:

right - the right Collection

This is similar to pop on a Stack where the first item in the list represents the top of the stack. Note: The behavior of this method changed in Groovy 2.5 to align with Java. If you need the old behavior use 'removeLast'. This is similar to push on a Stack where the first item in the list represents the top of the stack. Note: The behavior of this method changed in Groovy 2.5 to align with Java. If you need the old behavior use 'add'.

Parameters:

value - element to be prepended to this list.

public void putAt ( EmptyRange range, Object value)

A helper method to allow lists to work with subscript operators. def list = ["a", true] list[1..<1] = 5 assert list == ["a", 5, true]

public void putAt ( EmptyRange range, Collection value)

A helper method to allow lists to work with subscript operators. def list = ["a", true] list[1..<1] = [4, 3, 2] assert list == ["a", 4, 3, 2, true]

public void putAt ( IntRange range, Object value)

List subscript assignment operator when given a range as the index. Example:

def myList = [4, 3, 5, 1, 2, 8, 10]
myList[3..5] = "b"
assert myList == [4, 3, 5, "b", 10]

Items in the given range are replaced with the operand. The value operand is always treated as a single value.

Parameters:

range - the subset of the list to set

value - the value to put at the given sublist

public void putAt ( IntRange range, Collection col)

List subscript assignment operator when given a range as the index and the assignment operand is a collection. Example:

def myList = [4, 3, 5, 1, 2, 8, 10]
myList[3..5] = ["a", true]
assert myList == [4, 3, 5, "a", true, 10]

Items in the given range are replaced with items from the collection.

Parameters:

range - the subset of the list to set

col - the collection of values to put at the given sublist

public void putAt (int idx, Object value)

A helper method to allow lists to work with subscript operators.

def list = [2, 3]
list[0] = 1
assert list == [1, 3]

Parameters:

idx - an index

value - the value to put at the given index

public void putAt ( List splice, Object value)

A helper method to allow lists to work with subscript operators.

def list = ["a", true, 42, 9.4]
list[1, 3] = 5
assert list == ["a", 5, 42, 5]

Parameters:

splice - the subset of the list to set

value - the value to put at the given sublist

public void putAt ( List splice, Collection values)

A helper method to allow lists to work with subscript operators.

def list = ["a", true, 42, 9.4]
list[1, 4] = ["x", false]
assert list == ["a", "x", 42, 9.4, false]

Parameters:

splice - the subset of the list to set

values - the value to put at the given sublist

public Object removeAt (int index)

Modifies this list by removing the element at the specified position in this list. Returns the removed element. Essentially an alias for List#remove(int) but with no ambiguity for List<Integer>. Example: def list = [1, 2, 3] list.removeAt(1) assert [1, 3] == list

public List reverse (boolean mutate)

Reverses the elements in a list. If mutate is true, the original list is modified in place and returned. Otherwise, a new list containing the reversed items is produced. def list = ["a", 4, false] assert list.reverse(false) == [false, 4, "a"] assert list == ["a", 4, false] assert list.reverse(true) == [false, 4, "a"] assert list == [false, 4, "a"]

public List reverseEach ( Closure closure)

Iterate over each element of the list in the reverse order.

def result = []
[1,2,3].reverseEach { result << it }
assert result == [3,2,1]

Parameters:

closure - a closure to which each item is passed.

public void shuffle ( Random rnd)

Randomly reorders the elements of the specified list using the specified random instance as the source of randomness. def r = new Random() def list = ["a", 4, false] def origSize = list.size() def origCopy = new ArrayList(list) list.shuffle(r) assert list.size() == origSize assert origCopy.every{ list.contains(it) }

public List shuffled ()

Creates a new list containing the elements of the specified list but in a random order. def list = ["a", 4, false] def result = list.shuffled() assert list !== result assert list == ["a", 4, false] assert list.size() == result.size() assert list.every{ result.contains(it) }

public List shuffled ( Random rnd)

Creates a new list containing the elements of the specified list but in a random order using the specified random instance as the source of randomness. def r = new Random() def list = ["a", 4, false] def result = list.shuffled(r) assert list !== result assert list == ["a", 4, false] assert list.size() == result.size() assert list.every{ result.contains(it) }

public List split ( Closure closure)

Splits 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 }

Parameters:

closure - a closure condition

Returns the first num elements from the head of this List. def strings = [ 'a', 'b', 'c' ] assert strings.take( 0 ) == [] assert strings.take( 2 ) == [ 'a', 'b' ] assert strings.take( 5 ) == [ 'a', 'b', 'c' ]

public List takeRight (int num)

Returns the last num elements from the tail of this List. def strings = [ 'a', 'b', 'c' ] assert strings.takeRight( 0 ) == [] assert strings.takeRight( 2 ) == [ 'b', 'c' ] assert strings.takeRight( 5 ) == [ 'a', 'b', 'c' ]

public List takeWhile ( Closure condition)

Returns the longest prefix of this list where each element passed to the given closure condition evaluates to true. Similar to Iterable#takeWhile(groovy.lang.Closure) except that it attempts to preserve the type of the original list. def nums = [ 1, 3, 2 ] assert nums.takeWhile{ it < 1 } == [] assert nums.takeWhile{ it < 3 } == [ 1 ] assert nums.takeWhile{ it < 4 } == [ 1, 3, 2 ]

public List toUnique ()

Returns a List containing the items from the List but with duplicates removed using the natural ordering of the items to determine uniqueness. def letters = ['c', 'a', 't', 's', 'a', 't', 'h', 'a', 't'] def expected = ['c', 'a', 't', 's', 'h'] assert letters.toUnique() == expected

public List toUnique ( Closure condition)

Returns a List containing the items from the List but with duplicates removed. The items in the List are compared by the given Closure condition. For each duplicate, the first member which is returned from the Iterable is retained, but all other ones are removed. If the closure takes a single parameter, each element from the Iterable will be passed to the closure. The closure should return a value used for comparison (either using Comparable#compareTo(java.lang.Object) or Object#equals(java.lang.Object) ). If the closure takes two parameters, two items from the Iterable will be passed as arguments, and the closure should return an int value (with 0 indicating the items are not unique). class Person { def fname, lname String toString() { return fname + " " + lname 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] def list2 = list.toUnique{ p1, p2 -> p1.lname != p2.lname ? p1.lname <=> p2.lname : p1.fname <=> p2.fname } assert( list2 == [a, b, c] && list == [a, b, c, d] ) def list3 = list.toUnique{ it.toString() } assert( list3 == [a, b, c] && list == [a, b, c, d] )

public List toUnique ( Comparator comparator)

Returns a List containing the items from the List but with duplicates removed. The items in the List are compared by the given Comparator. For each duplicate, the first member which is returned from the List is retained, but all other ones are removed. 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) 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.toUnique(new PersonComparator()) assert list2 == [a, b, c] && list == [a, b, c, d]

Adds GroovyCollections#transpose(List) as a method on lists. A Transpose Function takes a collection of columns and returns a collection of rows. The first row consists of the first element from each column. Successive rows are constructed similarly. Example usage: def result = [['a', 'b'], [1, 2]].transpose() assert result == [['a', 1], ['b', 2]] def result = [['a', 'b'], [1, 2], [3, 4]].transpose() assert result == [['a', 1, 3], ['b', 2, 4]]

Modifies this List to remove all duplicated items, using Groovy's default number-aware comparator.

assert [1,3] == [1,3,3].unique()

public List unique (boolean mutate)

Remove all duplicates from a given List 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]

public List unique (boolean mutate, Closure closure)

A convenience method for making a List 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 List will be passed to the closure. The closure should return a value used for comparison (either using Comparable#compareTo(java.lang.Object) or Object#equals(java.lang.Object) ). If the closure takes two parameters, two items from the collection will 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]

Parameters:

mutate - false will always cause a new list to be created, true will mutate lists in place

closure - a 1 or 2 arg Closure used to determine unique items

public List unique (boolean mutate, Comparator comparator)

Remove all duplicates from a given List. If mutate is true, it works on the original object (and also returns it). If mutate is false, a new List is returned. The order of members in the List are compared by the given Comparator. For each duplicate, the first member which is returned by the given List's iterator is retained, but all other ones are removed. The given List'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) 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] )

Parameters:

mutate - false will always cause a new List to be created, true will mutate List in place

comparator - a Comparator

public List unique ( Closure closure)

A convenience method for making a List unique using a Closure to determine duplicate (equal) items. If the closure takes a single parameter, the argument passed will be each element, and the closure should return a value used for comparison (either using Comparable#compareTo(java.lang.Object) or Object#equals(java.lang.Object) ). If the closure takes two parameters, two items from the List will be passed as arguments, and the closure should return an int 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 }

Parameters:

closure - a 1 or 2 arg Closure used to determine unique items

Remove all duplicates from a given List. Works on the original object (and also returns it). The order of members in the List are compared by the given Comparator. For each duplicate, the first member which is returned by the given List's iterator is retained, but all other ones are removed. The given List'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) 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] )

public ListWithDefault withDefault ( Closure init)

An alias for withLazyDefault which decorates a list allowing it to grow when called with index values outside the normal list bounds.

Parameters:

init - a Closure with the target index as parameter which generates the default value

public ListWithDefault withEagerDefault ( Closure init)

Decorates a list allowing it to grow when called with a non-existent index value. When called with such values, the list is grown in size and a default value is placed in the list by calling a supplied init Closure. Null values can be stored in the list. How it works: The decorated list intercepts all calls to getAt(index) and get(index) . If an index greater than or equal to the current size() is used, the list will grow automatically up to the specified index. Gaps will be filled by calling the init Closure. If generating a default value is a costly operation consider using withLazyDefault . Example usage: def list = [0, 1].withEagerDefault{ 42 } assert list[0] == 0 assert list[1] == 1 assert list[3] == 42 // default value assert list == [0, 1, 42, 42] // gap filled with default value // illustrate using the index when generating default values def list2 = [5].withEagerDefault{ index -> index * index } assert list2[3] == 9 assert list2 == [5, 1, 4, 9] // illustrate what happens with null values list2[2] = null assert list2[2] == null assert list2 == [5, 1, null, 9]

public ListWithDefault withLazyDefault ( Closure init)

Decorates a list allowing it to grow when called with a non-existent index value. When called with such values, the list is grown in size and a default value is placed in the list by calling a supplied init Closure. Subsequent retrieval operations if finding a null value in the list assume it was set as null from an earlier growing operation and again call the init Closure to populate the retrieved value; consequently the list can't be used to store null values. How it works: The decorated list intercepts all calls to getAt(index) and get(index) . If an index greater than or equal to the current size() is used, the list will grow automatically up to the specified index. Gaps will be filled by null . If a default value should also be used to fill gaps instead of null , use withEagerDefault . If getAt(index) or get(index) are called and a null value is found, it is assumed that the null value was a consequence of an earlier grow list operation and the init Closure is called to populate the value. Example usage: def list = [0, 1].withLazyDefault{ 42 } assert list[0] == 0 assert list[1] == 1 assert list[3] == 42 // default value assert list == [0, 1, null, 42] // gap filled with null // illustrate using the index when generating default values def list2 = [5].withLazyDefault{ index -> index * index } assert list2[3] == 9 assert list2 == [5, null, null, 9] assert list2[2] == 4 assert list2 == [5, null, 4, 9] // illustrate what happens with null values list2[2] = null assert list2[2] == 4