Return type  Name and parameters 

boolean

any(Closure predicate)
Iterates over the contents of a double Array, and checks whether a predicate is valid for at least one element. 
boolean

asBoolean()
Coerces a double array to a boolean value. 
double

average()
Calculates the average of the doubles in the array. 
List

chop(int chopSizes)
Chops the double array into pieces, returning lists with sizes corresponding to the supplied chop sizes. 
boolean

contains(Object value)
Checks whether the array contains the given value. 
Number

count(Object value)
Counts the number of occurrences of the given value inside this array. 
DoubleStream

doubleStream()
Returns a sequential DoubleStream with the specified array as its source. 
double[]

each(DoubleConsumer consumer)
Iterates through a double[] passing each double to the given consumer. 
double[]

eachWithIndex(Closure closure)
Iterates through a double[], passing each double and the element's index (a counter starting at zero) to the given closure. 
boolean

equals(double[] right)
Compares the contents of this array to the contents of the given array. 
boolean

every(Closure predicate)
Iterates over the contents of a double Array, and checks whether a predicate is valid for all elements. 
double

first()
Returns the first item from the double array. 
List

flatten()
Flattens an array. 
List

getAt(IntRange range)
Supports the subscript operator for a double array with an IntRange giving the desired indices. 
List

getAt(ObjectRange range)
Supports the subscript operator for a double array with an ObjectRange giving the desired indices. 
List

getAt(Range range)
Supports the subscript operator for a double array with a range giving the desired indices. 
List

getAt(Collection indices)
Supports the subscript operator for a double array with a (potentially nested) collection giving the desired indices. 
IntRange

getIndices()
Returns indices of the double array. 
double

head()
Returns the first item from the double array. 
Map

indexed()
Zips a double[] with indices in (index, value) order starting from index 0. 
Map

indexed(int offset)
Zips a double[] with indices in (index, value) order. 
double[]

init()
Returns the items from the double array excluding the last item. 
String

join()
Concatenates the string representation of each item in this array. 
String

join(String separator)
Concatenates the string representation of each item in this array, with the given String as a separator between each item. 
double

last()
Returns the last item from the double array. 
double

max()
Adds max() method to double arrays. 
double

max(DoubleComparator comparator)
Selects the maximum value found from the double array using the supplier DoubleComparator to determine the maximum of any two values. 
double

max(DoubleUnaryOperator operator)
Selects the maximum value found from the double array using the supplier DoubleUnaryOperator to determine the maximum of any two values. 
double

maxBy(Closure closure)
Selects the maximum value found from the double array using the closure to determine the maximum of any two values. 
double

maxComparing(Comparator comparator)
Selects the maximum value found from the double array using the comparator to determine the maximum of any two values. 
double

min()
Adds min() method to double arrays. 
double

min(DoubleComparator comparator)
Selects the minimum value found from the double array using the supplier DoubleBinaryOperator as a comparator to determine the minimum of any two values. 
double

min(DoubleUnaryOperator operator)
Selects the minimum value found from the double array using the supplier DoubleUnaryOperator to determine the minimum of any two values. 
double

minBy(Closure closure)
Selects the minimum value found from the double array using the closure to determine the minimum of any two values. 
double

minComparing(Comparator comparator)
Selects the minimum value found from the double array using the comparator to determine the minimum of any two values. 
double[]

reverse()
Creates a new double array containing items which are the same as this array but in reverse order. 
double[]

reverse(boolean mutate)
Reverses the items in an array. 
double[]

reverseEach(Closure closure)
Iterates through a double[] in reverse order passing each double to the given closure. 
int

size()
Provides arrays with a size method similar to collections.

Stream

stream()
Returns a sequential Stream with the specified array as its source. 
double

sum()
Sums the items in an array. 
double

sum(double initialValue)
Sums the items in an array, adding the result to some initial value. 
double[]

swap(int i, int j)
Swaps two elements at the specified positions. 
double[]

tail()
Returns the items from the double array excluding the first item. 
List

toList()
Converts this array to a List of the same size, with each element added to the list. 
Set

toSet()
Converts this array to a Set, with each unique element added to the set. 
String

toString()
Returns the string representation of the given array. 
Iterates over the contents of a double Array, and checks whether a predicate is valid for at least one element.
double[] array = [0.0d, 1.0d, 2.0d] assert array.any{ it > 1.5d } assert !array.any{ it > 2.5d }
predicate
 the closure predicate used for matchingCoerces a double array to a boolean value. A double array is false if the array is of length 0, and true otherwise.
Calculates the average of the doubles in the array.
assert 5.0d == ([2,4,6,8] as double[]).average()
Chops the double array into pieces, returning lists with sizes corresponding to the supplied chop sizes. If the array isn't large enough, truncated (possibly empty) pieces are returned. Using a chop size of 1 will cause that piece to contain all remaining items from the array.
double[] array = [0, 1, 2] assert array.chop(1, 2) == [[0], [1, 2]]
chopSizes
 the sizes for the returned piecesChecks whether the array contains the given value.
value
 the value being searched forCounts the number of occurrences of the given value inside this array.
Comparison is done using Groovy's == operator (using
compareTo(value) == 0
).
double[] array = [10.0d, 20.0d, 20.0d, 30.0d] assert array.count(20.0d) == 2
value
 the value being searched forReturns a sequential DoubleStream with the specified array as its source.
Stream
for the arrayIterates through a double[] passing each double to the given consumer.
double[] array = [0d, 1d, 2d] String result = '' array.each{ result += it } assert result == '0.01.02.0'
consumer
 the consumer for each doubleIterates through a double[], passing each double and the element's index (a counter starting at zero) to the given closure.
double[] array = [10d, 20d, 30d]
String result = ''
array.eachWithIndex{ item, index >
result += "$index($item)" }
assert result == '0(10.0)1(20.0)2(30.0)'
closure
 a Closure to operate on each doubleCompares the contents of this array to the contents of the given array.
Example usage:
double[] array1 = [4.0d, 8.0d] double[] array2 = [4.0d, 8.0d] assert array1 !== array2 assert array1.equals(array2)
right
 the array being comparedIterates over the contents of a double Array, and checks whether a predicate is valid for all elements.
double[] array = [0.0d, 1.0d, 2.0d] assert array.every{ it < 2.5d } assert !array.every{ it > 1.5d }
predicate
 the closure predicate used for matchingReturns the first item from the double array.
double[] doubles = [10.0d, 20.0d, 30.0d] assert doubles.first() == 10.0dAn alias for
head()
.
Flattens an array. This array is added to a new collection.
It is an alias for toList()
but allows algorithms to be written which also
work on multidimensional arrays or nonarrays where flattening would be applicable.
double[] array = [0.0d, 1.0d] assert array.flatten() == [0.0d, 1.0d]
Supports the subscript operator for a double array with an IntRange giving the desired indices.
double[] array = [0.0d, 10.0d, 20.0d, 30.0d, 40.0d] assert array[2..3] == [20.0d, 30.0d] assert array[2..1] == [30.0d, 40.0d] assert array[1..2] == [40.0d, 30.0d]
range
 an IntRange indicating the indices for the items to retrieveSupports the subscript operator for a double array with an ObjectRange giving the desired indices.
double[] array = [0.0d, 10.0d, 20.0d, 30.0d, 40.0d] def range = new ObjectRange(2, 3) assert array[range] == [20.0d, 30.0d]
range
 an ObjectRange indicating the indices for the items to retrieveSupports the subscript operator for a double array with a range giving the desired indices.
double[] array = [1.0d, 3.0d, 5.0d, 7.0d, 9.0d, 11.0d] assert array[2..<2] == [] // EmptyRange assert array[(0..5.5).step(2)] == [1.0d, 5.0d, 9.0d] // NumberRange assert array[(1..5.5).step(2)] == [3.0d, 7.0d, 11.0d] // NumberRange
range
 a range indicating the indices for the items to retrieveSupports the subscript operator for a double array with a (potentially nested) collection giving the desired indices.
double[] array = [0.0d, 2.0d, 4.0d, 6.0d, 8.0d] assert array[2, 3] == [4.0d, 6.0d] assert array[1, 0..1, [0, [1]]] == [2.0d, 0.0d, 2.0d, 0.0d, 8.0d]
indices
 a collection of indices for the items to retrieveReturns indices of the double array.
double[] array = [0.0d, 1.0d] assert array.indices == 0..1
Returns the first item from the double array.
double[] doubles = [10.0d, 20.0d, 30.0d] assert doubles.head() == 10.0dAn alias for
first()
.
Zips a double[] with indices in (index, value) order starting from index 0.
Example usage:
double[] nums = [10.0d, 20.0d, 30.0d] assert [0: 10.0d, 1: 20.0d, 2: 30.0d] == nums.indexed()
Zips a double[] with indices in (index, value) order.
Example usage:
double[] nums = [10.0d, 20.0d, 30.0d] assert [5: 10.0d, 6: 20.0d, 7: 30.0d] == nums.indexed(5)
offset
 an index to start fromReturns the items from the double array excluding the last item.
double[] doubles = [10.0d, 20.0d, 30.0d] def result = doubles.init() assert result == [10.0d, 20.0d] assert doubles.class.componentType == result.class.componentType
Concatenates the string representation of each item in this array.
Concatenates the string representation of each item in this array, with the given String as a separator between each item.
separator
 a String separatorReturns the last item from the double array.
double[] doubles = [10.0d, 20.0d, 30.0d] assert doubles.last() == 30.0d
Adds max() method to double arrays.
Example usage:
double[] nums = [1.1d, 3.3d, 2.2d] assert 3.3d == nums.max()
Selects the maximum value found from the double array using the supplier DoubleComparator to determine the maximum of any two values.
double[] nums = [10d, 20d, 30d] assert 20d == nums.max{ n, m>
n<=>
m } assert 30d == nums.max{ n, m>
n.abs()<=>
m.abs() }
comparator
 a comparator, i.e. returns a negative value if the first parameter is less than the secondSelects the maximum value found from the double array using the supplier DoubleUnaryOperator to determine the maximum of any two values. The operator is applied to each array element and the results are compared.
double[] nums = [10d, 20d, 30d] assert 30d == nums.max{ it.abs() } assert 20d == nums.max{ it }
operator
 an operator that returns a double used for comparing valuesSelects the maximum value found from the double array using the closure to determine the maximum of any two values.
double[] nums = [30.0d, 10.0d, 20.0d] assert 20.0d == nums.maxBy{ a, b>
a<=>
b } assert 30.0d == nums.maxBy{ it.abs() }
If the closure has two parameters it is used like a traditional Comparator, i.e., it should compare its two parameters for order, returning a negative integer, zero, or a positive integer when the first parameter is less than, equal to, or greater than the second respectively. Otherwise, the Closure is assumed to take a single parameter and return a Comparable (typically an Integer) which is then used for further comparison.
closure
 a Closure used to determine the correct orderingSelects the maximum value found from the double array using the comparator to determine the maximum of any two values.
double[] nums = [10.0d, 20.0d, 30.0d] assert 30d == nums.maxComparing(Comparator.naturalOrder()) assert 10d == nums.maxComparing(Comparator.reverseOrder())
comparator
 a ComparatorAdds min() method to double arrays.
Example usage:
double[] nums = [20.0d, 10.0d, 30.0d] assert 10.0d == nums.min()
Selects the minimum value found from the double array using the supplier DoubleBinaryOperator as a comparator to determine the minimum of any two values.
double[] nums = [10d, 20d, 30d] assert 20d == nums.min{ n, m>
n<=>
m } assert 10d == nums.min{ n, m>
n.abs()<=>
m.abs() }
comparator
 a comparator, i.e. returns a negative value if the first parameter is less than the secondSelects the minimum value found from the double array using the supplier DoubleUnaryOperator to determine the minimum of any two values. The operator is applied to each array element and the results are compared.
double[] nums = [10d, 20d, 30d] assert 20d == nums.min{ it } assert 10d == nums.min{ it.abs() }
operator
 an operator that returns a double used for comparing valuesSelects the minimum value found from the double array using the closure to determine the minimum of any two values.
double[] nums = [20.0d, 10.0d, 30.0d] assert 20.0d == nums.minBy{ a, b>
a<=>
b } assert 10.0d == nums.minBy{ it.abs() }
If the closure has two parameters it is used like a traditional Comparator, i.e., it should compare its two parameters for order, returning a negative integer, zero, or a positive integer when the first parameter is less than, equal to, or greater than the second respectively. Otherwise, the Closure is assumed to take a single parameter and return a Comparable (typically an int or double) which is then used for further comparison.
closure
 a Closure used to determine the correct orderingSelects the minimum value found from the double array using the comparator to determine the minimum of any two values.
double[] nums = [10.0d, 20.0d, 30.0d] assert 10d == nums.minComparing(Comparator.naturalOrder()) assert 30d == nums.minComparing(Comparator.reverseOrder())
comparator
 a ComparatorCreates a new double array containing items which are the same as this array but in reverse order.
double[] array = [1d, 2d] assert array.reverse() == [2d, 1d]
Reverses the items in an array. If mutate is true, the original array is modified in place and returned. Otherwise, a new array containing the reversed items is produced.
double[] array = 1d..3d def yarra = array.reverse(true) assert array == 3d..1d assert yarra == 3d..1d assert array === yarra yarra = array.reverse(false) assert array !== yarra assert array == 3d..1d assert yarra == 1d..3d
mutate
 true
if the array itself should be reversed in place, false
if a new array should be createdIterates through a double[] in reverse order passing each double to the given closure.
double[] array = [0, 1, 2] String result = '' array.reverseEach{ result += it } assert result == '2.01.00.0'
closure
 the closure applied on each doubleProvides arrays with a size
method similar to collections.
Returns a sequential Stream with the specified array as its source.
Stream
for the arraySums the items in an array.
assert (1+2+3+4 as double) == ([1,2,3,4] as double[]).sum()
Sums the items in an array, adding the result to some initial value.
assert (5+1+2+3+4 as double) == ([1,2,3,4] as double[]).sum(5)
initialValue
 the items in the array will be summed to this initial valueSwaps two elements at the specified positions.
Example:
assert ([1, 3, 2, 4] as double[]) == ([1, 2, 3, 4] as double[]).swap(1, 2)
i
 a positionj
 a positionReturns the items from the double array excluding the first item.
double[] doubles = [10.0d, 20.0d, 30.0d] def result = doubles.tail() assert result == [20.0d, 30.0d] assert doubles.class.componentType == result.class.componentType
Converts this array to a List of the same size, with each element added to the list.
Converts this array to a Set, with each unique element added to the set.
double[] array = [1.0d, 2.0d, 3.0d, 2.0d, 1.0d] Set expected = [1.0d, 2.0d, 3.0d] assert array.toSet() == expected
Returns the string representation of the given array.
double[] array = [1, 2, 3, 2, 1] assert array.toString() == '[1.0, 2.0, 3.0, 2.0, 1.0]'