public Class ArraysSupport

Calculates the hash code for the subrange of an integer array.

This method does not perform type checks or bounds checks. It is the responsibility of the caller to perform such checks before calling this method.

Parameters

a:int[]

the array

fromIndex:int

the first index of the subrange of the array

length:int

the number of elements in the subrange

initialValue:int

the initial hash value, typically 0 or 1

Returns:int

the calculated hash value

Calculates the hash code for the subrange of a short array.

This method does not perform type checks or bounds checks. It is the responsibility of the caller to perform such checks before calling this method.

Parameters

a:short[]

the array

fromIndex:int

the first index of the subrange of the array

length:int

the number of elements in the subrange

initialValue:int

the initial hash value, typically 0 or 1

Returns:int

the calculated hash value

Calculates the hash code for the subrange of a char array.

This method does not perform type checks or bounds checks. It is the responsibility of the caller to perform such checks before calling this method.

Parameters

a:char[]

the array

fromIndex:int

the first index of the subrange of the array

length:int

the number of elements in the subrange

initialValue:int

the initial hash value, typically 0 or 1

Returns:int

the calculated hash value

Calculates the hash code for the subrange of a byte array.

This method does not perform type checks or bounds checks. It is the responsibility of the caller to perform such checks before calling this method.

Parameters

a:byte[]

the array

fromIndex:int

the first index of the subrange of the array

length:int

the number of elements in the subrange

initialValue:int

the initial hash value, typically 0 or 1

Returns:int

the calculated hash value

Calculates the hash code for the subrange of an object array.

This method does not perform type checks or bounds checks. It is the responsibility of the caller to perform such checks before calling this method.

Parameters

a:Object[]

the array

fromIndex:int

the first index of the subrange of the array

length:int

the number of elements in the subrange

initialValue:int

the initial hash value, typically 0 or 1

Returns:int

the calculated hash value

Calculates the hash code for the subrange of a byte array whose elements are treated as unsigned bytes.

This method does not perform type checks or bounds checks. It is the responsibility of the caller to perform such checks before calling this method.

Parameters

a:byte[]

the array

fromIndex:int

the first index of the subrange of the array

length:int

the number of elements in the subrange

initialValue:int

the initial hash value, typically 0 or 1

Returns:int

the calculated hash value

Calculates the hash code for the subrange of a byte array whose contents are treated as UTF-16 chars.

This method does not perform type checks or bounds checks. It is the responsibility of the caller to perform such checks before calling this method.

fromIndex and length must be scaled down to char indexes.

Parameters

a:byte[]

the array

fromIndex:int

the first index of a char in the subrange of the array

length:int

the number of chars in the subrange

initialValue:int

the initial hash value, typically 0 or 1

Returns:int

the calculated hash value

Find the index of a mismatch between two arrays.

This method does not perform bounds checks. It is the responsibility of the caller to perform such bounds checks before calling this method.

Parameters

a:byte[]

the first array to be tested for a mismatch

b:byte[]

the second array to be tested for a mismatch

length:int

the number of bytes from each array to check

Returns:int

the index of a mismatch between the two arrays, otherwise -1 if no mismatch. The index will be within the range of (inclusive) 0 to (exclusive) the smaller of the two array lengths.

Find the relative index of a mismatch between two arrays starting from given indexes.

This method does not perform bounds checks. It is the responsibility of the caller to perform such bounds checks before calling this method.

Parameters

a:byte[]

the first array to be tested for a mismatch

aFromIndex:int

the index of the first element (inclusive) in the first array to be compared

b:byte[]

the second array to be tested for a mismatch

bFromIndex:int

the index of the first element (inclusive) in the second array to be compared

length:int

the number of bytes from each array to check

Returns:int

the relative index of a mismatch between the two arrays, otherwise -1 if no mismatch. The index will be within the range of (inclusive) 0 to (exclusive) the smaller of the two array bounds.

Computes a new array length given an array's current length, a minimum growth amount, and a preferred growth amount. The computation is done in an overflow-safe fashion. This method is used by objects that contain an array that might need to be grown in order to fulfill some immediate need (the minimum growth amount) but would also like to request more space (the preferred growth amount) in order to accommodate potential future needs. The returned length is usually clamped at the soft maximum length in order to avoid hitting the JVM implementation limit. However, the soft maximum will be exceeded if the minimum growth amount requires it. If the preferred growth amount is less than the minimum growth amount, the minimum growth amount is used as the preferred growth amount. The preferred length is determined by adding the preferred growth amount to the current length. If the preferred length does not exceed the soft maximum length (SOFT_MAX_ARRAY_LENGTH) then the preferred length is returned. If the preferred length exceeds the soft maximum, we use the minimum growth amount. The minimum required length is determined by adding the minimum growth amount to the current length. If the minimum required length exceeds Integer.MAX_VALUE, then this method throws OutOfMemoryError. Otherwise, this method returns the greater of the soft maximum or the minimum required length. Note that this method does not do any array allocation itself; it only does array length growth computations. However, it will throw OutOfMemoryError as noted above. Note also that this method cannot detect the JVM's implementation limit, and it may compute and return a length value up to and including Integer.MAX_VALUE that might exceed the JVM's implementation limit. In that case, the caller will likely attempt an array allocation with that length and encounter an OutOfMemoryError. Of course, regardless of the length value returned from this method, the caller may encounter OutOfMemoryError if there is insufficient heap to fulfill the request.

Parameters

oldLength:int

current length of the array (must be nonnegative)

minGrowth:int

minimum required growth amount (must be positive)

prefGrowth:int

preferred growth amount

Returns:int

the new array length

Exceptions

OutOfMemoryError:

if the new length would exceed Integer.MAX_VALUE

Reverses the elements of an array in-place.

Parameters

<T>

the array component type

a:T[]

the array to be reversed

Returns:T[]

the reversed array, always the same array as the argument

Dump the contents of the given collection into the given array, in reverse order. This mirrors the semantics of Collection.toArray(T[]) in regard to reusing the given array, appending null if necessary, or allocating a new array of the same component type.

A constraint is that this method should issue exactly one method call on the collection to obtain the elements and the size. Having a separate size() call or using an Iterator could result in errors if the collection changes size between calls. This implies that the elements need to be obtained via a single call to one of the toArray() methods. This further implies allocating memory proportional to the number of elements and making an extra copy, but this seems unavoidable.

An obvious approach would be simply to call coll.toArray(array) and then reverse the order of the elements. This doesn't work, because if given array is sufficiently long, we cannot tell how many elements were copied into it and thus there is no way to reverse the right set of elements while leaving the remaining array elements undisturbed.

Exceptions

ArrayStoreException:

if coll contains elements that can't be stored in the array

Find the relative index of the first mismatching pair of elements in two primitive arrays of the same component type. Pairs of elements will be tested in order relative to given offsets into both arrays.

This method does not perform type checks or bounds checks. It is the responsibility of the caller to perform such checks before calling this method.

The given offsets, in bytes, need not be aligned according to the given log₂ size the array elements. More specifically, an offset modulus the size need not be zero.

Parameters

a:Object

the first array to be tested for mismatch, or null for direct memory access

aOffset:long

the relative offset, in bytes, from the base address of the first array to test from, otherwise if the first array is null, an absolute address pointing to the first element to test.

b:Object

the second array to be tested for mismatch, or null for direct memory access

bOffset:long

the relative offset, in bytes, from the base address of the second array to test from, otherwise if the second array is null, an absolute address pointing to the first element to test.

length:int

the number of array elements to test

log2ArrayIndexScale:int

log₂ of the array index scale, that corresponds to the size, in bytes, of an array element.

Returns:int

if a mismatch is found a relative index, between 0 (inclusive) and length (exclusive), of the first mismatching pair of elements in the two arrays. Otherwise, if a mismatch is not found the bitwise compliment of the number of remaining pairs of elements to be checked in the tail of the two arrays.

Annotations

@IntrinsicCandidate