Movatterモバイル変換

Methods Summary

Methods
Return type	Name and parameters
`boolean`	`addAll(int index,Object[] items)` Modifies this list by inserting all the elements in the specified array into thelist at the specified position.
`List`	`asChecked(Class type)` Creates a checked view of a List.
`List`	`asImmutable()` A convenience method for creating an immutable List.
`List`	`asReversed()` Creates a view list with reversed order, and the order of original list will not change.
`List`	`asSynchronized()` Creates a synchronized view of a List.
`List`	`asUnmodifiable()` Creates an unmodifiable view of a List.
`BufferedIterator`	`bufferedIterator()` Returns a`BufferedIterator` that allows examining the next element withoutconsuming it.
`List`	`drop(int num)` Drops the given number of elements from the head of this List.
`List`	`dropRight(int num)` Drops the given number of elements from the tail of this List.
`List`	`dropWhile(Closure condition)` Returns a suffix of this List where elements are dropped from the frontwhile the given Closure evaluates to true.
`List`	`each(Closure closure)` Iterates through a List, passing each item to the given closure.
`List`	`eachWithIndex(Closure closure)` Iterates through a List,passing each item and the item's index (a counter starting atzero) to the given closure.
`boolean`	`equals(Object[] right)` Determines if the contents of this list are equal to thecontents of the given array in the same order.
`boolean`	`equals(List right)` Compare the contents of two Lists.
`Process`	`execute()` Executes the command specified by the given list.
`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`.
`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`.
`List`	`findAll()` Finds the items matching the IDENTITY Closure (i.e. matching Groovy truth).
`List`	`findAll(Closure closure)` Finds all values matching the closure condition.
`Object`	`first()` Returns the first item from the List.
`List`	`flatten()` Flatten a List.
`List`	`getAt(EmptyRange range)` Support the range subscript operator for a List.
`List`	`getAt(Range range)` Support the range subscript operator for a List.
`Object`	`getAt(int idx)` Support the subscript operator for a List.
`Object`	`getAt(Number idx)` Support subscript operator for list access.
`List`	`getAt(Collection indices)` Select a List of items from a List using a Collection toidentify the indices to be selected.
`List`	`grep()` Iterates over the collection returning each element that matchesusing the IDENTITY Closure as a filter - effectively returning all elements which satisfy Groovy truth.
`List`	`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.
`Object`	`head()` Returns the first item from the List.
`List`	`init()` Returns the items from the List excluding the last item.
`List`	`intersect(Iterable right)` Create a List composed of the intersection of a List and an Iterable.
`List`	`intersect(Iterable right,Comparator comparator)` Create a List composed of the intersection of a List and an Iterable.
`Object`	`last()` Returns the last item from the List.
`List`	`leftShift(Object value)` Overloads the left shift operator to provide an easy way to appendobjects to a List.
`List`	`minus(Iterable removeMe)` Create a new List composed of the elements of the first List minusevery occurrence of elements of the given Iterable.
`List`	`minus(Object removeMe)` Create a new List composed of the elements of the first List minus every occurrence of thegiven element to remove.
`List`	`minus(Collection removeMe)` Create a List composed of the elements of the first list minusevery occurrence of elements of the given Collection.
`List`	`multiply(Number factor)` Create a List composed of the elements of this Iterable, repeateda certain number of times.
`int`	`partitionPoint(IntRange range,Predicate condition)` Returns the index of the partition point according to the given predicate(the index of the first element of the second partition).
`int`	`partitionPoint(Predicate condition)` Returns the index of the partition point according to the given predicate(the index of the first element of the second partition).
`List`	`plus(int index,Iterable additions)` Creates a new List by inserting all the elements in the given Iterableto the elements from this List at the specified index.
`List`	`plus(int index,Object[] items)` Creates a new List by inserting all the elements in the specified arrayto the elements from the original List at the specified index.
`List`	`plus(int index,List additions)` Creates a new List by inserting all the elements in the given additions Listto the elements from the original List at the specified index.
`List`	`plus(Iterable right)` Create a List as a union of a List and an Iterable.
`List`	`plus(Object right)` Create a List as a union of a List and an Object.
`List`	`plus(Collection right)` Create a List as a union of a List and a Collection.
`Object`	`pop()` Removes the initial item from the List.
`boolean`	`push(Object value)` Prepends an item to the start of the List.
`void`	`putAt(EmptyRange range,Object value)` A helper method to allow lists to work with subscript operators.
`void`	`putAt(EmptyRange range,Collection value)` A helper method to allow lists to work with subscript operators.
`void`	`putAt(IntRange range,Object value)` List subscript assignment operator when given a range as the index.
`void`	`putAt(IntRange range,Collection col)` List subscript assignment operator when given a range as the index andthe assignment operand is a collection.
`void`	`putAt(int idx,Object value)` A helper method to allow lists to work with subscript operators.
`void`	`putAt(Number idx,Object value)` Support subscript operator for list modification.
`void`	`putAt(List splice,Object value)` A helper method to allow lists to work with subscript operators.
`void`	`putAt(List splice,Collection values)` A helper method to allow lists to work with subscript operators.
`Object`	`removeAt(int index)` Modifies this list by removing the element at the specified positionin this list.
`Object`	`removeLast()` Removes the last item from the List.
`List`	`reverse()` Creates a new List with the identical contents to this listbut in reverse order.
`List`	`reverse(boolean mutate)` Reverses the elements in a list.
`List`	`reverseEach(Closure closure)` Iterate over each element of the list in the reverse order.
`void`	`shuffle()` Randomly reorders the elements of the specified list.
`void`	`shuffle(Random rnd)` Randomly reorders the elements of the specified list using thespecified random instance as the source of randomness.
`List`	`shuffled()` Creates a new list containing the elements of the specified listbut in a random order.
`List`	`shuffled(Random rnd)` Creates a new list containing the elements of the specified list but in a randomorder using the specified random instance as the source of randomness.
`List`	`sort(IntRange range)` A mutating sort variant that takes an index range.
`List`	`sort(IntRange range, boolean mutate,Closure closure)` Sorts elements in the given index range using the given Closure to determine the ordering.
`List`	`sort(IntRange range, boolean mutate,Comparator comparator)` Sorts the Iterable using the given Comparator over the given index range.
`List`	`sort(IntRange range,Closure closure)` A sort variant that takes an index range and always mutates the original list.
`List`	`sort(IntRange range,Comparator comparator)` Sorts the Iterable using the given Comparator over the given index range.
`List`	`split(Closure closure)` Splits all items into two collections based on the closure condition.
`List`	`subList(IntRange range)` Returns a view of the portion of this list given by the specified range.
`Set`	`subsequences()` Finds all non-null subsequences of a list.
`List`	`swap(int i, int j)` Swaps two elements at the specified positions.
`List`	`tail()` Returns the items from the List excluding the first item.
`List`	`take(int num)` Returns the first`num` elements from the head of this List.
`List`	`takeRight(int num)` Returns the last`num` elements from the tail of this List.
`List`	`takeWhile(Closure condition)` Returns the longest prefix of this list where each elementpassed to the given closure condition evaluates to true.
`List`	`toSorted(IntRange range)` Returns a list, sorted over the given rangeusing a NumberAwareComparator, leaving the original list unmodified.
`List`	`toSorted(IntRange range,Closure closure)` A sort variant that takes an index range and never modifies the original list.
`List`	`toSorted(IntRange range,Comparator comparator)` Returns a list, sorted over the given rangeusing a NumberAwareComparator, leaving the original list unmodified.
`SpreadMap`	`toSpreadMap()` Creates a spreadable map from this list.
`List`	`toUnique()` Returns a List containing the items from the List but with duplicates removedusing the natural ordering of the items to determine uniqueness.
`List`	`toUnique(Closure condition)` Returns a List containing the items from the List but with duplicates removed.
`List`	`toUnique(Comparator comparator)` Returns a List containing the items from the List but with duplicates removed.
`List`	`transpose()` Adds GroovyCollections#transpose(List) as a method on lists.
`List`	`union(Iterable right)` Create a List composed of the union of a List and an Iterable.
`List`	`union(Iterable right,Comparator comparator)` Create a List composed of the union of a List and an Iterable.
`List`	`unique()` Modifies this List to remove all duplicated items, using Groovy'sdefault number-aware comparator.
`List`	`unique(boolean mutate)` Remove all duplicates from a given List using Groovy's default number-aware comparator.
`List`	`unique(boolean mutate,Closure closure)` A convenience method for making a List unique using a Closure to determine duplicate (equal) items.
`List`	`unique(boolean mutate,Comparator comparator)` Remove all duplicates from a given List.
`List`	`unique(Closure closure)` A convenience method for making a List unique using a Closureto determine duplicate (equal) items.
`List`	`unique(Comparator comparator)` Remove all duplicates from a given List.
`ListWithDefault`	`withDefault(Closure init)` An alias for`withLazyDefault` which decorates a list allowingit to grow when called with index values outside the normal list bounds.
`ListWithDefault`	`withEagerDefault(Closure init)` Decorates a list allowing it to grow when called with a non-existent index value.
`ListWithDefault`	`withLazyDefault(Closure init)` Decorates a list allowing it to grow when called with a non-existent index value.

Methods inherited from interface java.util.Collection
addAll,addAll,addAll,asBoolean,asChecked,asImmutable,asSynchronized,asType,asUnmodifiable,collectNested,each,eachWithIndex,find,find,findAll,findAll,flatten,getAt,getIndices,grep,grep,intersect,intersect,isCase,isNotCase,leftShift,minus,plus,plus,plus,removeAll,removeAll,removeElement,retainAll,retainAll,split,toListString,toListString,toSet,union,union,unique,unique,unique,unique,unique,unique

Methods inherited from interface java.lang.Iterable
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

- Methods Detail
  - public booleanaddAll(int index,Object[] items)
    Modifies this list by inserting all the elements in the specified array into thelist at the specified position. Shifts theelement currently at that position (if any) and any subsequentelements to the right (increases their indices). The new elementswill appear in this list in the order that they occur in the array.The behavior of this operation is undefined if the specified arrayis modified while the operation is in progress.See alsoplus for similar functionality with copy semantics, i.e. which produces a newlist 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
    Returns:
    true if this collection changed as a result of the call
    Since:
    1.7.2
    See Also:
    List#addAll(int, Collection)
  - publicListasChecked(Class type)
    Creates a checked view of a List.
    Parameters:
    Since:
    5.0.0
    See Also:
    Collections#checkedList
  - publicListasImmutable()
    A convenience method for creating an immutable List.
```
def mutable = [1,2,3]def immutable = mutable.asImmutable()try {    immutable << 4    assert false} catch (UnsupportedOperationException) {    assert true}mutable << 4assert mutable.size() == 4assert immutable.size() == 3
```
    Returns:
    an unmodifiable view of a copy of the original, i.e. an effectively immutable copy
    Since:
    1.0
    See Also:
    List#asUnmodifiable()
  - publicListasReversed()
    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]
```
    Returns:
    the reversed list
    Since:
    4.0.0
  - publicListasSynchronized()
    Creates a synchronized view of a List.
    Returns:
    a synchronized List
    Since:
    1.0
    See Also:
    Collections#synchronizedList(java.util.List)
  - publicListasUnmodifiable()
    Creates an unmodifiable view of a List.
```
def mutable = [1,2,3]def unmodifiable = mutable.asUnmodifiable()try {    unmodifiable << 4    assert false} catch (UnsupportedOperationException) {    assert true}mutable << 4assert unmodifiable.size() == 4
```
    Returns:
    an unmodifiable view of the List
    Since:
    2.5.0
    See Also:
    Collections#unmodifiableList(java.util.List)
  - publicBufferedIteratorbufferedIterator()
    Returns aBufferedIterator that allows examining the next element withoutconsuming it.
```
assert [1, 2, 3, 4].bufferedIterator().with { [head(), toList()] } == [1, [1, 2, 3, 4]]
```
    Returns:
    a BufferedIterator for traversing self
    Since:
    2.5.0
  - publicListdrop(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 ) == []
```
    Parameters:
    num - the number of elements to drop from this Iterable
    Returns:
    a List consisting of all the elements of this Iterable minus the firstnum elements, or an empty list if it has less thannum elements.
    Since:
    1.8.1
  - publicListdropRight(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 ) == []
```
    Parameters:
    num - the number of elements to drop from this List
    Returns:
    a List consisting of all the elements of this List minus the lastnum elements, or an empty List if it has less thannum elements.
    Since:
    2.4.0
  - publicListdropWhile(Closure condition)
    Returns a suffix of this List where elements are dropped from the frontwhile 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 ]
```
    Parameters:
    condition - the closure that must evaluate to true to continue dropping elements
    Returns:
    the shortest suffix of the given List such that the given closure condition evaluates to true for each element dropped from the front of the List
    Since:
    1.8.7
  - publicListeach(Closure closure)
    Iterates through a List, passing each item to the given closure.
    Parameters:
    closure - the closure applied on each element found
    Returns:
    the self List
    Since:
    2.4.0
  - publicListeachWithIndex(Closure closure)
    Iterates through a List,passing each item and the item's index (a counter starting atzero) to the given closure.
    Parameters:
    closure - a Closure to operate on each item
    Returns:
    the self List
    Since:
    2.4.0
  - public booleanequals(Object[] right)
    Determines if the contents of this list are equal to thecontents of the given array in the same order. This returnsfalse if either collection isnull.
```
assert [1, "a"].equals( [ 1, "a" ] as Object[] )
```
    Parameters:
    right - the Object[] being compared to
    Returns:
    true if the contents of both collections are equal
    Since:
    1.5.0
  - public booleanequals(List right)
    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 arenull, the resultis true; otherwise if either list isnull, the resultisfalse.
```
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
    Returns:
    booleantrue if the contents of both lists are identical,false otherwise.
    Since:
    1.0
  - publicProcessexecute()
    Executes the command specified by the given list. The toString() method is calledfor 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 usejava.lang.ProcessBuilder.
    Returns:
    the Process which has just started for this command line representation.
    Since:
    1.0
  - publicProcessexecute(String[] envp,File dir)
    Executes the command specified by the given list,with the environment defined byenvp and under the working directorydir.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 usejava.lang.ProcessBuilder.
    Parameters:
    envp - an array of Strings, each member of which has environment variable settings in the formatname=value, ornull if the subprocess should inherit the environment of the current process.
    dir - the working directory of the subprocess, ornull if the subprocess should inherit the working directory of the current process.
    Returns:
    the Process which has just started for this command line representation.
    Since:
    1.7.1
  - publicProcessexecute(List envp,File dir)
    Executes the command specified by the given list,with the environment defined byenvp and under the working directorydir.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 usejava.lang.ProcessBuilder.
    Parameters:
    envp - a List of Objects (converted to Strings using toString), each member of which has environment variable settings in the formatname=value, ornull if the subprocess should inherit the environment of the current process.
    dir - the working directory of the subprocess, ornull if the subprocess should inherit the working directory of the current process.
    Returns:
    the Process which has just started for this command line representation.
    Since:
    1.7.1
  - publicListfindAll()
    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]]
```
    Returns:
    a List of the truthy values
    Since:
    2.4.0
    See Also:
    Closure#IDENTITY
  - publicListfindAll(Closure closure)
    Finds all values matching the closure condition.
```
assert [2,4] == [1,2,3,4].findAll { it % 2 == 0 }
```
    Parameters:
    closure - a closure condition
    Returns:
    a List of matching values
    Since:
    2.4.0
  - publicObjectfirst()
    Returns the first item from the List.
```
def list = [3, 4, 2]assert list.first() == 3// check original is unalteredassert list == [3, 4, 2]
```
    Returns:
    the first item from the List
    Since:
    1.5.5
  - publicListflatten()
    Flatten a List. This List and any nested arrays orcollections have their contents (recursively) added to the new List.
```
assert [1,2,3,4,5] == [1,[2,3],[[4]],[],5].flatten()
```
    Returns:
    a flattened List
    Since:
    2.4.0
  - publicListgetAt(EmptyRange range)
    Support the range subscript operator for a List.
```
def list = [true, 1, 3.4]assert list[0..<0] == []
```
    Parameters:
    range - a Range indicating the items to get
    Returns:
    a new list instance based on range borders
    Since:
    1.0
  - publicListgetAt(Range range)
    Support the range subscript operator for a List.
```
def list = [1, "a", 4.5, true]assert list[1..2] == ["a", 4.5]
```
    Parameters:
    range - a Range indicating the items to get
    Returns:
    a new list instance based on range borders
    Since:
    1.0
  - publicObjectgetAt(int idx)
    Support the subscript operator for a List.
```
def list = [2, "a", 5.3]assert list[1] == "a"
```
    Parameters:
    idx - an index
    Returns:
    the value at the given index
    Since:
    1.0
  - publicObjectgetAt(Number idx)
    Support subscript operator for list access.
    Parameters:
  - publicListgetAt(Collection indices)
    Select a List of items from a List using a Collection toidentify 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
    Returns:
    a new list of the values at the given indices
    Since:
    1.0
  - publicListgrep()
    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]]
```
    Returns:
    a List of elements satisfy Groovy truth
    Since:
    2.4.0
    See Also:
    Closure#IDENTITY
  - publicListgrep(Object filter)
    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. This 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 ]
```
    Parameters:
    filter - the filter to perform on each element of the collection (using theObject#isCase(java.lang.Object) method)
    Returns:
    a List of objects which match the filter
    Since:
    2.4.0
  - publicObjecthead()
    Returns the first item from the List.
```
def list = [3, 4, 2]assert list.head() == 3assert list == [3, 4, 2]
```
    Returns:
    the first item from the List
    Since:
    1.5.5
  - publicListinit()
    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]
```
    Returns:
    a List without its last element
    Since:
    2.4.0
  - publicListintersect(Iterable right)
    Create a List composed of the intersection of a List and an Iterable. Anyelements 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 anelement exists in both collections.
    Parameters:
    right - an Iterable
    Returns:
    a List as an intersection of a List and an Iterable
    Since:
    2.4.0
    See Also:
    List#intersect(Iterable, Comparator)
  - publicListintersect(Iterable right,Comparator comparator)
    Create a List composed of the intersection of a List and an Iterable. Anyelements that exist in both iterables are added to the resultant collection.
```
assert [3,4] == [1,2,3,4].intersect([3,4,5,6])
```
    Parameters:
    right - an Iterable
    comparator - a Comparator
    Returns:
    a List as an intersection of a List and an Iterable
    Since:
    2.5.0
  - publicObjectlast()
    Returns the last item from the List.
```
def list = [3, 4, 2]assert list.last() == 2// check original is unalteredassert list == [3, 4, 2]
```
    Returns:
    the last item from the List
    Since:
    1.5.5
  - publicListleftShift(Object value)
    Overloads the left shift operator to provide an easy way to appendobjects to a List.
```
def list = [1,2]list << 3assert list == [1,2,3]
```
    Parameters:
    value - an Object to be added to the List.
    Returns:
    same List, after the value was added to it.
    Since:
    2.4.0
  - publicListminus(Iterable removeMe)
    Create a new List composed of the elements of the first List minusevery 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
    Returns:
    a new List with the given elements removed
    Since:
    1.8.7
  - publicListminus(Object removeMe)
    Create a new List composed of the elements of the first List minus every occurrence of thegiven element to remove.
```
assert ["a", 5, 5, true] - 5 == ["a", true]
```
    Parameters:
    removeMe - an element to remove from the List
    Returns:
    the resulting List with the given element removed
    Since:
    1.0
  - publicListminus(Collection removeMe)
    Create a List composed of the elements of the first list minusevery 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
    Returns:
    a List with the given elements removed
    Since:
    1.0
  - publicListmultiply(Number factor)
    Create a List composed of the elements of this Iterable, repeateda certain number of times. Note that for non-primitiveelements, 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 themethod will effectively return a Collection with a single copy of the Iterable's items.
    Parameters:
    factor - the number of times to append
    Returns:
    the multiplied List
    Since:
    2.4.0
  - public intpartitionPoint(IntRange range,Predicate condition)
    Returns the index of the partition point according to the given predicate(the index of the first element of the second partition).The list is assumed to be partitioned according to the given predicate.
```
def list = [7, 15, 3, 5, 4, 12, 6]assert list.partitionPoint(0..<list.size()) { it%2 != 0 } == 4
```
```
def list = [1, 2, 3, 3, 4, 4, 5, 6, 7]// usage case as lower_bound(cpp), bisect_left(python)assert list.partitionPoint(0..<list.size()) { it < 4 } == 4// usage case as upper_bound(cpp), bisect_right(python)assert list.partitionPoint(0..<list.size()) { it <= 4 } == 6// for all match conditionassert list.partitionPoint(0..<list.size()) { it <= 20 } == list.size()// for no match conditionassert list.partitionPoint(0..<list.size()) { it <= 0 } == 0// for all match condition with rangeassert list.partitionPoint(0..<4) { it <= 20 } == 4// for no match condition with rangeassert list.partitionPoint(2..<list.size()) { it <= 0 } == 2
```
    Parameters:
    range - the range [l,r] to find data match the condition
    condition - the matching condition
    Returns:
    an integer that is the index of the first element of the second partition
    Since:
    5.0.0
  - public intpartitionPoint(Predicate condition)
    Returns the index of the partition point according to the given predicate(the index of the first element of the second partition).The list is assumed to be partitioned according to the given predicate.
```
def list = [7, 15, 3, 5, 4, 12, 6] // partitioned into odds then evensassert list.partitionPoint{ it%2 != 0 } == 4
```
```
def list = [1, 2, 3, 3, 4, 4, 5, 6, 7]// usage case as lower_bound(cpp), bisect_left(python)assert list.partitionPoint{ it < 4 } == 4// usage case as upper_bound(cpp), bisect_right(python)assert list.partitionPoint{ it <= 4 } == 6// for all match conditionassert list.partitionPoint{ it <= 100 } == list.size()// for no match conditionassert list.partitionPoint{ it <= 0 } == 0// predicate of reverse logic examples:assert [7, 6, 5, 4, 4, 3, 3, 2, 1].partitionPoint{ it > 4 } == 3assert [7, 6, 5, 4, 4, 3, 3, 2, 1].partitionPoint{ it >= 4 } == 5
```
    Parameters:
    condition - the matching condition
    Returns:
    an integer that is the index of the first element of the second partition
    Since:
    5.0.0
  - publicListplus(int index,Iterable additions)
    Creates a new List by inserting all the elements in the given Iterableto 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
    Returns:
    the new list
    Since:
    1.8.7
    See Also:
    List#plus(int, List)
  - publicListplus(int index,Object[] items)
    Creates a new List by inserting all the elements in the specified arrayto the elements from the original List at the specified index.Shifts the element currently at that index (if any) and any subsequentelements to the right (increasing their indices).The new elements will appear in the resulting List in the order thatthey occur in the original array.The behavior of this operation is undefined if the list orarray 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 alsoaddAll for similar functionality with modify semantics, i.e. which performsthe 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
    Returns:
    the new list
    Since:
    1.8.1
    See Also:
    List#plus(int, List)
  - publicListplus(int index,List additions)
    Creates a new List by inserting all the elements in the given additions Listto the elements from the original List at the specified index.Shifts the element currently at that index (if any) and any subsequentelements to the right (increasing their indices). The new elementswill 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 listsare 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 alsoaddAll for similar functionality with modify semantics, i.e. which performsthe 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
    Returns:
    the new list
    Since:
    1.8.1
  - publicListplus(Iterable right)
    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
    Returns:
    the merged List
    Since:
    2.4.0
    See Also:
    Collection#plus(Collection)
  - publicListplus(Object right)
    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
    Returns:
    the resulting List
    Since:
    2.4.0
  - publicListplus(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
    Returns:
    the merged List
    Since:
    2.4.0
    See Also:
    Collection#plus(Collection)
  - publicObjectpop()
    Removes the initial item from the List.
```
def list = ["a", false, 2]assert list.pop() == 'a'assert list == [false, 2]
```
    This is similar to pop on a Stack where the first item in the listrepresents 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'.
    Returns:
    the item removed from the List
    Since:
    1.0
  - public booleanpush(Object value)
    Prepends an item to the start of the List.
```
def list = [3, 4, 2]list.push("x")assert list == ['x', 3, 4, 2]
```
    This is similar to push on a Stack where the first item in the listrepresents 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.
    Returns:
    true (for legacy compatibility reasons).
    Since:
    1.5.5
  - public voidputAt(EmptyRange range,Object value)
    A helper method to allow lists to work with subscript operators.
```
def list = ["a", true]list[1..<1] = 5assert list == ["a", 5, true]
```
    Parameters:
    range - the (in this case empty) subset of the list to set
    value - the values to put at the given sublist or a Collection of values
    Since:
    1.0
  - public voidputAt(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]
```
    Parameters:
    range - the (in this case empty) subset of the list to set
    value - the Collection of values
    Since:
    1.0
    See Also:
    List#putAt(groovy.lang.EmptyRange, java.lang.Object)
  - public voidputAt(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 givenrange are replaced with the operand. Thevalue operand isalways treated as a single value.
    Parameters:
    range - the subset of the list to set
    value - the value to put at the given sublist
    Since:
    1.0
  - public voidputAt(IntRange range,Collection col)
    List subscript assignment operator when given a range as the index andthe 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 givenrange 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
    Since:
    1.5.0
  - public voidputAt(int idx,Object value)
    A helper method to allow lists to work with subscript operators.
```
def list = [2, 3]list[0] = 1assert list == [1, 3]
```
    Parameters:
    idx - an index
    value - the value to put at the given index
    Since:
    1.0
  - public voidputAt(Number idx,Object value)
    Support subscript operator for list modification.
    Parameters:
  - public voidputAt(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] = 5assert list == ["a", 5, 42, 5]
```
    Parameters:
    splice - the subset of the list to set
    value - the value to put at the given sublist
    Since:
    1.0
  - public voidputAt(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
    Since:
    1.0
  - publicObjectremoveAt(int index)
    Modifies this list by removing the element at the specified positionin this list. Returns the removed element. Essentially an alias forList#remove(int) but with no ambiguity for List<Integer>.
    Example:
```
def list = [1, 2, 3]list.removeAt(1)assert [1, 3] == list
```
    Parameters:
    index - the index of the element to be removed
    Returns:
    the element previously at the specified position
    Since:
    2.4.0
  - publicObjectremoveLast()
    Removes the last item from the List.
```
def list = ['a', false, 2]assert list.removeLast() == 2assert list == ['a', false]
```
    Using add() and removeLast() is similar to push and pop on a Stackwhere the last item in the list represents the top of the stack.
    Returns:
    the item removed from the List
    Since:
    2.5.0
  - publicListreverse()
    Creates a new List with the identical contents to this listbut in reverse order.
```
def list = ["a", 4, false]assert list.reverse() == [false, 4, "a"]assert list == ["a", 4, false]
```
    Returns:
    a reversed List
    Since:
    1.0
    See Also:
    List#reverse(boolean)
  - publicListreverse(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"]
```
    Parameters:
    mutate - true if the list itself should be reversed in place and returned, false if a new list should be created
    Returns:
    a reversed List
    Since:
    1.8.1
  - publicListreverseEach(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.
    Returns:
    the original list
    Since:
    1.5.0
  - public voidshuffle()
    Randomly reorders the elements of the specified list.
```
def list = ["a", 4, false]def origSize = list.size()def origCopy = new ArrayList(list)list.shuffle()assert list.size() == origSizeassert origCopy.every{ list.contains(it) }
```
    Since:
    3.0.0
    See Also:
    Collections#shuffle(List)
  - public voidshuffle(Random rnd)
    Randomly reorders the elements of the specified list using thespecified 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() == origSizeassert origCopy.every{ list.contains(it) }
```
    Parameters:
    Since:
    3.0.0
    See Also:
    Collections#shuffle(List)
  - publicListshuffled()
    Creates a new list containing the elements of the specified listbut in a random order.
```
def list = ["a", 4, false]def result = list.shuffled()assert list !== resultassert list == ["a", 4, false]assert list.size() == result.size()assert list.every{ result.contains(it) }
```
    Since:
    3.0.0
    See Also:
    Collections#shuffle(List)
  - publicListshuffled(Random rnd)
    Creates a new list containing the elements of the specified list but in a randomorder 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 !== resultassert list == ["a", 4, false]assert list.size() == result.size()assert list.every{ result.contains(it) }
```
    Parameters:
    Since:
    3.0.0
    See Also:
    Collections#shuffle(List)
  - publicListsort(IntRange range)
    A mutating sort variant that takes an index range.
```
def nums = [5, 9, 1, 7, 3, 4, 8, 6, 0, 2]nums.sort(0..4)assert nums == [1, 3, 5, 7, 9, 4, 8, 6, 0, 2]
```
    Parameters:
    Returns:
    the sorted list
    Since:
    5.0.0
    See Also:
    List#sort(IntRange, boolean, Closure)
  - publicListsort(IntRange range, boolean mutate,Closure closure)
    Sorts elements in the given index range using the given Closure to determine the ordering.If mutate is true, it is sorted in place and returned. Otherwise, the elements are first placedinto a new list which is then sorted and returned, leaving the original List unchanged.
```
// a list with some odd then even numbersdef nums = [5, 9, 1, 7, 3, 4, 8, 6, 0, 2]// sort odds ascending, evens descendingassert nums.sort(0..4, false) { it }.sort(5..9, false) { -it } == [1, 3, 5, 7, 9, 8, 6, 4, 2, 0]// sort odds descending, evens descendingassert nums.sort(0..<5, false) { -it }.sort(4<..<10, false) { -it } == [9, 7, 5, 3, 1, 8, 6, 4, 2, 0]// sort odds descending, evens ascendingassert nums.sort(0..<5, false) { -it }.sort(5..-1, false) { it } == [9, 7, 5, 3, 1, 0, 2, 4, 6, 8]// leave first and last numbers, sort remaining odds ascending, remaining evens descendingassert nums.sort(1..4, false) { it }.sort(5..-2, false) { -it } == [5, 1, 3, 7, 9, 8, 6, 4, 0, 2]// leave first and last numbers, sort remaining odds descending, remaining evens ascendingassert nums.sort(1..4, false) { -it }.sort(5..-2, false) { it } == [5, 9, 7, 3, 1, 0, 4, 6, 8, 2]// leave first and last odds and evens, sort remaining odds ascending, remaining evens descendingassert nums.sort(0<..<4, false) { it }.sort(5<..<9, false) { -it } == [5, 1, 7, 9, 3, 4, 8, 6, 0, 2]// leave first and last odds and evens, sort remaining odds descending, remaining evens ascendingassert nums.sort(0<..<4, false) { -it }.sort(5<..<-1, false) { it } == [5, 9, 7, 1, 3, 4, 0, 6, 8, 2]
```
    Parameters:
    range - the inclusive range of index values over which to sort
    mutate - false causes a new list to be created, true will mutate lists in place
    closure - a Closure used to determine the correct ordering
    Returns:
    a sorted List
    Since:
    5.0.0
  - publicListsort(IntRange range, boolean mutate,Comparator comparator)
    Sorts the Iterable using the given Comparator over the given index range. If the Iterable is a List and mutateis true, it is sorted in place and returned. Otherwise, the elements are first placedinto a new list which is then sorted and returned - leaving the original Iterable unchanged.
```
def orig = ['hello', 'hi', 'Hey', 'a']def sorted = orig.sort(0..2, false, String.CASE_INSENSITIVE_ORDER)assert orig == ['hello', 'hi', 'Hey', 'a']assert sorted == ['hello', 'Hey', 'hi', 'a']
```
    Parameters:
    range - the inclusive range of index values over which to sort
    mutate - false causes a new list to be created, true will mutate lists in place
    comparator - a Comparator used for the comparison
    Returns:
    a sorted List
    Since:
    5.0.0
  - publicListsort(IntRange range,Closure closure)
    A sort variant that takes an index range and always mutates the original list.
```
def nums = [5, 9, 1, 7, 3, 4, 8, 6, 0, 2]nums.sort(0..4) { it }assert nums == [1, 3, 5, 7, 9, 4, 8, 6, 0, 2]
```
    Parameters:
    Returns:
    the sorted list
    Since:
    5.0.0
    See Also:
    List#sort(IntRange, boolean, Closure)
  - publicListsort(IntRange range,Comparator comparator)
    Sorts the Iterable using the given Comparator over the given index range.
```
def orig = ['hello', 'hi', 'Hey', 'a']orig.sort(0..2, String.CASE_INSENSITIVE_ORDER)assert orig == ['hello', 'Hey', 'hi', 'a']
```
    Parameters:
    range - the inclusive range of index values over which to sort
    comparator - a Comparator used for the comparison
    Returns:
    a sorted List
    Since:
    5.0.0
  - publicListsplit(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:
    a List whose first item is the accepted values and whose second item is the rejected values
    Since:
    2.4.0
  - publicListsubList(IntRange range)
    Returns a view of the portion of this list given by the specified range.
```
def nums = [0, 1, 2, 3, 4]assert nums.subList(1..3) == 1..3assert nums.subList(0<..<-1) == 1..3nums.subList(1..3).clear()assert nums == [0, 4]
```
    Parameters:
    range - a range
    Returns:
    a view of the specified range within this list
    Since:
    5.0.0
  - publicSetsubsequences()
    Finds all non-null subsequences of a list.
    Example usage:
```
def result = [1, 2, 3].subsequences()assert result == [[1, 2, 3], [1, 3], [2, 3], [1, 2], [1], [2], [3]] as Set
```
    Returns:
    the subsequences from the list
    Since:
    1.7.0
  - publicListswap(int i, int j)
    Swaps two elements at the specified positions.
    Example:
```
assert [1, 3, 2, 4] == [1, 2, 3, 4].swap(1, 2)
```
    Parameters:
    i - a position
    j - a position
    Returns:
    self
    Since:
    2.4.0
    See Also:
    Collections#swap(List, int, int)
  - publicListtail()
    Returns the items from the List excluding the first item.
```
def list = [3, 4, 2]assert list.tail() == [4, 2]assert list == [3, 4, 2]
```
    Returns:
    a List without its first element
    Since:
    1.5.6
  - publicListtake(int num)
    Returns the firstnum 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' ]
```
    Parameters:
    num - the number of elements to take from this List
    Returns:
    a List consisting of the firstnum elements from this List, or else all the elements from the List if it has less thannum elements.
    Since:
    1.8.1
  - publicListtakeRight(int num)
    Returns the lastnum 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' ]
```
    Parameters:
    num - the number of elements to take from this List
    Returns:
    a List consisting of the lastnum elements from this List, or else all the elements from the List if it has less thannum elements.
    Since:
    2.4.0
  - publicListtakeWhile(Closure condition)
    Returns the longest prefix of this list where each elementpassed 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 ]
```
    Parameters:
    condition - the closure that must evaluate to true to continue taking elements
    Returns:
    a prefix of the given list where each element passed to the given closure evaluates to true
    Since:
    1.8.7
  - publicListtoSorted(IntRange range)
    Returns a list, sorted over the given rangeusing a NumberAwareComparator, leaving the original list unmodified.
```
def nums = [5, 9, 1, 7, 3, 4, 8, 6, 0, 2]assert nums.toSorted(0..4) == [1, 3, 5, 7, 9, 4, 8, 6, 0, 2]assert nums.toSorted(5..-1) == [5, 9, 1, 7, 3, 0, 2, 4, 6, 8]
```
    Parameters:
    range - the inclusive range of index values over which to sort
    Returns:
    the sorted list
    Since:
    5.0.0
    See Also:
    List#toSorted(IntRange, Closure)
  - publicListtoSorted(IntRange range,Closure closure)
    A sort variant that takes an index range and never modifies the original list.
```
def nums = [5, 9, 1, 7, 3, 4, 8, 6, 0, 2]assert nums.toSorted(0..4) { it } == [1, 3, 5, 7, 9, 4, 8, 6, 0, 2]
```
    Parameters:
    range - the inclusive range of index values over which to sort
    closure - a Closure used for the comparison
    Returns:
    the sorted list
    Since:
    5.0.0
    See Also:
    List#sort(IntRange, boolean, Closure)
  - publicListtoSorted(IntRange range,Comparator comparator)
    Returns a list, sorted over the given rangeusing a NumberAwareComparator, leaving the original list unmodified.
```
def nums = [5, 9, 1, 7, 3, 4, 8, 6, 0, 2]assert nums.toSorted(0..4, Comparator.reverseOrder()) == [9, 7, 5, 3, 1, 4, 8, 6, 0, 2]assert nums.toSorted(5..-1, Comparator.reverseOrder()) == [5, 9, 1, 7, 3, 8, 6, 4, 2, 0]
```
    Parameters:
    range - the inclusive range of index values over which to sort
    comparator - a Comparator used for the comparison
    Returns:
    the sorted list
    Since:
    5.0.0
    See Also:
    List#sort(IntRange, boolean, Comparator)
  - publicSpreadMaptoSpreadMap()
    Creates a spreadable map from this list.
    Returns:
    a newly created SpreadMap
    Since:
    1.8.0
    See Also:
    SpreadMap#SpreadMap(java.util.List)
    Map#toSpreadMap()
  - publicListtoUnique()
    Returns a List containing the items from the List but with duplicates removedusing 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
```
    Returns:
    the List of non-duplicate items
    Since:
    2.4.0
  - publicListtoUnique(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 theIterable 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 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 Iterablewill 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] )
```
    Parameters:
    condition - a Closure used to determine unique items
    Returns:
    a new List
    Since:
    2.4.0
    See Also:
    Iterable#toUnique(Comparator)
  - publicListtoUnique(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 theList 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)        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.toUnique(new PersonComparator())assert list2 == [a, b, c]&& list == [a, b, c, d]
```
    Parameters:
    comparator - a Comparator used to determine unique (equal) items Ifnull, the Comparable natural ordering of the elements will be used.
    Returns:
    the List of non-duplicate items
    Since:
    2.4.0
  - publicListtranspose()
    Adds GroovyCollections#transpose(List) as a method on lists.A Transpose Function takes a collection of columns and returns a collection ofrows. The first row consists of the first element from each column. Successiverows 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]]
```
    Returns:
    a List of the transposed lists
    Since:
    1.5.0
    See Also:
    GroovyCollections#transpose(java.util.List)
  - publicListunion(Iterable right)
    Create a List composed of the union of a List and an Iterable. Anyelements that exist in both iterables are added to the resultant collection, suchthat no elements are duplicated in the resultant collection.
```
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 already exists in the resultant collection.
    Parameters:
    right - an Iterable
    Returns:
    a List as a union of a List and an Iterable
    Since:
    5.0.0
    See Also:
    List#union(Iterable, Comparator)
  - publicListunion(Iterable right,Comparator comparator)
    Create a List composed of the union of a List and an Iterable. Anyelements that exist in either iterables are added to the resultant collection, suchthat no elements are duplicated in the resultant collection.
```
assert [1,2,3,4,5,6] == [1,2,3,4].union([3,4,5,6])
```
    Parameters:
    right - an Iterable
    comparator - a Comparator
    Returns:
    a List as a union of a List and an Iterable
    Since:
    5.0.0
  - publicListunique()
    Modifies this List to remove all duplicated items, using Groovy'sdefault number-aware comparator.
```
assert [1,3] == [1,3,3].unique()
```
    Returns:
    the now modified List
    Since:
    2.4.0
    See Also:
    Collection#unique(boolean)
  - publicListunique(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]
```
    Parameters:
    mutate - false will cause a new List containing unique items from the List to be created, true will mutate List in place
    Returns:
    the now modified List
    Since:
    2.4.0
  - publicListunique(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 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]
```
    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
    Returns:
    self without any duplicates
    Since:
    2.4.0
  - publicListunique(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 returnedby 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)        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] )
```
    Parameters:
    mutate - false will always cause a new List to be created, true will mutate List in place
    comparator - a Comparator
    Returns:
    self the List without duplicates
    Since:
    2.4.0
  - publicListunique(Closure closure)
    A convenience method for making a List 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 Listwill 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 }
```
    Parameters:
    closure - a 1 or 2 arg Closure used to determine unique items
    Returns:
    self without any duplicates
    Since:
    2.4.0
    See Also:
    Collection#unique(boolean, Closure)
  - publicListunique(Comparator comparator)
    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 returnedby 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)        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] )
```
    Parameters:
    comparator - a Comparator
    Returns:
    self the now modified List without duplicates
    Since:
    2.4.0
    See Also:
    Collection#unique(boolean, java.util.Comparator)
  - publicListWithDefaultwithDefault(Closure init)
    An alias forwithLazyDefault which decorates a list allowingit 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
    Returns:
    the decorated List
    Since:
    1.8.7
    See Also:
    List#withLazyDefault(groovy.lang.Closure)
    List#withEagerDefault(groovy.lang.Closure)
  - publicListWithDefaultwithEagerDefault(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 valueis placed in the list by calling a suppliedinit Closure. Null valuescan be stored in the list.
    How it works: The decorated list intercepts all callstogetAt(index) andget(index). If an index greater thanor equal to the currentsize() is used, the list will grow automaticallyup to the specified index. Gaps will be filled by calling theinit Closure.If generating a default value is a costly operation consider usingwithLazyDefault.
    Example usage:
```
def list = [0, 1].withEagerDefault{ 42 }assert list[0] == 0assert list[1] == 1assert list[3] == 42   // default valueassert list == [0, 1, 42, 42]   // gap filled with default value// illustrate using the index when generating default valuesdef list2 = [5].withEagerDefault{ index-> index * index }assert list2[3] == 9assert list2 == [5, 1, 4, 9]// illustrate what happens with null valueslist2[2] = nullassert list2[2] == nullassert list2 == [5, 1, null, 9]
```
    Parameters:
    init - a Closure with the target index as parameter which generates the default value
    Returns:
    the wrapped List
    Since:
    1.8.7
  - publicListWithDefaultwithLazyDefault(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 valueis placed in the list by calling a suppliedinit Closure. Subsequentretrieval operations if finding a null value in the list assume it was setas null from an earlier growing operation and again call theinit Closureto populate the retrieved value; consequently the list can't be used to store null values.
    How it works: The decorated list intercepts all callstogetAt(index) andget(index). If an index greater thanor equal to the currentsize() is used, the list will grow automaticallyup to the specified index. Gaps will be filled bynull. If a default valueshould also be used to fill gaps instead ofnull, usewithEagerDefault.IfgetAt(index) orget(index) are called and a null valueis found, it is assumed that the null value was a consequence of an earlier grow listoperation and theinit Closure is called to populate the value.
    Example usage:
```
def list = [0, 1].withLazyDefault{ 42 }assert list[0] == 0assert list[1] == 1assert list[3] == 42   // default valueassert list == [0, 1, null, 42] // gap filled with null// illustrate using the index when generating default valuesdef list2 = [5].withLazyDefault{ index-> index * index }assert list2[3] == 9assert list2 == [5, null, null, 9]assert list2[2] == 4assert list2 == [5, null, 4, 9]// illustrate what happens with null valueslist2[2] = nullassert list2[2] == 4
```
    Parameters:
    init - a Closure with the target index as parameter which generates the default value
    Returns:
    the decorated List
    Since:
    1.8.7

Movatterモバイル変換

Interface List

Methods Summary

Methods inherited from interface java.util.Collection

Methods inherited from interface java.lang.Iterable

Methods Detail

public booleanaddAll(int index,Object[] items)

publicListasChecked(Class type)

publicListasImmutable()

publicListasReversed()

publicListasSynchronized()

publicListasUnmodifiable()

publicBufferedIteratorbufferedIterator()

publicListdrop(int num)

publicListdropRight(int num)

publicListdropWhile(Closure condition)

publicListeach(Closure closure)

publicListeachWithIndex(Closure closure)

public booleanequals(Object[] right)

public booleanequals(List right)

publicProcessexecute()

publicProcessexecute(String[] envp,File dir)

publicProcessexecute(List envp,File dir)

publicListfindAll()

publicListfindAll(Closure closure)

publicObjectfirst()

publicListflatten()

publicListgetAt(EmptyRange range)

publicListgetAt(Range range)

publicObjectgetAt(int idx)

publicObjectgetAt(Number idx)

publicListgetAt(Collection indices)

publicListgrep()

publicListgrep(Object filter)

publicObjecthead()

publicListinit()

publicListintersect(Iterable right)

publicListintersect(Iterable right,Comparator comparator)

publicObjectlast()

publicListleftShift(Object value)

publicListminus(Iterable removeMe)

publicListminus(Object removeMe)

publicListminus(Collection removeMe)

publicListmultiply(Number factor)

public intpartitionPoint(IntRange range,Predicate condition)

public intpartitionPoint(Predicate condition)

publicListplus(int index,Iterable additions)

publicListplus(int index,Object[] items)

publicListplus(int index,List additions)

publicListplus(Iterable right)

publicListplus(Object right)

publicListplus(Collection right)

publicObjectpop()

public booleanpush(Object value)

public voidputAt(EmptyRange range,Object value)

public voidputAt(EmptyRange range,Collection value)

public voidputAt(IntRange range,Object value)

public voidputAt(IntRange range,Collection col)

public voidputAt(int idx,Object value)

public voidputAt(Number idx,Object value)

public voidputAt(List splice,Object value)

public voidputAt(List splice,Collection values)

publicObjectremoveAt(int index)

publicObjectremoveLast()

publicListreverse()

publicListreverse(boolean mutate)

publicListreverseEach(Closure closure)

public voidshuffle()

public voidshuffle(Random rnd)

publicListshuffled()

publicListshuffled(Random rnd)

publicListsort(IntRange range)

publicListsort(IntRange range, boolean mutate,Closure closure)

publicListsort(IntRange range, boolean mutate,Comparator comparator)

publicListsort(IntRange range,Closure closure)

publicListsort(IntRange range,Comparator comparator)

publicListsplit(Closure closure)

publicListsubList(IntRange range)

publicSetsubsequences()

publicListswap(int i, int j)