Arrays

asList

@SafeVarargs open static fun <T : Any!> asList(vararg a: T): MutableList<T>

Returns a fixed-size list backed by the specified array. (Changes to the returned list "write through" to the array.) This method acts as bridge between array-based and collection-based APIs, in combination with Collection#toArray. The returned list is serializable and implements RandomAccess.

This method also provides a convenient way to create a fixed-size list initialized to contain several elements:

List<String> stooges = Arrays.asList("Larry", "Moe", "Curly");
  

binarySearch

open static fun binarySearch(
    a: LongArray, 
    key: Long
): Int

Searches the specified array of longs for the specified value using the binary search algorithm. The array must be sorted (as by the sort(long[]) method) prior to making this call. If it is not sorted, the results are undefined. If the array contains multiple elements with the specified value, there is no guarantee which one will be found.

binarySearch

open static fun binarySearch(
    a: LongArray, 
    fromIndex: Int, 
    toIndex: Int, 
    key: Long
): Int

Searches a range of the specified array of longs for the specified value using the binary search algorithm. The range must be sorted (as by the sort(long[],int,int) method) prior to making this call. If it is not sorted, the results are undefined. If the range contains multiple elements with the specified value, there is no guarantee which one will be found.

binarySearch

open static fun binarySearch(
    a: IntArray, 
    key: Int
): Int

Searches the specified array of ints for the specified value using the binary search algorithm. The array must be sorted (as by the sort(int[]) method) prior to making this call. If it is not sorted, the results are undefined. If the array contains multiple elements with the specified value, there is no guarantee which one will be found.

binarySearch

open static fun binarySearch(
    a: IntArray, 
    fromIndex: Int, 
    toIndex: Int, 
    key: Int
): Int

Searches a range of the specified array of ints for the specified value using the binary search algorithm. The range must be sorted (as by the sort(int[],int,int) method) prior to making this call. If it is not sorted, the results are undefined. If the range contains multiple elements with the specified value, there is no guarantee which one will be found.

binarySearch

open static fun binarySearch(
    a: ShortArray, 
    key: Short
): Int

Searches the specified array of shorts for the specified value using the binary search algorithm. The array must be sorted (as by the sort(short[]) method) prior to making this call. If it is not sorted, the results are undefined. If the array contains multiple elements with the specified value, there is no guarantee which one will be found.

binarySearch

open static fun binarySearch(
    a: ShortArray, 
    fromIndex: Int, 
    toIndex: Int, 
    key: Short
): Int

Searches a range of the specified array of shorts for the specified value using the binary search algorithm. The range must be sorted (as by the sort(short[],int,int) method) prior to making this call. If it is not sorted, the results are undefined. If the range contains multiple elements with the specified value, there is no guarantee which one will be found.

binarySearch

open static fun binarySearch(
    a: CharArray, 
    key: Char
): Int

Searches the specified array of chars for the specified value using the binary search algorithm. The array must be sorted (as by the sort(char[]) method) prior to making this call. If it is not sorted, the results are undefined. If the array contains multiple elements with the specified value, there is no guarantee which one will be found.

binarySearch

open static fun binarySearch(
    a: CharArray, 
    fromIndex: Int, 
    toIndex: Int, 
    key: Char
): Int

Searches a range of the specified array of chars for the specified value using the binary search algorithm. The range must be sorted (as by the sort(char[],int,int) method) prior to making this call. If it is not sorted, the results are undefined. If the range contains multiple elements with the specified value, there is no guarantee which one will be found.

binarySearch

open static fun binarySearch(
    a: ByteArray, 
    key: Byte
): Int

Searches the specified array of bytes for the specified value using the binary search algorithm. The array must be sorted (as by the sort(byte[]) method) prior to making this call. If it is not sorted, the results are undefined. If the array contains multiple elements with the specified value, there is no guarantee which one will be found.

binarySearch

open static fun binarySearch(
    a: ByteArray, 
    fromIndex: Int, 
    toIndex: Int, 
    key: Byte
): Int

Searches a range of the specified array of bytes for the specified value using the binary search algorithm. The range must be sorted (as by the sort(byte[],int,int) method) prior to making this call. If it is not sorted, the results are undefined. If the range contains multiple elements with the specified value, there is no guarantee which one will be found.

binarySearch

open static fun binarySearch(
    a: DoubleArray, 
    key: Double
): Int

Searches the specified array of doubles for the specified value using the binary search algorithm. The array must be sorted (as by the sort(double[]) method) prior to making this call. If it is not sorted, the results are undefined. If the array contains multiple elements with the specified value, there is no guarantee which one will be found. This method considers all NaN values to be equivalent and equal.

binarySearch

open static fun binarySearch(
    a: DoubleArray, 
    fromIndex: Int, 
    toIndex: Int, 
    key: Double
): Int

Searches a range of the specified array of doubles for the specified value using the binary search algorithm. The range must be sorted (as by the sort(double[],int,int) method) prior to making this call. If it is not sorted, the results are undefined. If the range contains multiple elements with the specified value, there is no guarantee which one will be found. This method considers all NaN values to be equivalent and equal.

binarySearch

open static fun binarySearch(
    a: FloatArray, 
    key: Float
): Int

Searches the specified array of floats for the specified value using the binary search algorithm. The array must be sorted (as by the sort(float[]) method) prior to making this call. If it is not sorted, the results are undefined. If the array contains multiple elements with the specified value, there is no guarantee which one will be found. This method considers all NaN values to be equivalent and equal.

binarySearch

open static fun binarySearch(
    a: FloatArray, 
    fromIndex: Int, 
    toIndex: Int, 
    key: Float
): Int

Searches a range of the specified array of floats for the specified value using the binary search algorithm. The range must be sorted (as by the sort(float[],int,int) method) prior to making this call. If it is not sorted, the results are undefined. If the range contains multiple elements with the specified value, there is no guarantee which one will be found. This method considers all NaN values to be equivalent and equal.

binarySearch

open static fun binarySearch(
    a: Array<Any!>, 
    key: Any
): Int

Searches the specified array for the specified object using the binary search algorithm. The array must be sorted into ascending order according to the Comparable of its elements (as by the sort(java.lang.Object[]) method) prior to making this call. If it is not sorted, the results are undefined. (If the array contains elements that are not mutually comparable (for example, strings and integers), it cannot be sorted according to the natural ordering of its elements, hence results are undefined.) If the array contains multiple elements equal to the specified object, there is no guarantee which one will be found.

binarySearch

open static fun binarySearch(
    a: Array<Any!>, 
    fromIndex: Int, 
    toIndex: Int, 
    key: Any
): Int

Searches a range of the specified array for the specified object using the binary search algorithm. The range must be sorted into ascending order according to the Comparable of its elements (as by the sort(java.lang.Object[],int,int) method) prior to making this call. If it is not sorted, the results are undefined. (If the range contains elements that are not mutually comparable (for example, strings and integers), it cannot be sorted according to the natural ordering of its elements, hence results are undefined.) If the range contains multiple elements equal to the specified object, there is no guarantee which one will be found.

binarySearch

open static fun <T : Any!> binarySearch(
    a: Array<T>, 
    key: T, 
    c: Comparator<in T>?
): Int

Searches the specified array for the specified object using the binary search algorithm. The array must be sorted into ascending order according to the specified comparator (as by the sort(T[], Comparator) method) prior to making this call. If it is not sorted, the results are undefined. If the array contains multiple elements equal to the specified object, there is no guarantee which one will be found.

binarySearch

open static fun <T : Any!> binarySearch(
    a: Array<T>, 
    fromIndex: Int, 
    toIndex: Int, 
    key: T, 
    c: Comparator<in T>?
): Int

Searches a range of the specified array for the specified object using the binary search algorithm. The range must be sorted into ascending order according to the specified comparator (as by the sort(T[], int, int, Comparator) method) prior to making this call. If it is not sorted, the results are undefined. If the range contains multiple elements equal to the specified object, there is no guarantee which one will be found.

copyOf

open static fun <T : Any!> copyOf(
    original: Array<T>, 
    newLength: Int
): Array<T>

Copies the specified array, truncating or padding with nulls (if necessary) so the copy has the specified length. For all indices that are valid in both the original array and the copy, the two arrays will contain identical values. For any indices that are valid in the copy but not the original, the copy will contain null. Such indices will exist if and only if the specified length is greater than that of the original array. The resulting array is of exactly the same class as the original array.

copyOf

open static fun <T : Any!, U : Any!> copyOf(
    original: Array<U>, 
    newLength: Int, 
    newType: Class<out Array<T>!>
): Array<T>

Copies the specified array, truncating or padding with nulls (if necessary) so the copy has the specified length. For all indices that are valid in both the original array and the copy, the two arrays will contain identical values. For any indices that are valid in the copy but not the original, the copy will contain null. Such indices will exist if and only if the specified length is greater than that of the original array. The resulting array is of the class newType.

copyOf

open static fun copyOf(
    original: ByteArray, 
    newLength: Int
): ByteArray

Copies the specified array, truncating or padding with zeros (if necessary) so the copy has the specified length. For all indices that are valid in both the original array and the copy, the two arrays will contain identical values. For any indices that are valid in the copy but not the original, the copy will contain (byte)0. Such indices will exist if and only if the specified length is greater than that of the original array.

copyOf

open static fun copyOf(
    original: ShortArray, 
    newLength: Int
): ShortArray

Copies the specified array, truncating or padding with zeros (if necessary) so the copy has the specified length. For all indices that are valid in both the original array and the copy, the two arrays will contain identical values. For any indices that are valid in the copy but not the original, the copy will contain (short)0. Such indices will exist if and only if the specified length is greater than that of the original array.

copyOf

open static fun copyOf(
    original: IntArray, 
    newLength: Int
): IntArray

Copies the specified array, truncating or padding with zeros (if necessary) so the copy has the specified length. For all indices that are valid in both the original array and the copy, the two arrays will contain identical values. For any indices that are valid in the copy but not the original, the copy will contain 0. Such indices will exist if and only if the specified length is greater than that of the original array.

copyOf

open static fun copyOf(
    original: LongArray, 
    newLength: Int
): LongArray

Copies the specified array, truncating or padding with zeros (if necessary) so the copy has the specified length. For all indices that are valid in both the original array and the copy, the two arrays will contain identical values. For any indices that are valid in the copy but not the original, the copy will contain 0L. Such indices will exist if and only if the specified length is greater than that of the original array.

copyOf

open static fun copyOf(
    original: CharArray, 
    newLength: Int
): CharArray

Copies the specified array, truncating or padding with null characters (if necessary) so the copy has the specified length. For all indices that are valid in both the original array and the copy, the two arrays will contain identical values. For any indices that are valid in the copy but not the original, the copy will contain '\\u000'. Such indices will exist if and only if the specified length is greater than that of the original array.

copyOf

open static fun copyOf(
    original: FloatArray, 
    newLength: Int
): FloatArray

Copies the specified array, truncating or padding with zeros (if necessary) so the copy has the specified length. For all indices that are valid in both the original array and the copy, the two arrays will contain identical values. For any indices that are valid in the copy but not the original, the copy will contain 0f. Such indices will exist if and only if the specified length is greater than that of the original array.

copyOf

open static fun copyOf(
    original: DoubleArray, 
    newLength: Int
): DoubleArray

Copies the specified array, truncating or padding with zeros (if necessary) so the copy has the specified length. For all indices that are valid in both the original array and the copy, the two arrays will contain identical values. For any indices that are valid in the copy but not the original, the copy will contain 0d. Such indices will exist if and only if the specified length is greater than that of the original array.

copyOf

open static fun copyOf(
    original: BooleanArray, 
    newLength: Int
): BooleanArray

Copies the specified array, truncating or padding with false (if necessary) so the copy has the specified length. For all indices that are valid in both the original array and the copy, the two arrays will contain identical values. For any indices that are valid in the copy but not the original, the copy will contain false. Such indices will exist if and only if the specified length is greater than that of the original array.

copyOfRange

open static fun <T : Any!> copyOfRange(
    original: Array<T>, 
    from: Int, 
    to: Int
): Array<T>

Copies the specified range of the specified array into a new array. The initial index of the range (from) must lie between zero and original.length, inclusive. The value at original[from] is placed into the initial element of the copy (unless from == original.length or from == to). Values from subsequent elements in the original array are placed into subsequent elements in the copy. The final index of the range (to), which must be greater than or equal to from, may be greater than original.length, in which case null is placed in all elements of the copy whose index is greater than or equal to original.length - from. The length of the returned array will be to - from.

The resulting array is of exactly the same class as the original array.

copyOfRange

open static fun <T : Any!, U : Any!> copyOfRange(
    original: Array<U>, 
    from: Int, 
    to: Int, 
    newType: Class<out Array<T>!>
): Array<T>

Copies the specified range of the specified array into a new array. The initial index of the range (from) must lie between zero and original.length, inclusive. The value at original[from] is placed into the initial element of the copy (unless from == original.length or from == to). Values from subsequent elements in the original array are placed into subsequent elements in the copy. The final index of the range (to), which must be greater than or equal to from, may be greater than original.length, in which case null is placed in all elements of the copy whose index is greater than or equal to original.length - from. The length of the returned array will be to - from. The resulting array is of the class newType.

copyOfRange

open static fun copyOfRange(
    original: ByteArray, 
    from: Int, 
    to: Int
): ByteArray

Copies the specified range of the specified array into a new array. The initial index of the range (from) must lie between zero and original.length, inclusive. The value at original[from] is placed into the initial element of the copy (unless from == original.length or from == to). Values from subsequent elements in the original array are placed into subsequent elements in the copy. The final index of the range (to), which must be greater than or equal to from, may be greater than original.length, in which case (byte)0 is placed in all elements of the copy whose index is greater than or equal to original.length - from. The length of the returned array will be to - from.

copyOfRange

open static fun copyOfRange(
    original: ShortArray, 
    from: Int, 
    to: Int
): ShortArray

Copies the specified range of the specified array into a new array. The initial index of the range (from) must lie between zero and original.length, inclusive. The value at original[from] is placed into the initial element of the copy (unless from == original.length or from == to). Values from subsequent elements in the original array are placed into subsequent elements in the copy. The final index of the range (to), which must be greater than or equal to from, may be greater than original.length, in which case (short)0 is placed in all elements of the copy whose index is greater than or equal to original.length - from. The length of the returned array will be to - from.

copyOfRange

open static fun copyOfRange(
    original: IntArray, 
    from: Int, 
    to: Int
): IntArray

Copies the specified range of the specified array into a new array. The initial index of the range (from) must lie between zero and original.length, inclusive. The value at original[from] is placed into the initial element of the copy (unless from == original.length or from == to). Values from subsequent elements in the original array are placed into subsequent elements in the copy. The final index of the range (to), which must be greater than or equal to from, may be greater than original.length, in which case 0 is placed in all elements of the copy whose index is greater than or equal to original.length - from. The length of the returned array will be to - from.

copyOfRange

open static fun copyOfRange(
    original: LongArray, 
    from: Int, 
    to: Int
): LongArray

Copies the specified range of the specified array into a new array. The initial index of the range (from) must lie between zero and original.length, inclusive. The value at original[from] is placed into the initial element of the copy (unless from == original.length or from == to). Values from subsequent elements in the original array are placed into subsequent elements in the copy. The final index of the range (to), which must be greater than or equal to from, may be greater than original.length, in which case 0L is placed in all elements of the copy whose index is greater than or equal to original.length - from. The length of the returned array will be to - from.

copyOfRange

open static fun copyOfRange(
    original: CharArray, 
    from: Int, 
    to: Int
): CharArray

Copies the specified range of the specified array into a new array. The initial index of the range (from) must lie between zero and original.length, inclusive. The value at original[from] is placed into the initial element of the copy (unless from == original.length or from == to). Values from subsequent elements in the original array are placed into subsequent elements in the copy. The final index of the range (to), which must be greater than or equal to from, may be greater than original.length, in which case '\\u000' is placed in all elements of the copy whose index is greater than or equal to original.length - from. The length of the returned array will be to - from.

copyOfRange

open static fun copyOfRange(
    original: FloatArray, 
    from: Int, 
    to: Int
): FloatArray

Copies the specified range of the specified array into a new array. The initial index of the range (from) must lie between zero and original.length, inclusive. The value at original[from] is placed into the initial element of the copy (unless from == original.length or from == to). Values from subsequent elements in the original array are placed into subsequent elements in the copy. The final index of the range (to), which must be greater than or equal to from, may be greater than original.length, in which case 0f is placed in all elements of the copy whose index is greater than or equal to original.length - from. The length of the returned array will be to - from.

copyOfRange

open static fun copyOfRange(
    original: DoubleArray, 
    from: Int, 
    to: Int
): DoubleArray

Copies the specified range of the specified array into a new array. The initial index of the range (from) must lie between zero and original.length, inclusive. The value at original[from] is placed into the initial element of the copy (unless from == original.length or from == to). Values from subsequent elements in the original array are placed into subsequent elements in the copy. The final index of the range (to), which must be greater than or equal to from, may be greater than original.length, in which case 0d is placed in all elements of the copy whose index is greater than or equal to original.length - from. The length of the returned array will be to - from.

copyOfRange

open static fun copyOfRange(
    original: BooleanArray, 
    from: Int, 
    to: Int
): BooleanArray

Copies the specified range of the specified array into a new array. The initial index of the range (from) must lie between zero and original.length, inclusive. The value at original[from] is placed into the initial element of the copy (unless from == original.length or from == to). Values from subsequent elements in the original array are placed into subsequent elements in the copy. The final index of the range (to), which must be greater than or equal to from, may be greater than original.length, in which case false is placed in all elements of the copy whose index is greater than or equal to original.length - from. The length of the returned array will be to - from.

deepEquals

open static fun deepEquals(
    a1: Array<Any!>?, 
    a2: Array<Any!>?
): Boolean

Returns true if the two specified arrays are deeply equal to one another. Unlike the equals(java.lang.Object[],java.lang.Object[]) method, this method is appropriate for use with nested arrays of arbitrary depth.

Two array references are considered deeply equal if both are null, or if they refer to arrays that contain the same number of elements and all corresponding pairs of elements in the two arrays are deeply equal.

Two possibly null elements e1 and e2 are deeply equal if any of the following conditions hold:

• e1 and e2 are both arrays of object reference types, and Arrays.deepEquals(e1, e2) would return true
• e1 and e2 are arrays of the same primitive type, and the appropriate overloading of Arrays.equals(e1, e2) would return true.
• e1 == e2
• e1.equals(e2) would return true.

If either of the specified arrays contain themselves as elements either directly or indirectly through one or more levels of arrays, the behavior of this method is undefined.

deepHashCode

open static fun deepHashCode(a: Array<Any!>?): Int

Returns a hash code based on the "deep contents" of the specified array. If the array contains other arrays as elements, the hash code is based on their contents and so on, ad infinitum. It is therefore unacceptable to invoke this method on an array that contains itself as an element, either directly or indirectly through one or more levels of arrays. The behavior of such an invocation is undefined.

For any two arrays a and b such that Arrays.deepEquals(a, b), it is also the case that Arrays.deepHashCode(a) == Arrays.deepHashCode(b).

The computation of the value returned by this method is similar to that of the value returned by List#hashCode() on a list containing the same elements as a in the same order, with one difference: If an element e of a is itself an array, its hash code is computed not by calling e.hashCode(), but as by calling the appropriate overloading of Arrays.hashCode(e) if e is an array of a primitive type, or as by calling Arrays.deepHashCode(e) recursively if e is an array of a reference type. If a is null, this method returns 0.

deepToString

open static fun deepToString(a: Array<Any!>?): String

Returns a string representation of the "deep contents" of the specified array. If the array contains other arrays as elements, the string representation contains their contents and so on. This method is designed for converting multidimensional arrays to strings.

The string representation consists of a list of the array's elements, enclosed in square brackets ("[]"). Adjacent elements are separated by the characters ", " (a comma followed by a space). Elements are converted to strings as by String.valueOf(Object), unless they are themselves arrays.

If an element e is an array of a primitive type, it is converted to a string as by invoking the appropriate overloading of Arrays.toString(e). If an element e is an array of a reference type, it is converted to a string as by invoking this method recursively.

To avoid infinite recursion, if the specified array contains itself as an element, or contains an indirect reference to itself through one or more levels of arrays, the self-reference is converted to the string "[...]". For example, an array containing only a reference to itself would be rendered as "[[...]]".

This method returns "null" if the specified array is null.

equals

open static fun equals(
    a: LongArray?, 
    a2: LongArray?
): Boolean

Returns true if the two specified arrays of longs are equal to one another. Two arrays are considered equal if both arrays contain the same number of elements, and all corresponding pairs of elements in the two arrays are equal. In other words, two arrays are equal if they contain the same elements in the same order. Also, two array references are considered equal if both are null.

equals

open static fun equals(
    a: IntArray?, 
    a2: IntArray?
): Boolean

Returns true if the two specified arrays of ints are equal to one another. Two arrays are considered equal if both arrays contain the same number of elements, and all corresponding pairs of elements in the two arrays are equal. In other words, two arrays are equal if they contain the same elements in the same order. Also, two array references are considered equal if both are null.

equals

open static fun equals(
    a: ShortArray?, 
    a2: ShortArray?
): Boolean

Returns true if the two specified arrays of shorts are equal to one another. Two arrays are considered equal if both arrays contain the same number of elements, and all corresponding pairs of elements in the two arrays are equal. In other words, two arrays are equal if they contain the same elements in the same order. Also, two array references are considered equal if both are null.

equals

open static fun equals(
    a: CharArray?, 
    a2: CharArray?
): Boolean

Returns true if the two specified arrays of chars are equal to one another. Two arrays are considered equal if both arrays contain the same number of elements, and all corresponding pairs of elements in the two arrays are equal. In other words, two arrays are equal if they contain the same elements in the same order. Also, two array references are considered equal if both are null.

equals

open static fun equals(
    a: ByteArray?, 
    a2: ByteArray?
): Boolean

Returns true if the two specified arrays of bytes are equal to one another. Two arrays are considered equal if both arrays contain the same number of elements, and all corresponding pairs of elements in the two arrays are equal. In other words, two arrays are equal if they contain the same elements in the same order. Also, two array references are considered equal if both are null.

equals

open static fun equals(
    a: BooleanArray?, 
    a2: BooleanArray?
): Boolean

Returns true if the two specified arrays of booleans are equal to one another. Two arrays are considered equal if both arrays contain the same number of elements, and all corresponding pairs of elements in the two arrays are equal. In other words, two arrays are equal if they contain the same elements in the same order. Also, two array references are considered equal if both are null.

equals

open static fun equals(
    a: DoubleArray?, 
    a2: DoubleArray?
): Boolean

Returns true if the two specified arrays of doubles are equal to one another. Two arrays are considered equal if both arrays contain the same number of elements, and all corresponding pairs of elements in the two arrays are equal. In other words, two arrays are equal if they contain the same elements in the same order. Also, two array references are considered equal if both are null.

Two doubles d1 and d2 are considered equal if:

<tt>new Double(d1).equals(new Double(d2))</tt>

equals

open static fun equals(
    a: FloatArray?, 
    a2: FloatArray?
): Boolean

Returns true if the two specified arrays of floats are equal to one another. Two arrays are considered equal if both arrays contain the same number of elements, and all corresponding pairs of elements in the two arrays are equal. In other words, two arrays are equal if they contain the same elements in the same order. Also, two array references are considered equal if both are null.

Two floats f1 and f2 are considered equal if:

<tt>new Float(f1).equals(new Float(f2))</tt>

equals

open static fun equals(
    a: Array<Any!>?, 
    a2: Array<Any!>?
): Boolean

Returns true if the two specified arrays of Objects are equal to one another. The two arrays are considered equal if both arrays contain the same number of elements, and all corresponding pairs of elements in the two arrays are equal. Two objects e1 and e2 are considered equal if (e1==null ? e2==null : e1.equals(e2)). In other words, the two arrays are equal if they contain the same elements in the same order. Also, two array references are considered equal if both are null.

fill

open static fun fill(
    a: LongArray, 
    val: Long
): Unit

Assigns the specified long value to each element of the specified array of longs.

fill

open static fun fill(
    a: LongArray, 
    fromIndex: Int, 
    toIndex: Int, 
    val: Long
): Unit

Assigns the specified long value to each element of the specified range of the specified array of longs. The range to be filled extends from index fromIndex, inclusive, to index toIndex, exclusive. (If fromIndex==toIndex, the range to be filled is empty.)

fill

open static fun fill(
    a: IntArray, 
    val: Int
): Unit

Assigns the specified int value to each element of the specified array of ints.

fill

open static fun fill(
    a: IntArray, 
    fromIndex: Int, 
    toIndex: Int, 
    val: Int
): Unit

Assigns the specified int value to each element of the specified range of the specified array of ints. The range to be filled extends from index fromIndex, inclusive, to index toIndex, exclusive. (If fromIndex==toIndex, the range to be filled is empty.)

fill

open static fun fill(
    a: ShortArray, 
    val: Short
): Unit

Assigns the specified short value to each element of the specified array of shorts.

fill

open static fun fill(
    a: ShortArray, 
    fromIndex: Int, 
    toIndex: Int, 
    val: Short
): Unit