)first).compareTo(second);
}
static final NaturalOrder INSTANCE = new NaturalOrder();
}
/**
* Checks that {@code fromIndex} and {@code toIndex} are in
* the range and throws an exception if they aren't.
*/
static void rangeCheck(int arrayLength, int fromIndex, int toIndex) {
if (fromIndex > toIndex) {
throw new IllegalArgumentException(
"fromIndex(" + fromIndex + ") > toIndex(" + toIndex + ")");
}
if (fromIndex < 0) {
throw new ArrayIndexOutOfBoundsException(fromIndex);
}
if (toIndex > arrayLength) {
throw new ArrayIndexOutOfBoundsException(toIndex);
}
}
/*
* Sorting methods. Note that all public "sort" methods take the
* same form: Performing argument checks if necessary, and then
* expanding arguments into those required for the internal
* implementation methods residing in other package-private
* classes (except for legacyMergeSort, included in this class).
*/
/**
* Sorts the specified array into ascending numerical order.
*
* Implementation note: The sorting algorithm is a Dual-Pivot Quicksort
* by Vladimir Yaroslavskiy, Jon Bentley, and Joshua Bloch. This algorithm
* offers O(n log(n)) performance on many data sets that cause other
* quicksorts to degrade to quadratic performance, and is typically
* faster than traditional (one-pivot) Quicksort implementations.
*
* @param a the array to be sorted
*/
public static void sort(int[] a) {
DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0);
}
/**
* Sorts the specified range of the array into ascending order. The range
* to be sorted extends from the index {@code fromIndex}, inclusive, to
* the index {@code toIndex}, exclusive. If {@code fromIndex == toIndex},
* the range to be sorted is empty.
*
*
Implementation note: The sorting algorithm is a Dual-Pivot Quicksort
* by Vladimir Yaroslavskiy, Jon Bentley, and Joshua Bloch. This algorithm
* offers O(n log(n)) performance on many data sets that cause other
* quicksorts to degrade to quadratic performance, and is typically
* faster than traditional (one-pivot) Quicksort implementations.
*
* @param a the array to be sorted
* @param fromIndex the index of the first element, inclusive, to be sorted
* @param toIndex the index of the last element, exclusive, to be sorted
*
* @throws IllegalArgumentException if {@code fromIndex > toIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code fromIndex < 0} or {@code toIndex > a.length}
*/
public static void sort(int[] a, int fromIndex, int toIndex) {
rangeCheck(a.length, fromIndex, toIndex);
DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0);
}
/**
* Sorts the specified array into ascending numerical order.
*
*
Implementation note: The sorting algorithm is a Dual-Pivot Quicksort
* by Vladimir Yaroslavskiy, Jon Bentley, and Joshua Bloch. This algorithm
* offers O(n log(n)) performance on many data sets that cause other
* quicksorts to degrade to quadratic performance, and is typically
* faster than traditional (one-pivot) Quicksort implementations.
*
* @param a the array to be sorted
*/
public static void sort(long[] a) {
DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0);
}
/**
* Sorts the specified range of the array into ascending order. The range
* to be sorted extends from the index {@code fromIndex}, inclusive, to
* the index {@code toIndex}, exclusive. If {@code fromIndex == toIndex},
* the range to be sorted is empty.
*
*
Implementation note: The sorting algorithm is a Dual-Pivot Quicksort
* by Vladimir Yaroslavskiy, Jon Bentley, and Joshua Bloch. This algorithm
* offers O(n log(n)) performance on many data sets that cause other
* quicksorts to degrade to quadratic performance, and is typically
* faster than traditional (one-pivot) Quicksort implementations.
*
* @param a the array to be sorted
* @param fromIndex the index of the first element, inclusive, to be sorted
* @param toIndex the index of the last element, exclusive, to be sorted
*
* @throws IllegalArgumentException if {@code fromIndex > toIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code fromIndex < 0} or {@code toIndex > a.length}
*/
public static void sort(long[] a, int fromIndex, int toIndex) {
rangeCheck(a.length, fromIndex, toIndex);
DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0);
}
/**
* Sorts the specified array into ascending numerical order.
*
*
Implementation note: The sorting algorithm is a Dual-Pivot Quicksort
* by Vladimir Yaroslavskiy, Jon Bentley, and Joshua Bloch. This algorithm
* offers O(n log(n)) performance on many data sets that cause other
* quicksorts to degrade to quadratic performance, and is typically
* faster than traditional (one-pivot) Quicksort implementations.
*
* @param a the array to be sorted
*/
public static void sort(short[] a) {
DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0);
}
/**
* Sorts the specified range of the array into ascending order. The range
* to be sorted extends from the index {@code fromIndex}, inclusive, to
* the index {@code toIndex}, exclusive. If {@code fromIndex == toIndex},
* the range to be sorted is empty.
*
*
Implementation note: The sorting algorithm is a Dual-Pivot Quicksort
* by Vladimir Yaroslavskiy, Jon Bentley, and Joshua Bloch. This algorithm
* offers O(n log(n)) performance on many data sets that cause other
* quicksorts to degrade to quadratic performance, and is typically
* faster than traditional (one-pivot) Quicksort implementations.
*
* @param a the array to be sorted
* @param fromIndex the index of the first element, inclusive, to be sorted
* @param toIndex the index of the last element, exclusive, to be sorted
*
* @throws IllegalArgumentException if {@code fromIndex > toIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code fromIndex < 0} or {@code toIndex > a.length}
*/
public static void sort(short[] a, int fromIndex, int toIndex) {
rangeCheck(a.length, fromIndex, toIndex);
DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0);
}
/**
* Sorts the specified array into ascending numerical order.
*
*
Implementation note: The sorting algorithm is a Dual-Pivot Quicksort
* by Vladimir Yaroslavskiy, Jon Bentley, and Joshua Bloch. This algorithm
* offers O(n log(n)) performance on many data sets that cause other
* quicksorts to degrade to quadratic performance, and is typically
* faster than traditional (one-pivot) Quicksort implementations.
*
* @param a the array to be sorted
*/
public static void sort(char[] a) {
DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0);
}
/**
* Sorts the specified range of the array into ascending order. The range
* to be sorted extends from the index {@code fromIndex}, inclusive, to
* the index {@code toIndex}, exclusive. If {@code fromIndex == toIndex},
* the range to be sorted is empty.
*
*
Implementation note: The sorting algorithm is a Dual-Pivot Quicksort
* by Vladimir Yaroslavskiy, Jon Bentley, and Joshua Bloch. This algorithm
* offers O(n log(n)) performance on many data sets that cause other
* quicksorts to degrade to quadratic performance, and is typically
* faster than traditional (one-pivot) Quicksort implementations.
*
* @param a the array to be sorted
* @param fromIndex the index of the first element, inclusive, to be sorted
* @param toIndex the index of the last element, exclusive, to be sorted
*
* @throws IllegalArgumentException if {@code fromIndex > toIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code fromIndex < 0} or {@code toIndex > a.length}
*/
public static void sort(char[] a, int fromIndex, int toIndex) {
rangeCheck(a.length, fromIndex, toIndex);
DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0);
}
/**
* Sorts the specified array into ascending numerical order.
*
*
Implementation note: The sorting algorithm is a Dual-Pivot Quicksort
* by Vladimir Yaroslavskiy, Jon Bentley, and Joshua Bloch. This algorithm
* offers O(n log(n)) performance on many data sets that cause other
* quicksorts to degrade to quadratic performance, and is typically
* faster than traditional (one-pivot) Quicksort implementations.
*
* @param a the array to be sorted
*/
public static void sort(byte[] a) {
DualPivotQuicksort.sort(a, 0, a.length - 1);
}
/**
* Sorts the specified range of the array into ascending order. The range
* to be sorted extends from the index {@code fromIndex}, inclusive, to
* the index {@code toIndex}, exclusive. If {@code fromIndex == toIndex},
* the range to be sorted is empty.
*
*
Implementation note: The sorting algorithm is a Dual-Pivot Quicksort
* by Vladimir Yaroslavskiy, Jon Bentley, and Joshua Bloch. This algorithm
* offers O(n log(n)) performance on many data sets that cause other
* quicksorts to degrade to quadratic performance, and is typically
* faster than traditional (one-pivot) Quicksort implementations.
*
* @param a the array to be sorted
* @param fromIndex the index of the first element, inclusive, to be sorted
* @param toIndex the index of the last element, exclusive, to be sorted
*
* @throws IllegalArgumentException if {@code fromIndex > toIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code fromIndex < 0} or {@code toIndex > a.length}
*/
public static void sort(byte[] a, int fromIndex, int toIndex) {
rangeCheck(a.length, fromIndex, toIndex);
DualPivotQuicksort.sort(a, fromIndex, toIndex - 1);
}
/**
* Sorts the specified array into ascending numerical order.
*
*
The {@code <} relation does not provide a total order on all float
* values: {@code -0.0f == 0.0f} is {@code true} and a {@code Float.NaN}
* value compares neither less than, greater than, nor equal to any value,
* even itself. This method uses the total order imposed by the method
* {@link Float#compareTo}: {@code -0.0f} is treated as less than value
* {@code 0.0f} and {@code Float.NaN} is considered greater than any
* other value and all {@code Float.NaN} values are considered equal.
*
*
Implementation note: The sorting algorithm is a Dual-Pivot Quicksort
* by Vladimir Yaroslavskiy, Jon Bentley, and Joshua Bloch. This algorithm
* offers O(n log(n)) performance on many data sets that cause other
* quicksorts to degrade to quadratic performance, and is typically
* faster than traditional (one-pivot) Quicksort implementations.
*
* @param a the array to be sorted
*/
public static void sort(float[] a) {
DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0);
}
/**
* Sorts the specified range of the array into ascending order. The range
* to be sorted extends from the index {@code fromIndex}, inclusive, to
* the index {@code toIndex}, exclusive. If {@code fromIndex == toIndex},
* the range to be sorted is empty.
*
*
The {@code <} relation does not provide a total order on all float
* values: {@code -0.0f == 0.0f} is {@code true} and a {@code Float.NaN}
* value compares neither less than, greater than, nor equal to any value,
* even itself. This method uses the total order imposed by the method
* {@link Float#compareTo}: {@code -0.0f} is treated as less than value
* {@code 0.0f} and {@code Float.NaN} is considered greater than any
* other value and all {@code Float.NaN} values are considered equal.
*
*
Implementation note: The sorting algorithm is a Dual-Pivot Quicksort
* by Vladimir Yaroslavskiy, Jon Bentley, and Joshua Bloch. This algorithm
* offers O(n log(n)) performance on many data sets that cause other
* quicksorts to degrade to quadratic performance, and is typically
* faster than traditional (one-pivot) Quicksort implementations.
*
* @param a the array to be sorted
* @param fromIndex the index of the first element, inclusive, to be sorted
* @param toIndex the index of the last element, exclusive, to be sorted
*
* @throws IllegalArgumentException if {@code fromIndex > toIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code fromIndex < 0} or {@code toIndex > a.length}
*/
public static void sort(float[] a, int fromIndex, int toIndex) {
rangeCheck(a.length, fromIndex, toIndex);
DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0);
}
/**
* Sorts the specified array into ascending numerical order.
*
*
The {@code <} relation does not provide a total order on all double
* values: {@code -0.0d == 0.0d} is {@code true} and a {@code Double.NaN}
* value compares neither less than, greater than, nor equal to any value,
* even itself. This method uses the total order imposed by the method
* {@link Double#compareTo}: {@code -0.0d} is treated as less than value
* {@code 0.0d} and {@code Double.NaN} is considered greater than any
* other value and all {@code Double.NaN} values are considered equal.
*
*
Implementation note: The sorting algorithm is a Dual-Pivot Quicksort
* by Vladimir Yaroslavskiy, Jon Bentley, and Joshua Bloch. This algorithm
* offers O(n log(n)) performance on many data sets that cause other
* quicksorts to degrade to quadratic performance, and is typically
* faster than traditional (one-pivot) Quicksort implementations.
*
* @param a the array to be sorted
*/
public static void sort(double[] a) {
DualPivotQuicksort.sort(a, 0, a.length - 1, null, 0, 0);
}
/**
* Sorts the specified range of the array into ascending order. The range
* to be sorted extends from the index {@code fromIndex}, inclusive, to
* the index {@code toIndex}, exclusive. If {@code fromIndex == toIndex},
* the range to be sorted is empty.
*
*
The {@code <} relation does not provide a total order on all double
* values: {@code -0.0d == 0.0d} is {@code true} and a {@code Double.NaN}
* value compares neither less than, greater than, nor equal to any value,
* even itself. This method uses the total order imposed by the method
* {@link Double#compareTo}: {@code -0.0d} is treated as less than value
* {@code 0.0d} and {@code Double.NaN} is considered greater than any
* other value and all {@code Double.NaN} values are considered equal.
*
*
Implementation note: The sorting algorithm is a Dual-Pivot Quicksort
* by Vladimir Yaroslavskiy, Jon Bentley, and Joshua Bloch. This algorithm
* offers O(n log(n)) performance on many data sets that cause other
* quicksorts to degrade to quadratic performance, and is typically
* faster than traditional (one-pivot) Quicksort implementations.
*
* @param a the array to be sorted
* @param fromIndex the index of the first element, inclusive, to be sorted
* @param toIndex the index of the last element, exclusive, to be sorted
*
* @throws IllegalArgumentException if {@code fromIndex > toIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code fromIndex < 0} or {@code toIndex > a.length}
*/
public static void sort(double[] a, int fromIndex, int toIndex) {
rangeCheck(a.length, fromIndex, toIndex);
DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0);
}
/**
* Sorts the specified array into ascending numerical order.
*
* @implNote The sorting algorithm is a parallel sort-merge that breaks the
* array into sub-arrays that are themselves sorted and then merged. When
* the sub-array length reaches a minimum granularity, the sub-array is
* sorted using the appropriate {@link Arrays#sort(byte[]) Arrays.sort}
* method. If the length of the specified array is less than the minimum
* granularity, then it is sorted using the appropriate {@link
* Arrays#sort(byte[]) Arrays.sort} method. The algorithm requires a
* working space no greater than the size of the original array. The
* {@link ForkJoinPool#commonPool() ForkJoin common pool} is used to
* execute any parallel tasks.
*
* @param a the array to be sorted
*
* @since 1.8
*/
public static void parallelSort(byte[] a) {
int n = a.length, p, g;
if (n <= MIN_ARRAY_SORT_GRAN ||
(p = ForkJoinPool.getCommonPoolParallelism()) == 1)
DualPivotQuicksort.sort(a, 0, n - 1);
else
new ArraysParallelSortHelpers.FJByte.Sorter
(null, a, new byte[n], 0, n, 0,
((g = n / (p << 2)) <= MIN_ARRAY_SORT_GRAN) ?
MIN_ARRAY_SORT_GRAN : g).invoke();
}
/**
* Sorts the specified range of the array into ascending numerical order.
* The range to be sorted extends from the index {@code fromIndex},
* inclusive, to the index {@code toIndex}, exclusive. If
* {@code fromIndex == toIndex}, the range to be sorted is empty.
*
* @implNote The sorting algorithm is a parallel sort-merge that breaks the
* array into sub-arrays that are themselves sorted and then merged. When
* the sub-array length reaches a minimum granularity, the sub-array is
* sorted using the appropriate {@link Arrays#sort(byte[]) Arrays.sort}
* method. If the length of the specified array is less than the minimum
* granularity, then it is sorted using the appropriate {@link
* Arrays#sort(byte[]) Arrays.sort} method. The algorithm requires a working
* space no greater than the size of the specified range of the original
* array. The {@link ForkJoinPool#commonPool() ForkJoin common pool} is
* used to execute any parallel tasks.
*
* @param a the array to be sorted
* @param fromIndex the index of the first element, inclusive, to be sorted
* @param toIndex the index of the last element, exclusive, to be sorted
*
* @throws IllegalArgumentException if {@code fromIndex > toIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code fromIndex < 0} or {@code toIndex > a.length}
*
* @since 1.8
*/
public static void parallelSort(byte[] a, int fromIndex, int toIndex) {
rangeCheck(a.length, fromIndex, toIndex);
int n = toIndex - fromIndex, p, g;
if (n <= MIN_ARRAY_SORT_GRAN ||
(p = ForkJoinPool.getCommonPoolParallelism()) == 1)
DualPivotQuicksort.sort(a, fromIndex, toIndex - 1);
else
new ArraysParallelSortHelpers.FJByte.Sorter
(null, a, new byte[n], fromIndex, n, 0,
((g = n / (p << 2)) <= MIN_ARRAY_SORT_GRAN) ?
MIN_ARRAY_SORT_GRAN : g).invoke();
}
/**
* Sorts the specified array into ascending numerical order.
*
* @implNote The sorting algorithm is a parallel sort-merge that breaks the
* array into sub-arrays that are themselves sorted and then merged. When
* the sub-array length reaches a minimum granularity, the sub-array is
* sorted using the appropriate {@link Arrays#sort(char[]) Arrays.sort}
* method. If the length of the specified array is less than the minimum
* granularity, then it is sorted using the appropriate {@link
* Arrays#sort(char[]) Arrays.sort} method. The algorithm requires a
* working space no greater than the size of the original array. The
* {@link ForkJoinPool#commonPool() ForkJoin common pool} is used to
* execute any parallel tasks.
*
* @param a the array to be sorted
*
* @since 1.8
*/
public static void parallelSort(char[] a) {
int n = a.length, p, g;
if (n <= MIN_ARRAY_SORT_GRAN ||
(p = ForkJoinPool.getCommonPoolParallelism()) == 1)
DualPivotQuicksort.sort(a, 0, n - 1, null, 0, 0);
else
new ArraysParallelSortHelpers.FJChar.Sorter
(null, a, new char[n], 0, n, 0,
((g = n / (p << 2)) <= MIN_ARRAY_SORT_GRAN) ?
MIN_ARRAY_SORT_GRAN : g).invoke();
}
/**
* Sorts the specified range of the array into ascending numerical order.
* The range to be sorted extends from the index {@code fromIndex},
* inclusive, to the index {@code toIndex}, exclusive. If
* {@code fromIndex == toIndex}, the range to be sorted is empty.
*
@implNote The sorting algorithm is a parallel sort-merge that breaks the
* array into sub-arrays that are themselves sorted and then merged. When
* the sub-array length reaches a minimum granularity, the sub-array is
* sorted using the appropriate {@link Arrays#sort(char[]) Arrays.sort}
* method. If the length of the specified array is less than the minimum
* granularity, then it is sorted using the appropriate {@link
* Arrays#sort(char[]) Arrays.sort} method. The algorithm requires a working
* space no greater than the size of the specified range of the original
* array. The {@link ForkJoinPool#commonPool() ForkJoin common pool} is
* used to execute any parallel tasks.
*
* @param a the array to be sorted
* @param fromIndex the index of the first element, inclusive, to be sorted
* @param toIndex the index of the last element, exclusive, to be sorted
*
* @throws IllegalArgumentException if {@code fromIndex > toIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code fromIndex < 0} or {@code toIndex > a.length}
*
* @since 1.8
*/
public static void parallelSort(char[] a, int fromIndex, int toIndex) {
rangeCheck(a.length, fromIndex, toIndex);
int n = toIndex - fromIndex, p, g;
if (n <= MIN_ARRAY_SORT_GRAN ||
(p = ForkJoinPool.getCommonPoolParallelism()) == 1)
DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0);
else
new ArraysParallelSortHelpers.FJChar.Sorter
(null, a, new char[n], fromIndex, n, 0,
((g = n / (p << 2)) <= MIN_ARRAY_SORT_GRAN) ?
MIN_ARRAY_SORT_GRAN : g).invoke();
}
/**
* Sorts the specified array into ascending numerical order.
*
* @implNote The sorting algorithm is a parallel sort-merge that breaks the
* array into sub-arrays that are themselves sorted and then merged. When
* the sub-array length reaches a minimum granularity, the sub-array is
* sorted using the appropriate {@link Arrays#sort(short[]) Arrays.sort}
* method. If the length of the specified array is less than the minimum
* granularity, then it is sorted using the appropriate {@link
* Arrays#sort(short[]) Arrays.sort} method. The algorithm requires a
* working space no greater than the size of the original array. The
* {@link ForkJoinPool#commonPool() ForkJoin common pool} is used to
* execute any parallel tasks.
*
* @param a the array to be sorted
*
* @since 1.8
*/
public static void parallelSort(short[] a) {
int n = a.length, p, g;
if (n <= MIN_ARRAY_SORT_GRAN ||
(p = ForkJoinPool.getCommonPoolParallelism()) == 1)
DualPivotQuicksort.sort(a, 0, n - 1, null, 0, 0);
else
new ArraysParallelSortHelpers.FJShort.Sorter
(null, a, new short[n], 0, n, 0,
((g = n / (p << 2)) <= MIN_ARRAY_SORT_GRAN) ?
MIN_ARRAY_SORT_GRAN : g).invoke();
}
/**
* Sorts the specified range of the array into ascending numerical order.
* The range to be sorted extends from the index {@code fromIndex},
* inclusive, to the index {@code toIndex}, exclusive. If
* {@code fromIndex == toIndex}, the range to be sorted is empty.
*
* @implNote The sorting algorithm is a parallel sort-merge that breaks the
* array into sub-arrays that are themselves sorted and then merged. When
* the sub-array length reaches a minimum granularity, the sub-array is
* sorted using the appropriate {@link Arrays#sort(short[]) Arrays.sort}
* method. If the length of the specified array is less than the minimum
* granularity, then it is sorted using the appropriate {@link
* Arrays#sort(short[]) Arrays.sort} method. The algorithm requires a working
* space no greater than the size of the specified range of the original
* array. The {@link ForkJoinPool#commonPool() ForkJoin common pool} is
* used to execute any parallel tasks.
*
* @param a the array to be sorted
* @param fromIndex the index of the first element, inclusive, to be sorted
* @param toIndex the index of the last element, exclusive, to be sorted
*
* @throws IllegalArgumentException if {@code fromIndex > toIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code fromIndex < 0} or {@code toIndex > a.length}
*
* @since 1.8
*/
public static void parallelSort(short[] a, int fromIndex, int toIndex) {
rangeCheck(a.length, fromIndex, toIndex);
int n = toIndex - fromIndex, p, g;
if (n <= MIN_ARRAY_SORT_GRAN ||
(p = ForkJoinPool.getCommonPoolParallelism()) == 1)
DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0);
else
new ArraysParallelSortHelpers.FJShort.Sorter
(null, a, new short[n], fromIndex, n, 0,
((g = n / (p << 2)) <= MIN_ARRAY_SORT_GRAN) ?
MIN_ARRAY_SORT_GRAN : g).invoke();
}
/**
* Sorts the specified array into ascending numerical order.
*
* @implNote The sorting algorithm is a parallel sort-merge that breaks the
* array into sub-arrays that are themselves sorted and then merged. When
* the sub-array length reaches a minimum granularity, the sub-array is
* sorted using the appropriate {@link Arrays#sort(int[]) Arrays.sort}
* method. If the length of the specified array is less than the minimum
* granularity, then it is sorted using the appropriate {@link
* Arrays#sort(int[]) Arrays.sort} method. The algorithm requires a
* working space no greater than the size of the original array. The
* {@link ForkJoinPool#commonPool() ForkJoin common pool} is used to
* execute any parallel tasks.
*
* @param a the array to be sorted
*
* @since 1.8
*/
public static void parallelSort(int[] a) {
int n = a.length, p, g;
if (n <= MIN_ARRAY_SORT_GRAN ||
(p = ForkJoinPool.getCommonPoolParallelism()) == 1)
DualPivotQuicksort.sort(a, 0, n - 1, null, 0, 0);
else
new ArraysParallelSortHelpers.FJInt.Sorter
(null, a, new int[n], 0, n, 0,
((g = n / (p << 2)) <= MIN_ARRAY_SORT_GRAN) ?
MIN_ARRAY_SORT_GRAN : g).invoke();
}
/**
* Sorts the specified range of the array into ascending numerical order.
* The range to be sorted extends from the index {@code fromIndex},
* inclusive, to the index {@code toIndex}, exclusive. If
* {@code fromIndex == toIndex}, the range to be sorted is empty.
*
* @implNote The sorting algorithm is a parallel sort-merge that breaks the
* array into sub-arrays that are themselves sorted and then merged. When
* the sub-array length reaches a minimum granularity, the sub-array is
* sorted using the appropriate {@link Arrays#sort(int[]) Arrays.sort}
* method. If the length of the specified array is less than the minimum
* granularity, then it is sorted using the appropriate {@link
* Arrays#sort(int[]) Arrays.sort} method. The algorithm requires a working
* space no greater than the size of the specified range of the original
* array. The {@link ForkJoinPool#commonPool() ForkJoin common pool} is
* used to execute any parallel tasks.
*
* @param a the array to be sorted
* @param fromIndex the index of the first element, inclusive, to be sorted
* @param toIndex the index of the last element, exclusive, to be sorted
*
* @throws IllegalArgumentException if {@code fromIndex > toIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code fromIndex < 0} or {@code toIndex > a.length}
*
* @since 1.8
*/
public static void parallelSort(int[] a, int fromIndex, int toIndex) {
rangeCheck(a.length, fromIndex, toIndex);
int n = toIndex - fromIndex, p, g;
if (n <= MIN_ARRAY_SORT_GRAN ||
(p = ForkJoinPool.getCommonPoolParallelism()) == 1)
DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0);
else
new ArraysParallelSortHelpers.FJInt.Sorter
(null, a, new int[n], fromIndex, n, 0,
((g = n / (p << 2)) <= MIN_ARRAY_SORT_GRAN) ?
MIN_ARRAY_SORT_GRAN : g).invoke();
}
/**
* Sorts the specified array into ascending numerical order.
*
* @implNote The sorting algorithm is a parallel sort-merge that breaks the
* array into sub-arrays that are themselves sorted and then merged. When
* the sub-array length reaches a minimum granularity, the sub-array is
* sorted using the appropriate {@link Arrays#sort(long[]) Arrays.sort}
* method. If the length of the specified array is less than the minimum
* granularity, then it is sorted using the appropriate {@link
* Arrays#sort(long[]) Arrays.sort} method. The algorithm requires a
* working space no greater than the size of the original array. The
* {@link ForkJoinPool#commonPool() ForkJoin common pool} is used to
* execute any parallel tasks.
*
* @param a the array to be sorted
*
* @since 1.8
*/
public static void parallelSort(long[] a) {
int n = a.length, p, g;
if (n <= MIN_ARRAY_SORT_GRAN ||
(p = ForkJoinPool.getCommonPoolParallelism()) == 1)
DualPivotQuicksort.sort(a, 0, n - 1, null, 0, 0);
else
new ArraysParallelSortHelpers.FJLong.Sorter
(null, a, new long[n], 0, n, 0,
((g = n / (p << 2)) <= MIN_ARRAY_SORT_GRAN) ?
MIN_ARRAY_SORT_GRAN : g).invoke();
}
/**
* Sorts the specified range of the array into ascending numerical order.
* The range to be sorted extends from the index {@code fromIndex},
* inclusive, to the index {@code toIndex}, exclusive. If
* {@code fromIndex == toIndex}, the range to be sorted is empty.
*
* @implNote The sorting algorithm is a parallel sort-merge that breaks the
* array into sub-arrays that are themselves sorted and then merged. When
* the sub-array length reaches a minimum granularity, the sub-array is
* sorted using the appropriate {@link Arrays#sort(long[]) Arrays.sort}
* method. If the length of the specified array is less than the minimum
* granularity, then it is sorted using the appropriate {@link
* Arrays#sort(long[]) Arrays.sort} method. The algorithm requires a working
* space no greater than the size of the specified range of the original
* array. The {@link ForkJoinPool#commonPool() ForkJoin common pool} is
* used to execute any parallel tasks.
*
* @param a the array to be sorted
* @param fromIndex the index of the first element, inclusive, to be sorted
* @param toIndex the index of the last element, exclusive, to be sorted
*
* @throws IllegalArgumentException if {@code fromIndex > toIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code fromIndex < 0} or {@code toIndex > a.length}
*
* @since 1.8
*/
public static void parallelSort(long[] a, int fromIndex, int toIndex) {
rangeCheck(a.length, fromIndex, toIndex);
int n = toIndex - fromIndex, p, g;
if (n <= MIN_ARRAY_SORT_GRAN ||
(p = ForkJoinPool.getCommonPoolParallelism()) == 1)
DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0);
else
new ArraysParallelSortHelpers.FJLong.Sorter
(null, a, new long[n], fromIndex, n, 0,
((g = n / (p << 2)) <= MIN_ARRAY_SORT_GRAN) ?
MIN_ARRAY_SORT_GRAN : g).invoke();
}
/**
* Sorts the specified array into ascending numerical order.
*
*
The {@code <} relation does not provide a total order on all float
* values: {@code -0.0f == 0.0f} is {@code true} and a {@code Float.NaN}
* value compares neither less than, greater than, nor equal to any value,
* even itself. This method uses the total order imposed by the method
* {@link Float#compareTo}: {@code -0.0f} is treated as less than value
* {@code 0.0f} and {@code Float.NaN} is considered greater than any
* other value and all {@code Float.NaN} values are considered equal.
*
* @implNote The sorting algorithm is a parallel sort-merge that breaks the
* array into sub-arrays that are themselves sorted and then merged. When
* the sub-array length reaches a minimum granularity, the sub-array is
* sorted using the appropriate {@link Arrays#sort(float[]) Arrays.sort}
* method. If the length of the specified array is less than the minimum
* granularity, then it is sorted using the appropriate {@link
* Arrays#sort(float[]) Arrays.sort} method. The algorithm requires a
* working space no greater than the size of the original array. The
* {@link ForkJoinPool#commonPool() ForkJoin common pool} is used to
* execute any parallel tasks.
*
* @param a the array to be sorted
*
* @since 1.8
*/
public static void parallelSort(float[] a) {
int n = a.length, p, g;
if (n <= MIN_ARRAY_SORT_GRAN ||
(p = ForkJoinPool.getCommonPoolParallelism()) == 1)
DualPivotQuicksort.sort(a, 0, n - 1, null, 0, 0);
else
new ArraysParallelSortHelpers.FJFloat.Sorter
(null, a, new float[n], 0, n, 0,
((g = n / (p << 2)) <= MIN_ARRAY_SORT_GRAN) ?
MIN_ARRAY_SORT_GRAN : g).invoke();
}
/**
* Sorts the specified range of the array into ascending numerical order.
* The range to be sorted extends from the index {@code fromIndex},
* inclusive, to the index {@code toIndex}, exclusive. If
* {@code fromIndex == toIndex}, the range to be sorted is empty.
*
*
The {@code <} relation does not provide a total order on all float
* values: {@code -0.0f == 0.0f} is {@code true} and a {@code Float.NaN}
* value compares neither less than, greater than, nor equal to any value,
* even itself. This method uses the total order imposed by the method
* {@link Float#compareTo}: {@code -0.0f} is treated as less than value
* {@code 0.0f} and {@code Float.NaN} is considered greater than any
* other value and all {@code Float.NaN} values are considered equal.
*
* @implNote The sorting algorithm is a parallel sort-merge that breaks the
* array into sub-arrays that are themselves sorted and then merged. When
* the sub-array length reaches a minimum granularity, the sub-array is
* sorted using the appropriate {@link Arrays#sort(float[]) Arrays.sort}
* method. If the length of the specified array is less than the minimum
* granularity, then it is sorted using the appropriate {@link
* Arrays#sort(float[]) Arrays.sort} method. The algorithm requires a working
* space no greater than the size of the specified range of the original
* array. The {@link ForkJoinPool#commonPool() ForkJoin common pool} is
* used to execute any parallel tasks.
*
* @param a the array to be sorted
* @param fromIndex the index of the first element, inclusive, to be sorted
* @param toIndex the index of the last element, exclusive, to be sorted
*
* @throws IllegalArgumentException if {@code fromIndex > toIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code fromIndex < 0} or {@code toIndex > a.length}
*
* @since 1.8
*/
public static void parallelSort(float[] a, int fromIndex, int toIndex) {
rangeCheck(a.length, fromIndex, toIndex);
int n = toIndex - fromIndex, p, g;
if (n <= MIN_ARRAY_SORT_GRAN ||
(p = ForkJoinPool.getCommonPoolParallelism()) == 1)
DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0);
else
new ArraysParallelSortHelpers.FJFloat.Sorter
(null, a, new float[n], fromIndex, n, 0,
((g = n / (p << 2)) <= MIN_ARRAY_SORT_GRAN) ?
MIN_ARRAY_SORT_GRAN : g).invoke();
}
/**
* Sorts the specified array into ascending numerical order.
*
*
The {@code <} relation does not provide a total order on all double
* values: {@code -0.0d == 0.0d} is {@code true} and a {@code Double.NaN}
* value compares neither less than, greater than, nor equal to any value,
* even itself. This method uses the total order imposed by the method
* {@link Double#compareTo}: {@code -0.0d} is treated as less than value
* {@code 0.0d} and {@code Double.NaN} is considered greater than any
* other value and all {@code Double.NaN} values are considered equal.
*
* @implNote The sorting algorithm is a parallel sort-merge that breaks the
* array into sub-arrays that are themselves sorted and then merged. When
* the sub-array length reaches a minimum granularity, the sub-array is
* sorted using the appropriate {@link Arrays#sort(double[]) Arrays.sort}
* method. If the length of the specified array is less than the minimum
* granularity, then it is sorted using the appropriate {@link
* Arrays#sort(double[]) Arrays.sort} method. The algorithm requires a
* working space no greater than the size of the original array. The
* {@link ForkJoinPool#commonPool() ForkJoin common pool} is used to
* execute any parallel tasks.
*
* @param a the array to be sorted
*
* @since 1.8
*/
public static void parallelSort(double[] a) {
int n = a.length, p, g;
if (n <= MIN_ARRAY_SORT_GRAN ||
(p = ForkJoinPool.getCommonPoolParallelism()) == 1)
DualPivotQuicksort.sort(a, 0, n - 1, null, 0, 0);
else
new ArraysParallelSortHelpers.FJDouble.Sorter
(null, a, new double[n], 0, n, 0,
((g = n / (p << 2)) <= MIN_ARRAY_SORT_GRAN) ?
MIN_ARRAY_SORT_GRAN : g).invoke();
}
/**
* Sorts the specified range of the array into ascending numerical order.
* The range to be sorted extends from the index {@code fromIndex},
* inclusive, to the index {@code toIndex}, exclusive. If
* {@code fromIndex == toIndex}, the range to be sorted is empty.
*
*
The {@code <} relation does not provide a total order on all double
* values: {@code -0.0d == 0.0d} is {@code true} and a {@code Double.NaN}
* value compares neither less than, greater than, nor equal to any value,
* even itself. This method uses the total order imposed by the method
* {@link Double#compareTo}: {@code -0.0d} is treated as less than value
* {@code 0.0d} and {@code Double.NaN} is considered greater than any
* other value and all {@code Double.NaN} values are considered equal.
*
* @implNote The sorting algorithm is a parallel sort-merge that breaks the
* array into sub-arrays that are themselves sorted and then merged. When
* the sub-array length reaches a minimum granularity, the sub-array is
* sorted using the appropriate {@link Arrays#sort(double[]) Arrays.sort}
* method. If the length of the specified array is less than the minimum
* granularity, then it is sorted using the appropriate {@link
* Arrays#sort(double[]) Arrays.sort} method. The algorithm requires a working
* space no greater than the size of the specified range of the original
* array. The {@link ForkJoinPool#commonPool() ForkJoin common pool} is
* used to execute any parallel tasks.
*
* @param a the array to be sorted
* @param fromIndex the index of the first element, inclusive, to be sorted
* @param toIndex the index of the last element, exclusive, to be sorted
*
* @throws IllegalArgumentException if {@code fromIndex > toIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code fromIndex < 0} or {@code toIndex > a.length}
*
* @since 1.8
*/
public static void parallelSort(double[] a, int fromIndex, int toIndex) {
rangeCheck(a.length, fromIndex, toIndex);
int n = toIndex - fromIndex, p, g;
if (n <= MIN_ARRAY_SORT_GRAN ||
(p = ForkJoinPool.getCommonPoolParallelism()) == 1)
DualPivotQuicksort.sort(a, fromIndex, toIndex - 1, null, 0, 0);
else
new ArraysParallelSortHelpers.FJDouble.Sorter
(null, a, new double[n], fromIndex, n, 0,
((g = n / (p << 2)) <= MIN_ARRAY_SORT_GRAN) ?
MIN_ARRAY_SORT_GRAN : g).invoke();
}
/**
* Sorts the specified array of objects into ascending order, according
* to the {@linkplain Comparable natural ordering} of its elements.
* All elements in the array must implement the {@link Comparable}
* interface. Furthermore, all elements in the array must be
* mutually comparable (that is, {@code e1.compareTo(e2)} must
* not throw a {@code ClassCastException} for any elements {@code e1}
* and {@code e2} in the array).
*
*
This sort is guaranteed to be stable : equal elements will
* not be reordered as a result of the sort.
*
* @implNote The sorting algorithm is a parallel sort-merge that breaks the
* array into sub-arrays that are themselves sorted and then merged. When
* the sub-array length reaches a minimum granularity, the sub-array is
* sorted using the appropriate {@link Arrays#sort(Object[]) Arrays.sort}
* method. If the length of the specified array is less than the minimum
* granularity, then it is sorted using the appropriate {@link
* Arrays#sort(Object[]) Arrays.sort} method. The algorithm requires a
* working space no greater than the size of the original array. The
* {@link ForkJoinPool#commonPool() ForkJoin common pool} is used to
* execute any parallel tasks.
*
* @param the class of the objects to be sorted
* @param a the array to be sorted
*
* @throws ClassCastException if the array contains elements that are not
* mutually comparable (for example, strings and integers)
* @throws IllegalArgumentException (optional) if the natural
* ordering of the array elements is found to violate the
* {@link Comparable} contract
*
* @since 1.8
*/
@SuppressWarnings("unchecked")
public static > void parallelSort(T[] a) {
int n = a.length, p, g;
if (n <= MIN_ARRAY_SORT_GRAN ||
(p = ForkJoinPool.getCommonPoolParallelism()) == 1)
TimSort.sort(a, 0, n, NaturalOrder.INSTANCE, null, 0, 0);
else
new ArraysParallelSortHelpers.FJObject.Sorter<>
(null, a,
(T[])Array.newInstance(a.getClass().getComponentType(), n),
0, n, 0, ((g = n / (p << 2)) <= MIN_ARRAY_SORT_GRAN) ?
MIN_ARRAY_SORT_GRAN : g, NaturalOrder.INSTANCE).invoke();
}
/**
* Sorts the specified range of the specified array of objects into
* ascending order, according to the
* {@linkplain Comparable natural ordering} of its
* elements. The range to be sorted extends from index
* {@code fromIndex}, inclusive, to index {@code toIndex}, exclusive.
* (If {@code fromIndex==toIndex}, the range to be sorted is empty.) All
* elements in this range must implement the {@link Comparable}
* interface. Furthermore, all elements in this range must be mutually
* comparable (that is, {@code e1.compareTo(e2)} must not throw a
* {@code ClassCastException} for any elements {@code e1} and
* {@code e2} in the array).
*
* This sort is guaranteed to be stable : equal elements will
* not be reordered as a result of the sort.
*
* @implNote The sorting algorithm is a parallel sort-merge that breaks the
* array into sub-arrays that are themselves sorted and then merged. When
* the sub-array length reaches a minimum granularity, the sub-array is
* sorted using the appropriate {@link Arrays#sort(Object[]) Arrays.sort}
* method. If the length of the specified array is less than the minimum
* granularity, then it is sorted using the appropriate {@link
* Arrays#sort(Object[]) Arrays.sort} method. The algorithm requires a working
* space no greater than the size of the specified range of the original
* array. The {@link ForkJoinPool#commonPool() ForkJoin common pool} is
* used to execute any parallel tasks.
*
* @param the class of the objects to be sorted
* @param a the array to be sorted
* @param fromIndex the index of the first element (inclusive) to be
* sorted
* @param toIndex the index of the last element (exclusive) to be sorted
* @throws IllegalArgumentException if {@code fromIndex > toIndex} or
* (optional) if the natural ordering of the array elements is
* found to violate the {@link Comparable} contract
* @throws ArrayIndexOutOfBoundsException if {@code fromIndex < 0} or
* {@code toIndex > a.length}
* @throws ClassCastException if the array contains elements that are
* not mutually comparable (for example, strings and
* integers).
*
* @since 1.8
*/
@SuppressWarnings("unchecked")
public static >
void parallelSort(T[] a, int fromIndex, int toIndex) {
rangeCheck(a.length, fromIndex, toIndex);
int n = toIndex - fromIndex, p, g;
if (n <= MIN_ARRAY_SORT_GRAN ||
(p = ForkJoinPool.getCommonPoolParallelism()) == 1)
TimSort.sort(a, fromIndex, toIndex, NaturalOrder.INSTANCE, null, 0, 0);
else
new ArraysParallelSortHelpers.FJObject.Sorter<>
(null, a,
(T[])Array.newInstance(a.getClass().getComponentType(), n),
fromIndex, n, 0, ((g = n / (p << 2)) <= MIN_ARRAY_SORT_GRAN) ?
MIN_ARRAY_SORT_GRAN : g, NaturalOrder.INSTANCE).invoke();
}
/**
* Sorts the specified array of objects according to the order induced by
* the specified comparator. All elements in the array must be
* mutually comparable by the specified comparator (that is,
* {@code c.compare(e1, e2)} must not throw a {@code ClassCastException}
* for any elements {@code e1} and {@code e2} in the array).
*
* This sort is guaranteed to be stable : equal elements will
* not be reordered as a result of the sort.
*
* @implNote The sorting algorithm is a parallel sort-merge that breaks the
* array into sub-arrays that are themselves sorted and then merged. When
* the sub-array length reaches a minimum granularity, the sub-array is
* sorted using the appropriate {@link Arrays#sort(Object[]) Arrays.sort}
* method. If the length of the specified array is less than the minimum
* granularity, then it is sorted using the appropriate {@link
* Arrays#sort(Object[]) Arrays.sort} method. The algorithm requires a
* working space no greater than the size of the original array. The
* {@link ForkJoinPool#commonPool() ForkJoin common pool} is used to
* execute any parallel tasks.
*
* @param the class of the objects to be sorted
* @param a the array to be sorted
* @param cmp the comparator to determine the order of the array. A
* {@code null} value indicates that the elements'
* {@linkplain Comparable natural ordering} should be used.
* @throws ClassCastException if the array contains elements that are
* not mutually comparable using the specified comparator
* @throws IllegalArgumentException (optional) if the comparator is
* found to violate the {@link java.util.Comparator} contract
*
* @since 1.8
*/
@SuppressWarnings("unchecked")
public static void parallelSort(T[] a, Comparator cmp) {
if (cmp == null)
cmp = NaturalOrder.INSTANCE;
int n = a.length, p, g;
if (n <= MIN_ARRAY_SORT_GRAN ||
(p = ForkJoinPool.getCommonPoolParallelism()) == 1)
TimSort.sort(a, 0, n, cmp, null, 0, 0);
else
new ArraysParallelSortHelpers.FJObject.Sorter<>
(null, a,
(T[])Array.newInstance(a.getClass().getComponentType(), n),
0, n, 0, ((g = n / (p << 2)) <= MIN_ARRAY_SORT_GRAN) ?
MIN_ARRAY_SORT_GRAN : g, cmp).invoke();
}
/**
* Sorts the specified range of the specified array of objects according
* to the order induced by the specified comparator. The range to be
* sorted extends from index {@code fromIndex}, inclusive, to index
* {@code toIndex}, exclusive. (If {@code fromIndex==toIndex}, the
* range to be sorted is empty.) All elements in the range must be
* mutually comparable by the specified comparator (that is,
* {@code c.compare(e1, e2)} must not throw a {@code ClassCastException}
* for any elements {@code e1} and {@code e2} in the range).
*
* This sort is guaranteed to be stable : equal elements will
* not be reordered as a result of the sort.
*
* @implNote The sorting algorithm is a parallel sort-merge that breaks the
* array into sub-arrays that are themselves sorted and then merged. When
* the sub-array length reaches a minimum granularity, the sub-array is
* sorted using the appropriate {@link Arrays#sort(Object[]) Arrays.sort}
* method. If the length of the specified array is less than the minimum
* granularity, then it is sorted using the appropriate {@link
* Arrays#sort(Object[]) Arrays.sort} method. The algorithm requires a working
* space no greater than the size of the specified range of the original
* array. The {@link ForkJoinPool#commonPool() ForkJoin common pool} is
* used to execute any parallel tasks.
*
* @param the class of the objects to be sorted
* @param a the array to be sorted
* @param fromIndex the index of the first element (inclusive) to be
* sorted
* @param toIndex the index of the last element (exclusive) to be sorted
* @param cmp the comparator to determine the order of the array. A
* {@code null} value indicates that the elements'
* {@linkplain Comparable natural ordering} should be used.
* @throws IllegalArgumentException if {@code fromIndex > toIndex} or
* (optional) if the natural ordering of the array elements is
* found to violate the {@link Comparable} contract
* @throws ArrayIndexOutOfBoundsException if {@code fromIndex < 0} or
* {@code toIndex > a.length}
* @throws ClassCastException if the array contains elements that are
* not mutually comparable (for example, strings and
* integers).
*
* @since 1.8
*/
@SuppressWarnings("unchecked")
public static void parallelSort(T[] a, int fromIndex, int toIndex,
Comparator cmp) {
rangeCheck(a.length, fromIndex, toIndex);
if (cmp == null)
cmp = NaturalOrder.INSTANCE;
int n = toIndex - fromIndex, p, g;
if (n <= MIN_ARRAY_SORT_GRAN ||
(p = ForkJoinPool.getCommonPoolParallelism()) == 1)
TimSort.sort(a, fromIndex, toIndex, cmp, null, 0, 0);
else
new ArraysParallelSortHelpers.FJObject.Sorter<>
(null, a,
(T[])Array.newInstance(a.getClass().getComponentType(), n),
fromIndex, n, 0, ((g = n / (p << 2)) <= MIN_ARRAY_SORT_GRAN) ?
MIN_ARRAY_SORT_GRAN : g, cmp).invoke();
}
/*
* Sorting of complex type arrays.
*/
/**
* Old merge sort implementation can be selected (for
* compatibility with broken comparators) using a system property.
* Cannot be a static boolean in the enclosing class due to
* circular dependencies. To be removed in a future release.
*/
static final class LegacyMergeSort {
private static final boolean userRequested =
java.security.AccessController.doPrivileged(
new sun.security.action.GetBooleanAction(
"java.util.Arrays.useLegacyMergeSort")).booleanValue();
}
/**
* Sorts the specified array of objects into ascending order, according
* to the {@linkplain Comparable natural ordering} of its elements.
* All elements in the array must implement the {@link Comparable}
* interface. Furthermore, all elements in the array must be
* mutually comparable (that is, {@code e1.compareTo(e2)} must
* not throw a {@code ClassCastException} for any elements {@code e1}
* and {@code e2} in the array).
*
* This sort is guaranteed to be stable : equal elements will
* not be reordered as a result of the sort.
*
*
Implementation note: This implementation is a stable, adaptive,
* iterative mergesort that requires far fewer than n lg(n) comparisons
* when the input array is partially sorted, while offering the
* performance of a traditional mergesort when the input array is
* randomly ordered. If the input array is nearly sorted, the
* implementation requires approximately n comparisons. Temporary
* storage requirements vary from a small constant for nearly sorted
* input arrays to n/2 object references for randomly ordered input
* arrays.
*
*
The implementation takes equal advantage of ascending and
* descending order in its input array, and can take advantage of
* ascending and descending order in different parts of the same
* input array. It is well-suited to merging two or more sorted arrays:
* simply concatenate the arrays and sort the resulting array.
*
*
The implementation was adapted from Tim Peters's list sort for Python
* (
* TimSort ). It uses techniques from Peter McIlroy's "Optimistic
* Sorting and Information Theoretic Complexity", in Proceedings of the
* Fourth Annual ACM-SIAM Symposium on Discrete Algorithms, pp 467-474,
* January 1993.
*
* @param a the array to be sorted
* @throws ClassCastException if the array contains elements that are not
* mutually comparable (for example, strings and integers)
* @throws IllegalArgumentException (optional) if the natural
* ordering of the array elements is found to violate the
* {@link Comparable} contract
*/
public static void sort(Object[] a) {
if (LegacyMergeSort.userRequested)
legacyMergeSort(a);
else
ComparableTimSort.sort(a, 0, a.length, null, 0, 0);
}
/** To be removed in a future release. */
private static void legacyMergeSort(Object[] a) {
Object[] aux = a.clone();
mergeSort(aux, a, 0, a.length, 0);
}
/**
* Sorts the specified range of the specified array of objects into
* ascending order, according to the
* {@linkplain Comparable natural ordering} of its
* elements. The range to be sorted extends from index
* {@code fromIndex}, inclusive, to index {@code toIndex}, exclusive.
* (If {@code fromIndex==toIndex}, the range to be sorted is empty.) All
* elements in this range must implement the {@link Comparable}
* interface. Furthermore, all elements in this range must be mutually
* comparable (that is, {@code e1.compareTo(e2)} must not throw a
* {@code ClassCastException} for any elements {@code e1} and
* {@code e2} in the array).
*
*
This sort is guaranteed to be stable : equal elements will
* not be reordered as a result of the sort.
*
*
Implementation note: This implementation is a stable, adaptive,
* iterative mergesort that requires far fewer than n lg(n) comparisons
* when the input array is partially sorted, while offering the
* performance of a traditional mergesort when the input array is
* randomly ordered. If the input array is nearly sorted, the
* implementation requires approximately n comparisons. Temporary
* storage requirements vary from a small constant for nearly sorted
* input arrays to n/2 object references for randomly ordered input
* arrays.
*
*
The implementation takes equal advantage of ascending and
* descending order in its input array, and can take advantage of
* ascending and descending order in different parts of the same
* input array. It is well-suited to merging two or more sorted arrays:
* simply concatenate the arrays and sort the resulting array.
*
*
The implementation was adapted from Tim Peters's list sort for Python
* (
* TimSort ). It uses techniques from Peter McIlroy's "Optimistic
* Sorting and Information Theoretic Complexity", in Proceedings of the
* Fourth Annual ACM-SIAM Symposium on Discrete Algorithms, pp 467-474,
* January 1993.
*
* @param a the array to be sorted
* @param fromIndex the index of the first element (inclusive) to be
* sorted
* @param toIndex the index of the last element (exclusive) to be sorted
* @throws IllegalArgumentException if {@code fromIndex > toIndex} or
* (optional) if the natural ordering of the array elements is
* found to violate the {@link Comparable} contract
* @throws ArrayIndexOutOfBoundsException if {@code fromIndex < 0} or
* {@code toIndex > a.length}
* @throws ClassCastException if the array contains elements that are
* not mutually comparable (for example, strings and
* integers).
*/
public static void sort(Object[] a, int fromIndex, int toIndex) {
rangeCheck(a.length, fromIndex, toIndex);
if (LegacyMergeSort.userRequested)
legacyMergeSort(a, fromIndex, toIndex);
else
ComparableTimSort.sort(a, fromIndex, toIndex, null, 0, 0);
}
/** To be removed in a future release. */
private static void legacyMergeSort(Object[] a,
int fromIndex, int toIndex) {
Object[] aux = copyOfRange(a, fromIndex, toIndex);
mergeSort(aux, a, fromIndex, toIndex, -fromIndex);
}
/**
* Tuning parameter: list size at or below which insertion sort will be
* used in preference to mergesort.
* To be removed in a future release.
*/
private static final int INSERTIONSORT_THRESHOLD = 7;
/**
* Src is the source array that starts at index 0
* Dest is the (possibly larger) array destination with a possible offset
* low is the index in dest to start sorting
* high is the end index in dest to end sorting
* off is the offset to generate corresponding low, high in src
* To be removed in a future release.
*/
@SuppressWarnings({"unchecked", "rawtypes"})
private static void mergeSort(Object[] src,
Object[] dest,
int low,
int high,
int off) {
int length = high - low;
// Insertion sort on smallest arrays
if (length < INSERTIONSORT_THRESHOLD) {
for (int i=low; ilow &&
((Comparable) dest[j-1]).compareTo(dest[j])>0; j--)
swap(dest, j, j-1);
return;
}
// Recursively sort halves of dest into src
int destLow = low;
int destHigh = high;
low += off;
high += off;
int mid = (low + high) >>> 1;
mergeSort(dest, src, low, mid, -off);
mergeSort(dest, src, mid, high, -off);
// If list is already sorted, just copy from src to dest. This is an
// optimization that results in faster sorts for nearly ordered lists.
if (((Comparable)src[mid-1]).compareTo(src[mid]) <= 0) {
System.arraycopy(src, low, dest, destLow, length);
return;
}
// Merge sorted halves (now in src) into dest
for(int i = destLow, p = low, q = mid; i < destHigh; i++) {
if (q >= high || p < mid && ((Comparable)src[p]).compareTo(src[q])<=0)
dest[i] = src[p++];
else
dest[i] = src[q++];
}
}
/**
* Swaps x[a] with x[b].
*/
private static void swap(Object[] x, int a, int b) {
Object t = x[a];
x[a] = x[b];
x[b] = t;
}
/**
* Sorts the specified array of objects according to the order induced by
* the specified comparator. All elements in the array must be
* mutually comparable by the specified comparator (that is,
* {@code c.compare(e1, e2)} must not throw a {@code ClassCastException}
* for any elements {@code e1} and {@code e2} in the array).
*
* This sort is guaranteed to be stable : equal elements will
* not be reordered as a result of the sort.
*
*
Implementation note: This implementation is a stable, adaptive,
* iterative mergesort that requires far fewer than n lg(n) comparisons
* when the input array is partially sorted, while offering the
* performance of a traditional mergesort when the input array is
* randomly ordered. If the input array is nearly sorted, the
* implementation requires approximately n comparisons. Temporary
* storage requirements vary from a small constant for nearly sorted
* input arrays to n/2 object references for randomly ordered input
* arrays.
*
*
The implementation takes equal advantage of ascending and
* descending order in its input array, and can take advantage of
* ascending and descending order in different parts of the same
* input array. It is well-suited to merging two or more sorted arrays:
* simply concatenate the arrays and sort the resulting array.
*
*
The implementation was adapted from Tim Peters's list sort for Python
* (
* TimSort ). It uses techniques from Peter McIlroy's "Optimistic
* Sorting and Information Theoretic Complexity", in Proceedings of the
* Fourth Annual ACM-SIAM Symposium on Discrete Algorithms, pp 467-474,
* January 1993.
*
* @param the class of the objects to be sorted
* @param a the array to be sorted
* @param c the comparator to determine the order of the array. A
* {@code null} value indicates that the elements'
* {@linkplain Comparable natural ordering} should be used.
* @throws ClassCastException if the array contains elements that are
* not mutually comparable using the specified comparator
* @throws IllegalArgumentException (optional) if the comparator is
* found to violate the {@link Comparator} contract
*/
public static void sort(T[] a, Comparator c) {
if (c == null) {
sort(a);
} else {
if (LegacyMergeSort.userRequested)
legacyMergeSort(a, c);
else
TimSort.sort(a, 0, a.length, c, null, 0, 0);
}
}
/** To be removed in a future release. */
private static void legacyMergeSort(T[] a, Comparator c) {
T[] aux = a.clone();
if (c==null)
mergeSort(aux, a, 0, a.length, 0);
else
mergeSort(aux, a, 0, a.length, 0, c);
}
/**
* Sorts the specified range of the specified array of objects according
* to the order induced by the specified comparator. The range to be
* sorted extends from index {@code fromIndex}, inclusive, to index
* {@code toIndex}, exclusive. (If {@code fromIndex==toIndex}, the
* range to be sorted is empty.) All elements in the range must be
* mutually comparable by the specified comparator (that is,
* {@code c.compare(e1, e2)} must not throw a {@code ClassCastException}
* for any elements {@code e1} and {@code e2} in the range).
*
* This sort is guaranteed to be stable : equal elements will
* not be reordered as a result of the sort.
*
*
Implementation note: This implementation is a stable, adaptive,
* iterative mergesort that requires far fewer than n lg(n) comparisons
* when the input array is partially sorted, while offering the
* performance of a traditional mergesort when the input array is
* randomly ordered. If the input array is nearly sorted, the
* implementation requires approximately n comparisons. Temporary
* storage requirements vary from a small constant for nearly sorted
* input arrays to n/2 object references for randomly ordered input
* arrays.
*
*
The implementation takes equal advantage of ascending and
* descending order in its input array, and can take advantage of
* ascending and descending order in different parts of the same
* input array. It is well-suited to merging two or more sorted arrays:
* simply concatenate the arrays and sort the resulting array.
*
*
The implementation was adapted from Tim Peters's list sort for Python
* (
* TimSort ). It uses techniques from Peter McIlroy's "Optimistic
* Sorting and Information Theoretic Complexity", in Proceedings of the
* Fourth Annual ACM-SIAM Symposium on Discrete Algorithms, pp 467-474,
* January 1993.
*
* @param the class of the objects to be sorted
* @param a the array to be sorted
* @param fromIndex the index of the first element (inclusive) to be
* sorted
* @param toIndex the index of the last element (exclusive) to be sorted
* @param c the comparator to determine the order of the array. A
* {@code null} value indicates that the elements'
* {@linkplain Comparable natural ordering} should be used.
* @throws ClassCastException if the array contains elements that are not
* mutually comparable using the specified comparator.
* @throws IllegalArgumentException if {@code fromIndex > toIndex} or
* (optional) if the comparator is found to violate the
* {@link Comparator} contract
* @throws ArrayIndexOutOfBoundsException if {@code fromIndex < 0} or
* {@code toIndex > a.length}
*/
public static void sort(T[] a, int fromIndex, int toIndex,
Comparator c) {
if (c == null) {
sort(a, fromIndex, toIndex);
} else {
rangeCheck(a.length, fromIndex, toIndex);
if (LegacyMergeSort.userRequested)
legacyMergeSort(a, fromIndex, toIndex, c);
else
TimSort.sort(a, fromIndex, toIndex, c, null, 0, 0);
}
}
/** To be removed in a future release. */
private static void legacyMergeSort(T[] a, int fromIndex, int toIndex,
Comparator c) {
T[] aux = copyOfRange(a, fromIndex, toIndex);
if (c==null)
mergeSort(aux, a, fromIndex, toIndex, -fromIndex);
else
mergeSort(aux, a, fromIndex, toIndex, -fromIndex, c);
}
/**
* Src is the source array that starts at index 0
* Dest is the (possibly larger) array destination with a possible offset
* low is the index in dest to start sorting
* high is the end index in dest to end sorting
* off is the offset into src corresponding to low in dest
* To be removed in a future release.
*/
@SuppressWarnings({"rawtypes", "unchecked"})
private static void mergeSort(Object[] src,
Object[] dest,
int low, int high, int off,
Comparator c) {
int length = high - low;
// Insertion sort on smallest arrays
if (length < INSERTIONSORT_THRESHOLD) {
for (int i=low; ilow && c.compare(dest[j-1], dest[j])>0; j--)
swap(dest, j, j-1);
return;
}
// Recursively sort halves of dest into src
int destLow = low;
int destHigh = high;
low += off;
high += off;
int mid = (low + high) >>> 1;
mergeSort(dest, src, low, mid, -off, c);
mergeSort(dest, src, mid, high, -off, c);
// If list is already sorted, just copy from src to dest. This is an
// optimization that results in faster sorts for nearly ordered lists.
if (c.compare(src[mid-1], src[mid]) <= 0) {
System.arraycopy(src, low, dest, destLow, length);
return;
}
// Merge sorted halves (now in src) into dest
for(int i = destLow, p = low, q = mid; i < destHigh; i++) {
if (q >= high || p < mid && c.compare(src[p], src[q]) <= 0)
dest[i] = src[p++];
else
dest[i] = src[q++];
}
}
// Parallel prefix
/**
* Cumulates, in parallel, each element of the given array in place,
* using the supplied function. For example if the array initially
* holds {@code [2, 1, 0, 3]} and the operation performs addition,
* then upon return the array holds {@code [2, 3, 3, 6]}.
* Parallel prefix computation is usually more efficient than
* sequential loops for large arrays.
*
* @param the class of the objects in the array
* @param array the array, which is modified in-place by this method
* @param op a side-effect-free, associative function to perform the
* cumulation
* @throws NullPointerException if the specified array or function is null
* @since 1.8
*/
public static void parallelPrefix(T[] array, BinaryOperator op) {
Objects.requireNonNull(op);
if (array.length > 0)
new ArrayPrefixHelpers.CumulateTask<>
(null, op, array, 0, array.length).invoke();
}
/**
* Performs {@link #parallelPrefix(Object[], BinaryOperator)}
* for the given subrange of the array.
*
* @param the class of the objects in the array
* @param array the array
* @param fromIndex the index of the first element, inclusive
* @param toIndex the index of the last element, exclusive
* @param op a side-effect-free, associative function to perform the
* cumulation
* @throws IllegalArgumentException if {@code fromIndex > toIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code fromIndex < 0} or {@code toIndex > array.length}
* @throws NullPointerException if the specified array or function is null
* @since 1.8
*/
public static void parallelPrefix(T[] array, int fromIndex,
int toIndex, BinaryOperator op) {
Objects.requireNonNull(op);
rangeCheck(array.length, fromIndex, toIndex);
if (fromIndex < toIndex)
new ArrayPrefixHelpers.CumulateTask<>
(null, op, array, fromIndex, toIndex).invoke();
}
/**
* Cumulates, in parallel, each element of the given array in place,
* using the supplied function. For example if the array initially
* holds {@code [2, 1, 0, 3]} and the operation performs addition,
* then upon return the array holds {@code [2, 3, 3, 6]}.
* Parallel prefix computation is usually more efficient than
* sequential loops for large arrays.
*
* @param array the array, which is modified in-place by this method
* @param op a side-effect-free, associative function to perform the
* cumulation
* @throws NullPointerException if the specified array or function is null
* @since 1.8
*/
public static void parallelPrefix(long[] array, LongBinaryOperator op) {
Objects.requireNonNull(op);
if (array.length > 0)
new ArrayPrefixHelpers.LongCumulateTask
(null, op, array, 0, array.length).invoke();
}
/**
* Performs {@link #parallelPrefix(long[], LongBinaryOperator)}
* for the given subrange of the array.
*
* @param array the array
* @param fromIndex the index of the first element, inclusive
* @param toIndex the index of the last element, exclusive
* @param op a side-effect-free, associative function to perform the
* cumulation
* @throws IllegalArgumentException if {@code fromIndex > toIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code fromIndex < 0} or {@code toIndex > array.length}
* @throws NullPointerException if the specified array or function is null
* @since 1.8
*/
public static void parallelPrefix(long[] array, int fromIndex,
int toIndex, LongBinaryOperator op) {
Objects.requireNonNull(op);
rangeCheck(array.length, fromIndex, toIndex);
if (fromIndex < toIndex)
new ArrayPrefixHelpers.LongCumulateTask
(null, op, array, fromIndex, toIndex).invoke();
}
/**
* Cumulates, in parallel, each element of the given array in place,
* using the supplied function. For example if the array initially
* holds {@code [2.0, 1.0, 0.0, 3.0]} and the operation performs addition,
* then upon return the array holds {@code [2.0, 3.0, 3.0, 6.0]}.
* Parallel prefix computation is usually more efficient than
* sequential loops for large arrays.
*
* Because floating-point operations may not be strictly associative,
* the returned result may not be identical to the value that would be
* obtained if the operation was performed sequentially.
*
* @param array the array, which is modified in-place by this method
* @param op a side-effect-free function to perform the cumulation
* @throws NullPointerException if the specified array or function is null
* @since 1.8
*/
public static void parallelPrefix(double[] array, DoubleBinaryOperator op) {
Objects.requireNonNull(op);
if (array.length > 0)
new ArrayPrefixHelpers.DoubleCumulateTask
(null, op, array, 0, array.length).invoke();
}
/**
* Performs {@link #parallelPrefix(double[], DoubleBinaryOperator)}
* for the given subrange of the array.
*
* @param array the array
* @param fromIndex the index of the first element, inclusive
* @param toIndex the index of the last element, exclusive
* @param op a side-effect-free, associative function to perform the
* cumulation
* @throws IllegalArgumentException if {@code fromIndex > toIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code fromIndex < 0} or {@code toIndex > array.length}
* @throws NullPointerException if the specified array or function is null
* @since 1.8
*/
public static void parallelPrefix(double[] array, int fromIndex,
int toIndex, DoubleBinaryOperator op) {
Objects.requireNonNull(op);
rangeCheck(array.length, fromIndex, toIndex);
if (fromIndex < toIndex)
new ArrayPrefixHelpers.DoubleCumulateTask
(null, op, array, fromIndex, toIndex).invoke();
}
/**
* Cumulates, in parallel, each element of the given array in place,
* using the supplied function. For example if the array initially
* holds {@code [2, 1, 0, 3]} and the operation performs addition,
* then upon return the array holds {@code [2, 3, 3, 6]}.
* Parallel prefix computation is usually more efficient than
* sequential loops for large arrays.
*
* @param array the array, which is modified in-place by this method
* @param op a side-effect-free, associative function to perform the
* cumulation
* @throws NullPointerException if the specified array or function is null
* @since 1.8
*/
public static void parallelPrefix(int[] array, IntBinaryOperator op) {
Objects.requireNonNull(op);
if (array.length > 0)
new ArrayPrefixHelpers.IntCumulateTask
(null, op, array, 0, array.length).invoke();
}
/**
* Performs {@link #parallelPrefix(int[], IntBinaryOperator)}
* for the given subrange of the array.
*
* @param array the array
* @param fromIndex the index of the first element, inclusive
* @param toIndex the index of the last element, exclusive
* @param op a side-effect-free, associative function to perform the
* cumulation
* @throws IllegalArgumentException if {@code fromIndex > toIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code fromIndex < 0} or {@code toIndex > array.length}
* @throws NullPointerException if the specified array or function is null
* @since 1.8
*/
public static void parallelPrefix(int[] array, int fromIndex,
int toIndex, IntBinaryOperator op) {
Objects.requireNonNull(op);
rangeCheck(array.length, fromIndex, toIndex);
if (fromIndex < toIndex)
new ArrayPrefixHelpers.IntCumulateTask
(null, op, array, fromIndex, toIndex).invoke();
}
// Searching
/**
* Searches the specified array of longs for the specified value using the
* binary search algorithm. The array must be sorted (as
* by the {@link #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.
*
* @param a the array to be searched
* @param key the value to be searched for
* @return index of the search key, if it is contained in the array;
* otherwise, (-(insertion point ) - 1). The
* insertion point is defined as the point at which the
* key would be inserted into the array: the index of the first
* element greater than the key, or {@code a.length} if all
* elements in the array are less than the specified key. Note
* that this guarantees that the return value will be >= 0 if
* and only if the key is found.
*/
public static int binarySearch(long[] a, long key) {
return binarySearch0(a, 0, a.length, key);
}
/**
* 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 {@link #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.
*
* @param a the array to be searched
* @param fromIndex the index of the first element (inclusive) to be
* searched
* @param toIndex the index of the last element (exclusive) to be searched
* @param key the value to be searched for
* @return index of the search key, if it is contained in the array
* within the specified range;
* otherwise, (-(insertion point ) - 1). The
* insertion point is defined as the point at which the
* key would be inserted into the array: the index of the first
* element in the range greater than the key,
* or {@code toIndex} if all
* elements in the range are less than the specified key. Note
* that this guarantees that the return value will be >= 0 if
* and only if the key is found.
* @throws IllegalArgumentException
* if {@code fromIndex > toIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code fromIndex < 0 or toIndex > a.length}
* @since 1.6
*/
public static int binarySearch(long[] a, int fromIndex, int toIndex,
long key) {
rangeCheck(a.length, fromIndex, toIndex);
return binarySearch0(a, fromIndex, toIndex, key);
}
// Like public version, but without range checks.
private static int binarySearch0(long[] a, int fromIndex, int toIndex,
long key) {
int low = fromIndex;
int high = toIndex - 1;
while (low <= high) {
int mid = (low + high) >>> 1;
long midVal = a[mid];
if (midVal < key)
low = mid + 1;
else if (midVal > key)
high = mid - 1;
else
return mid; // key found
}
return -(low + 1); // key not found.
}
/**
* Searches the specified array of ints for the specified value using the
* binary search algorithm. The array must be sorted (as
* by the {@link #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.
*
* @param a the array to be searched
* @param key the value to be searched for
* @return index of the search key, if it is contained in the array;
* otherwise, (-(insertion point ) - 1). The
* insertion point is defined as the point at which the
* key would be inserted into the array: the index of the first
* element greater than the key, or {@code a.length} if all
* elements in the array are less than the specified key. Note
* that this guarantees that the return value will be >= 0 if
* and only if the key is found.
*/
public static int binarySearch(int[] a, int key) {
return binarySearch0(a, 0, a.length, key);
}
/**
* 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 {@link #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.
*
* @param a the array to be searched
* @param fromIndex the index of the first element (inclusive) to be
* searched
* @param toIndex the index of the last element (exclusive) to be searched
* @param key the value to be searched for
* @return index of the search key, if it is contained in the array
* within the specified range;
* otherwise, (-(insertion point ) - 1). The
* insertion point is defined as the point at which the
* key would be inserted into the array: the index of the first
* element in the range greater than the key,
* or {@code toIndex} if all
* elements in the range are less than the specified key. Note
* that this guarantees that the return value will be >= 0 if
* and only if the key is found.
* @throws IllegalArgumentException
* if {@code fromIndex > toIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code fromIndex < 0 or toIndex > a.length}
* @since 1.6
*/
public static int binarySearch(int[] a, int fromIndex, int toIndex,
int key) {
rangeCheck(a.length, fromIndex, toIndex);
return binarySearch0(a, fromIndex, toIndex, key);
}
// Like public version, but without range checks.
private static int binarySearch0(int[] a, int fromIndex, int toIndex,
int key) {
int low = fromIndex;
int high = toIndex - 1;
while (low <= high) {
int mid = (low + high) >>> 1;
int midVal = a[mid];
if (midVal < key)
low = mid + 1;
else if (midVal > key)
high = mid - 1;
else
return mid; // key found
}
return -(low + 1); // key not found.
}
/**
* Searches the specified array of shorts for the specified value using
* the binary search algorithm. The array must be sorted
* (as by the {@link #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.
*
* @param a the array to be searched
* @param key the value to be searched for
* @return index of the search key, if it is contained in the array;
* otherwise, (-(insertion point ) - 1). The
* insertion point is defined as the point at which the
* key would be inserted into the array: the index of the first
* element greater than the key, or {@code a.length} if all
* elements in the array are less than the specified key. Note
* that this guarantees that the return value will be >= 0 if
* and only if the key is found.
*/
public static int binarySearch(short[] a, short key) {
return binarySearch0(a, 0, a.length, key);
}
/**
* 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 {@link #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.
*
* @param a the array to be searched
* @param fromIndex the index of the first element (inclusive) to be
* searched
* @param toIndex the index of the last element (exclusive) to be searched
* @param key the value to be searched for
* @return index of the search key, if it is contained in the array
* within the specified range;
* otherwise, (-(insertion point ) - 1). The
* insertion point is defined as the point at which the
* key would be inserted into the array: the index of the first
* element in the range greater than the key,
* or {@code toIndex} if all
* elements in the range are less than the specified key. Note
* that this guarantees that the return value will be >= 0 if
* and only if the key is found.
* @throws IllegalArgumentException
* if {@code fromIndex > toIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code fromIndex < 0 or toIndex > a.length}
* @since 1.6
*/
public static int binarySearch(short[] a, int fromIndex, int toIndex,
short key) {
rangeCheck(a.length, fromIndex, toIndex);
return binarySearch0(a, fromIndex, toIndex, key);
}
// Like public version, but without range checks.
private static int binarySearch0(short[] a, int fromIndex, int toIndex,
short key) {
int low = fromIndex;
int high = toIndex - 1;
while (low <= high) {
int mid = (low + high) >>> 1;
short midVal = a[mid];
if (midVal < key)
low = mid + 1;
else if (midVal > key)
high = mid - 1;
else
return mid; // key found
}
return -(low + 1); // key not found.
}
/**
* Searches the specified array of chars for the specified value using the
* binary search algorithm. The array must be sorted (as
* by the {@link #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.
*
* @param a the array to be searched
* @param key the value to be searched for
* @return index of the search key, if it is contained in the array;
* otherwise, (-(insertion point ) - 1). The
* insertion point is defined as the point at which the
* key would be inserted into the array: the index of the first
* element greater than the key, or {@code a.length} if all
* elements in the array are less than the specified key. Note
* that this guarantees that the return value will be >= 0 if
* and only if the key is found.
*/
public static int binarySearch(char[] a, char key) {
return binarySearch0(a, 0, a.length, key);
}
/**
* 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 {@link #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.
*
* @param a the array to be searched
* @param fromIndex the index of the first element (inclusive) to be
* searched
* @param toIndex the index of the last element (exclusive) to be searched
* @param key the value to be searched for
* @return index of the search key, if it is contained in the array
* within the specified range;
* otherwise, (-(insertion point ) - 1). The
* insertion point is defined as the point at which the
* key would be inserted into the array: the index of the first
* element in the range greater than the key,
* or {@code toIndex} if all
* elements in the range are less than the specified key. Note
* that this guarantees that the return value will be >= 0 if
* and only if the key is found.
* @throws IllegalArgumentException
* if {@code fromIndex > toIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code fromIndex < 0 or toIndex > a.length}
* @since 1.6
*/
public static int binarySearch(char[] a, int fromIndex, int toIndex,
char key) {
rangeCheck(a.length, fromIndex, toIndex);
return binarySearch0(a, fromIndex, toIndex, key);
}
// Like public version, but without range checks.
private static int binarySearch0(char[] a, int fromIndex, int toIndex,
char key) {
int low = fromIndex;
int high = toIndex - 1;
while (low <= high) {
int mid = (low + high) >>> 1;
char midVal = a[mid];
if (midVal < key)
low = mid + 1;
else if (midVal > key)
high = mid - 1;
else
return mid; // key found
}
return -(low + 1); // key not found.
}
/**
* Searches the specified array of bytes for the specified value using the
* binary search algorithm. The array must be sorted (as
* by the {@link #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.
*
* @param a the array to be searched
* @param key the value to be searched for
* @return index of the search key, if it is contained in the array;
* otherwise, (-(insertion point ) - 1). The
* insertion point is defined as the point at which the
* key would be inserted into the array: the index of the first
* element greater than the key, or {@code a.length} if all
* elements in the array are less than the specified key. Note
* that this guarantees that the return value will be >= 0 if
* and only if the key is found.
*/
public static int binarySearch(byte[] a, byte key) {
return binarySearch0(a, 0, a.length, key);
}
/**
* 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 {@link #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.
*
* @param a the array to be searched
* @param fromIndex the index of the first element (inclusive) to be
* searched
* @param toIndex the index of the last element (exclusive) to be searched
* @param key the value to be searched for
* @return index of the search key, if it is contained in the array
* within the specified range;
* otherwise, (-(insertion point ) - 1). The
* insertion point is defined as the point at which the
* key would be inserted into the array: the index of the first
* element in the range greater than the key,
* or {@code toIndex} if all
* elements in the range are less than the specified key. Note
* that this guarantees that the return value will be >= 0 if
* and only if the key is found.
* @throws IllegalArgumentException
* if {@code fromIndex > toIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code fromIndex < 0 or toIndex > a.length}
* @since 1.6
*/
public static int binarySearch(byte[] a, int fromIndex, int toIndex,
byte key) {
rangeCheck(a.length, fromIndex, toIndex);
return binarySearch0(a, fromIndex, toIndex, key);
}
// Like public version, but without range checks.
private static int binarySearch0(byte[] a, int fromIndex, int toIndex,
byte key) {
int low = fromIndex;
int high = toIndex - 1;
while (low <= high) {
int mid = (low + high) >>> 1;
byte midVal = a[mid];
if (midVal < key)
low = mid + 1;
else if (midVal > key)
high = mid - 1;
else
return mid; // key found
}
return -(low + 1); // key not found.
}
/**
* Searches the specified array of doubles for the specified value using
* the binary search algorithm. The array must be sorted
* (as by the {@link #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.
*
* @param a the array to be searched
* @param key the value to be searched for
* @return index of the search key, if it is contained in the array;
* otherwise, (-(insertion point ) - 1). The
* insertion point is defined as the point at which the
* key would be inserted into the array: the index of the first
* element greater than the key, or {@code a.length} if all
* elements in the array are less than the specified key. Note
* that this guarantees that the return value will be >= 0 if
* and only if the key is found.
*/
public static int binarySearch(double[] a, double key) {
return binarySearch0(a, 0, a.length, key);
}
/**
* 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 {@link #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.
*
* @param a the array to be searched
* @param fromIndex the index of the first element (inclusive) to be
* searched
* @param toIndex the index of the last element (exclusive) to be searched
* @param key the value to be searched for
* @return index of the search key, if it is contained in the array
* within the specified range;
* otherwise, (-(insertion point ) - 1). The
* insertion point is defined as the point at which the
* key would be inserted into the array: the index of the first
* element in the range greater than the key,
* or {@code toIndex} if all
* elements in the range are less than the specified key. Note
* that this guarantees that the return value will be >= 0 if
* and only if the key is found.
* @throws IllegalArgumentException
* if {@code fromIndex > toIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code fromIndex < 0 or toIndex > a.length}
* @since 1.6
*/
public static int binarySearch(double[] a, int fromIndex, int toIndex,
double key) {
rangeCheck(a.length, fromIndex, toIndex);
return binarySearch0(a, fromIndex, toIndex, key);
}
// Like public version, but without range checks.
private static int binarySearch0(double[] a, int fromIndex, int toIndex,
double key) {
int low = fromIndex;
int high = toIndex - 1;
while (low <= high) {
int mid = (low + high) >>> 1;
double midVal = a[mid];
if (midVal < key)
low = mid + 1; // Neither val is NaN, thisVal is smaller
else if (midVal > key)
high = mid - 1; // Neither val is NaN, thisVal is larger
else {
long midBits = Double.doubleToLongBits(midVal);
long keyBits = Double.doubleToLongBits(key);
if (midBits == keyBits) // Values are equal
return mid; // Key found
else if (midBits < keyBits) // (-0.0, 0.0) or (!NaN, NaN)
low = mid + 1;
else // (0.0, -0.0) or (NaN, !NaN)
high = mid - 1;
}
}
return -(low + 1); // key not found.
}
/**
* Searches the specified array of floats for the specified value using
* the binary search algorithm. The array must be sorted
* (as by the {@link #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.
*
* @param a the array to be searched
* @param key the value to be searched for
* @return index of the search key, if it is contained in the array;
* otherwise, (-(insertion point ) - 1). The
* insertion point is defined as the point at which the
* key would be inserted into the array: the index of the first
* element greater than the key, or {@code a.length} if all
* elements in the array are less than the specified key. Note
* that this guarantees that the return value will be >= 0 if
* and only if the key is found.
*/
public static int binarySearch(float[] a, float key) {
return binarySearch0(a, 0, a.length, key);
}
/**
* 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 {@link #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.
*
* @param a the array to be searched
* @param fromIndex the index of the first element (inclusive) to be
* searched
* @param toIndex the index of the last element (exclusive) to be searched
* @param key the value to be searched for
* @return index of the search key, if it is contained in the array
* within the specified range;
* otherwise, (-(insertion point ) - 1). The
* insertion point is defined as the point at which the
* key would be inserted into the array: the index of the first
* element in the range greater than the key,
* or {@code toIndex} if all
* elements in the range are less than the specified key. Note
* that this guarantees that the return value will be >= 0 if
* and only if the key is found.
* @throws IllegalArgumentException
* if {@code fromIndex > toIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code fromIndex < 0 or toIndex > a.length}
* @since 1.6
*/
public static int binarySearch(float[] a, int fromIndex, int toIndex,
float key) {
rangeCheck(a.length, fromIndex, toIndex);
return binarySearch0(a, fromIndex, toIndex, key);
}
// Like public version, but without range checks.
private static int binarySearch0(float[] a, int fromIndex, int toIndex,
float key) {
int low = fromIndex;
int high = toIndex - 1;
while (low <= high) {
int mid = (low + high) >>> 1;
float midVal = a[mid];
if (midVal < key)
low = mid + 1; // Neither val is NaN, thisVal is smaller
else if (midVal > key)
high = mid - 1; // Neither val is NaN, thisVal is larger
else {
int midBits = Float.floatToIntBits(midVal);
int keyBits = Float.floatToIntBits(key);
if (midBits == keyBits) // Values are equal
return mid; // Key found
else if (midBits < keyBits) // (-0.0, 0.0) or (!NaN, NaN)
low = mid + 1;
else // (0.0, -0.0) or (NaN, !NaN)
high = mid - 1;
}
}
return -(low + 1); // key not found.
}
/**
* Searches the specified array for the specified object using the binary
* search algorithm. The array must be sorted into ascending order
* according to the
* {@linkplain Comparable natural ordering}
* of its elements (as by the
* {@link #sort(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.
*
* @param a the array to be searched
* @param key the value to be searched for
* @return index of the search key, if it is contained in the array;
* otherwise, (-(insertion point ) - 1). The
* insertion point is defined as the point at which the
* key would be inserted into the array: the index of the first
* element greater than the key, or {@code a.length} if all
* elements in the array are less than the specified key. Note
* that this guarantees that the return value will be >= 0 if
* and only if the key is found.
* @throws ClassCastException if the search key is not comparable to the
* elements of the array.
*/
public static int binarySearch(Object[] a, Object key) {
return binarySearch0(a, 0, a.length, key);
}
/**
* 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
* {@linkplain Comparable natural ordering}
* of its elements (as by the
* {@link #sort(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.
*
* @param a the array to be searched
* @param fromIndex the index of the first element (inclusive) to be
* searched
* @param toIndex the index of the last element (exclusive) to be searched
* @param key the value to be searched for
* @return index of the search key, if it is contained in the array
* within the specified range;
* otherwise, (-(insertion point ) - 1). The
* insertion point is defined as the point at which the
* key would be inserted into the array: the index of the first
* element in the range greater than the key,
* or {@code toIndex} if all
* elements in the range are less than the specified key. Note
* that this guarantees that the return value will be >= 0 if
* and only if the key is found.
* @throws ClassCastException if the search key is not comparable to the
* elements of the array within the specified range.
* @throws IllegalArgumentException
* if {@code fromIndex > toIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code fromIndex < 0 or toIndex > a.length}
* @since 1.6
*/
public static int binarySearch(Object[] a, int fromIndex, int toIndex,
Object key) {
rangeCheck(a.length, fromIndex, toIndex);
return binarySearch0(a, fromIndex, toIndex, key);
}
// Like public version, but without range checks.
private static int binarySearch0(Object[] a, int fromIndex, int toIndex,
Object key) {
int low = fromIndex;
int high = toIndex - 1;
while (low <= high) {
int mid = (low + high) >>> 1;
@SuppressWarnings("rawtypes")
Comparable midVal = (Comparable)a[mid];
@SuppressWarnings("unchecked")
int cmp = midVal.compareTo(key);
if (cmp < 0)
low = mid + 1;
else if (cmp > 0)
high = mid - 1;
else
return mid; // key found
}
return -(low + 1); // key not found.
}
/**
* 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
* {@link #sort(Object[], Comparator) 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.
*
* @param the class of the objects in the array
* @param a the array to be searched
* @param key the value to be searched for
* @param c the comparator by which the array is ordered. A
* {@code null} value indicates that the elements'
* {@linkplain Comparable natural ordering} should be used.
* @return index of the search key, if it is contained in the array;
* otherwise, (-(insertion point ) - 1). The
* insertion point is defined as the point at which the
* key would be inserted into the array: the index of the first
* element greater than the key, or {@code a.length} if all
* elements in the array are less than the specified key. Note
* that this guarantees that the return value will be >= 0 if
* and only if the key is found.
* @throws ClassCastException if the array contains elements that are not
* mutually comparable using the specified comparator,
* or the search key is not comparable to the
* elements of the array using this comparator.
*/
public static int binarySearch(T[] a, T key, Comparator c) {
return binarySearch0(a, 0, a.length, key, c);
}
/**
* 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
* {@link #sort(Object[], int, int, Comparator)
* 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.
*
* @param the class of the objects in the array
* @param a the array to be searched
* @param fromIndex the index of the first element (inclusive) to be
* searched
* @param toIndex the index of the last element (exclusive) to be searched
* @param key the value to be searched for
* @param c the comparator by which the array is ordered. A
* {@code null} value indicates that the elements'
* {@linkplain Comparable natural ordering} should be used.
* @return index of the search key, if it is contained in the array
* within the specified range;
* otherwise, (-(insertion point ) - 1). The
* insertion point is defined as the point at which the
* key would be inserted into the array: the index of the first
* element in the range greater than the key,
* or {@code toIndex} if all
* elements in the range are less than the specified key. Note
* that this guarantees that the return value will be >= 0 if
* and only if the key is found.
* @throws ClassCastException if the range contains elements that are not
* mutually comparable using the specified comparator,
* or the search key is not comparable to the
* elements in the range using this comparator.
* @throws IllegalArgumentException
* if {@code fromIndex > toIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code fromIndex < 0 or toIndex > a.length}
* @since 1.6
*/
public static int binarySearch(T[] a, int fromIndex, int toIndex,
T key, Comparator c) {
rangeCheck(a.length, fromIndex, toIndex);
return binarySearch0(a, fromIndex, toIndex, key, c);
}
// Like public version, but without range checks.
private static int binarySearch0(T[] a, int fromIndex, int toIndex,
T key, Comparator c) {
if (c == null) {
return binarySearch0(a, fromIndex, toIndex, key);
}
int low = fromIndex;
int high = toIndex - 1;
while (low <= high) {
int mid = (low + high) >>> 1;
T midVal = a[mid];
int cmp = c.compare(midVal, key);
if (cmp < 0)
low = mid + 1;
else if (cmp > 0)
high = mid - 1;
else
return mid; // key found
}
return -(low + 1); // key not found.
}
// Equality Testing
/**
* Returns {@code 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 {@code null}.
*
* @param a one array to be tested for equality
* @param a2 the other array to be tested for equality
* @return {@code true} if the two arrays are equal
*/
public static boolean equals(long[] a, long[] a2) {
if (a==a2)
return true;
if (a==null || a2==null)
return false;
int length = a.length;
if (a2.length != length)
return false;
return ArraysSupport.mismatch(a, a2, length) < 0;
}
/**
* Returns true if the two specified arrays of longs, over the specified
* ranges, are equal to one another.
*
* Two arrays are considered equal if the number of elements covered by
* each range is the same, and all corresponding pairs of elements over the
* specified ranges in the two arrays are equal. In other words, two arrays
* are equal if they contain, over the specified ranges, the same elements
* in the same order.
*
* @param a the first array to be tested for equality
* @param aFromIndex the index (inclusive) of the first element in the
* first array to be tested
* @param aToIndex the index (exclusive) of the last element in the
* first array to be tested
* @param b the second array to be tested fro equality
* @param bFromIndex the index (inclusive) of the first element in the
* second array to be tested
* @param bToIndex the index (exclusive) of the last element in the
* second array to be tested
* @return {@code true} if the two arrays, over the specified ranges, are
* equal
* @throws IllegalArgumentException
* if {@code aFromIndex > aToIndex} or
* if {@code bFromIndex > bToIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code aFromIndex < 0 or aToIndex > a.length} or
* if {@code bFromIndex < 0 or bToIndex > b.length}
* @throws NullPointerException
* if either array is {@code null}
* @since 9
*/
public static boolean equals(long[] a, int aFromIndex, int aToIndex,
long[] b, int bFromIndex, int bToIndex) {
rangeCheck(a.length, aFromIndex, aToIndex);
rangeCheck(b.length, bFromIndex, bToIndex);
int aLength = aToIndex - aFromIndex;
int bLength = bToIndex - bFromIndex;
if (aLength != bLength)
return false;
return ArraysSupport.mismatch(a, aFromIndex,
b, bFromIndex,
aLength) < 0;
}
/**
* Returns {@code 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 {@code null}.
*
* @param a one array to be tested for equality
* @param a2 the other array to be tested for equality
* @return {@code true} if the two arrays are equal
*/
public static boolean equals(int[] a, int[] a2) {
if (a==a2)
return true;
if (a==null || a2==null)
return false;
int length = a.length;
if (a2.length != length)
return false;
return ArraysSupport.mismatch(a, a2, length) < 0;
}
/**
* Returns true if the two specified arrays of ints, over the specified
* ranges, are equal to one another.
*
*
Two arrays are considered equal if the number of elements covered by
* each range is the same, and all corresponding pairs of elements over the
* specified ranges in the two arrays are equal. In other words, two arrays
* are equal if they contain, over the specified ranges, the same elements
* in the same order.
*
* @param a the first array to be tested for equality
* @param aFromIndex the index (inclusive) of the first element in the
* first array to be tested
* @param aToIndex the index (exclusive) of the last element in the
* first array to be tested
* @param b the second array to be tested fro equality
* @param bFromIndex the index (inclusive) of the first element in the
* second array to be tested
* @param bToIndex the index (exclusive) of the last element in the
* second array to be tested
* @return {@code true} if the two arrays, over the specified ranges, are
* equal
* @throws IllegalArgumentException
* if {@code aFromIndex > aToIndex} or
* if {@code bFromIndex > bToIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code aFromIndex < 0 or aToIndex > a.length} or
* if {@code bFromIndex < 0 or bToIndex > b.length}
* @throws NullPointerException
* if either array is {@code null}
* @since 9
*/
public static boolean equals(int[] a, int aFromIndex, int aToIndex,
int[] b, int bFromIndex, int bToIndex) {
rangeCheck(a.length, aFromIndex, aToIndex);
rangeCheck(b.length, bFromIndex, bToIndex);
int aLength = aToIndex - aFromIndex;
int bLength = bToIndex - bFromIndex;
if (aLength != bLength)
return false;
return ArraysSupport.mismatch(a, aFromIndex,
b, bFromIndex,
aLength) < 0;
}
/**
* Returns {@code 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 {@code null}.
*
* @param a one array to be tested for equality
* @param a2 the other array to be tested for equality
* @return {@code true} if the two arrays are equal
*/
public static boolean equals(short[] a, short a2[]) {
if (a==a2)
return true;
if (a==null || a2==null)
return false;
int length = a.length;
if (a2.length != length)
return false;
return ArraysSupport.mismatch(a, a2, length) < 0;
}
/**
* Returns true if the two specified arrays of shorts, over the specified
* ranges, are equal to one another.
*
*
Two arrays are considered equal if the number of elements covered by
* each range is the same, and all corresponding pairs of elements over the
* specified ranges in the two arrays are equal. In other words, two arrays
* are equal if they contain, over the specified ranges, the same elements
* in the same order.
*
* @param a the first array to be tested for equality
* @param aFromIndex the index (inclusive) of the first element in the
* first array to be tested
* @param aToIndex the index (exclusive) of the last element in the
* first array to be tested
* @param b the second array to be tested fro equality
* @param bFromIndex the index (inclusive) of the first element in the
* second array to be tested
* @param bToIndex the index (exclusive) of the last element in the
* second array to be tested
* @return {@code true} if the two arrays, over the specified ranges, are
* equal
* @throws IllegalArgumentException
* if {@code aFromIndex > aToIndex} or
* if {@code bFromIndex > bToIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code aFromIndex < 0 or aToIndex > a.length} or
* if {@code bFromIndex < 0 or bToIndex > b.length}
* @throws NullPointerException
* if either array is {@code null}
* @since 9
*/
public static boolean equals(short[] a, int aFromIndex, int aToIndex,
short[] b, int bFromIndex, int bToIndex) {
rangeCheck(a.length, aFromIndex, aToIndex);
rangeCheck(b.length, bFromIndex, bToIndex);
int aLength = aToIndex - aFromIndex;
int bLength = bToIndex - bFromIndex;
if (aLength != bLength)
return false;
return ArraysSupport.mismatch(a, aFromIndex,
b, bFromIndex,
aLength) < 0;
}
/**
* Returns {@code 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 {@code null}.
*
* @param a one array to be tested for equality
* @param a2 the other array to be tested for equality
* @return {@code true} if the two arrays are equal
*/
@HotSpotIntrinsicCandidate
public static boolean equals(char[] a, char[] a2) {
if (a==a2)
return true;
if (a==null || a2==null)
return false;
int length = a.length;
if (a2.length != length)
return false;
return ArraysSupport.mismatch(a, a2, length) < 0;
}
/**
* Returns true if the two specified arrays of chars, over the specified
* ranges, are equal to one another.
*
*
Two arrays are considered equal if the number of elements covered by
* each range is the same, and all corresponding pairs of elements over the
* specified ranges in the two arrays are equal. In other words, two arrays
* are equal if they contain, over the specified ranges, the same elements
* in the same order.
*
* @param a the first array to be tested for equality
* @param aFromIndex the index (inclusive) of the first element in the
* first array to be tested
* @param aToIndex the index (exclusive) of the last element in the
* first array to be tested
* @param b the second array to be tested fro equality
* @param bFromIndex the index (inclusive) of the first element in the
* second array to be tested
* @param bToIndex the index (exclusive) of the last element in the
* second array to be tested
* @return {@code true} if the two arrays, over the specified ranges, are
* equal
* @throws IllegalArgumentException
* if {@code aFromIndex > aToIndex} or
* if {@code bFromIndex > bToIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code aFromIndex < 0 or aToIndex > a.length} or
* if {@code bFromIndex < 0 or bToIndex > b.length}
* @throws NullPointerException
* if either array is {@code null}
* @since 9
*/
public static boolean equals(char[] a, int aFromIndex, int aToIndex,
char[] b, int bFromIndex, int bToIndex) {
rangeCheck(a.length, aFromIndex, aToIndex);
rangeCheck(b.length, bFromIndex, bToIndex);
int aLength = aToIndex - aFromIndex;
int bLength = bToIndex - bFromIndex;
if (aLength != bLength)
return false;
return ArraysSupport.mismatch(a, aFromIndex,
b, bFromIndex,
aLength) < 0;
}
/**
* Returns {@code 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 {@code null}.
*
* @param a one array to be tested for equality
* @param a2 the other array to be tested for equality
* @return {@code true} if the two arrays are equal
*/
@HotSpotIntrinsicCandidate
public static boolean equals(byte[] a, byte[] a2) {
if (a==a2)
return true;
if (a==null || a2==null)
return false;
int length = a.length;
if (a2.length != length)
return false;
return ArraysSupport.mismatch(a, a2, length) < 0;
}
/**
* Returns true if the two specified arrays of bytes, over the specified
* ranges, are equal to one another.
*
*
Two arrays are considered equal if the number of elements covered by
* each range is the same, and all corresponding pairs of elements over the
* specified ranges in the two arrays are equal. In other words, two arrays
* are equal if they contain, over the specified ranges, the same elements
* in the same order.
*
* @param a the first array to be tested for equality
* @param aFromIndex the index (inclusive) of the first element in the
* first array to be tested
* @param aToIndex the index (exclusive) of the last element in the
* first array to be tested
* @param b the second array to be tested fro equality
* @param bFromIndex the index (inclusive) of the first element in the
* second array to be tested
* @param bToIndex the index (exclusive) of the last element in the
* second array to be tested
* @return {@code true} if the two arrays, over the specified ranges, are
* equal
* @throws IllegalArgumentException
* if {@code aFromIndex > aToIndex} or
* if {@code bFromIndex > bToIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code aFromIndex < 0 or aToIndex > a.length} or
* if {@code bFromIndex < 0 or bToIndex > b.length}
* @throws NullPointerException
* if either array is {@code null}
* @since 9
*/
public static boolean equals(byte[] a, int aFromIndex, int aToIndex,
byte[] b, int bFromIndex, int bToIndex) {
rangeCheck(a.length, aFromIndex, aToIndex);
rangeCheck(b.length, bFromIndex, bToIndex);
int aLength = aToIndex - aFromIndex;
int bLength = bToIndex - bFromIndex;
if (aLength != bLength)
return false;
return ArraysSupport.mismatch(a, aFromIndex,
b, bFromIndex,
aLength) < 0;
}
/**
* Returns {@code 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 {@code null}.
*
* @param a one array to be tested for equality
* @param a2 the other array to be tested for equality
* @return {@code true} if the two arrays are equal
*/
public static boolean equals(boolean[] a, boolean[] a2) {
if (a==a2)
return true;
if (a==null || a2==null)
return false;
int length = a.length;
if (a2.length != length)
return false;
return ArraysSupport.mismatch(a, a2, length) < 0;
}
/**
* Returns true if the two specified arrays of booleans, over the specified
* ranges, are equal to one another.
*
*
Two arrays are considered equal if the number of elements covered by
* each range is the same, and all corresponding pairs of elements over the
* specified ranges in the two arrays are equal. In other words, two arrays
* are equal if they contain, over the specified ranges, the same elements
* in the same order.
*
* @param a the first array to be tested for equality
* @param aFromIndex the index (inclusive) of the first element in the
* first array to be tested
* @param aToIndex the index (exclusive) of the last element in the
* first array to be tested
* @param b the second array to be tested fro equality
* @param bFromIndex the index (inclusive) of the first element in the
* second array to be tested
* @param bToIndex the index (exclusive) of the last element in the
* second array to be tested
* @return {@code true} if the two arrays, over the specified ranges, are
* equal
* @throws IllegalArgumentException
* if {@code aFromIndex > aToIndex} or
* if {@code bFromIndex > bToIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code aFromIndex < 0 or aToIndex > a.length} or
* if {@code bFromIndex < 0 or bToIndex > b.length}
* @throws NullPointerException
* if either array is {@code null}
* @since 9
*/
public static boolean equals(boolean[] a, int aFromIndex, int aToIndex,
boolean[] b, int bFromIndex, int bToIndex) {
rangeCheck(a.length, aFromIndex, aToIndex);
rangeCheck(b.length, bFromIndex, bToIndex);
int aLength = aToIndex - aFromIndex;
int bLength = bToIndex - bFromIndex;
if (aLength != bLength)
return false;
return ArraysSupport.mismatch(a, aFromIndex,
b, bFromIndex,
aLength) < 0;
}
/**
* Returns {@code 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 {@code null}.
*
* Two doubles {@code d1} and {@code d2} are considered equal if:
*
{@code new Double(d1).equals(new Double(d2))}
* (Unlike the {@code ==} operator, this method considers
* {@code NaN} equals to itself, and 0.0d unequal to -0.0d.)
*
* @param a one array to be tested for equality
* @param a2 the other array to be tested for equality
* @return {@code true} if the two arrays are equal
* @see Double#equals(Object)
*/
public static boolean equals(double[] a, double[] a2) {
if (a==a2)
return true;
if (a==null || a2==null)
return false;
int length = a.length;
if (a2.length != length)
return false;
return ArraysSupport.mismatch(a, a2, length) < 0;
}
/**
* Returns true if the two specified arrays of doubles, over the specified
* ranges, are equal to one another.
*
* Two arrays are considered equal if the number of elements covered by
* each range is the same, and all corresponding pairs of elements over the
* specified ranges in the two arrays are equal. In other words, two arrays
* are equal if they contain, over the specified ranges, the same elements
* in the same order.
*
*
Two doubles {@code d1} and {@code d2} are considered equal if:
*
{@code new Double(d1).equals(new Double(d2))}
* (Unlike the {@code ==} operator, this method considers
* {@code NaN} equals to itself, and 0.0d unequal to -0.0d.)
*
* @param a the first array to be tested for equality
* @param aFromIndex the index (inclusive) of the first element in the
* first array to be tested
* @param aToIndex the index (exclusive) of the last element in the
* first array to be tested
* @param b the second array to be tested fro equality
* @param bFromIndex the index (inclusive) of the first element in the
* second array to be tested
* @param bToIndex the index (exclusive) of the last element in the
* second array to be tested
* @return {@code true} if the two arrays, over the specified ranges, are
* equal
* @throws IllegalArgumentException
* if {@code aFromIndex > aToIndex} or
* if {@code bFromIndex > bToIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code aFromIndex < 0 or aToIndex > a.length} or
* if {@code bFromIndex < 0 or bToIndex > b.length}
* @throws NullPointerException
* if either array is {@code null}
* @see Double#equals(Object)
* @since 9
*/
public static boolean equals(double[] a, int aFromIndex, int aToIndex,
double[] b, int bFromIndex, int bToIndex) {
rangeCheck(a.length, aFromIndex, aToIndex);
rangeCheck(b.length, bFromIndex, bToIndex);
int aLength = aToIndex - aFromIndex;
int bLength = bToIndex - bFromIndex;
if (aLength != bLength)
return false;
return ArraysSupport.mismatch(a, aFromIndex,
b, bFromIndex, aLength) < 0;
}
/**
* Returns {@code 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 {@code null}.
*
* Two floats {@code f1} and {@code f2} are considered equal if:
* {@code new Float(f1).equals(new Float(f2))}
* (Unlike the {@code ==} operator, this method considers
* {@code NaN} equals to itself, and 0.0f unequal to -0.0f.)
*
* @param a one array to be tested for equality
* @param a2 the other array to be tested for equality
* @return {@code true} if the two arrays are equal
* @see Float#equals(Object)
*/
public static boolean equals(float[] a, float[] a2) {
if (a==a2)
return true;
if (a==null || a2==null)
return false;
int length = a.length;
if (a2.length != length)
return false;
return ArraysSupport.mismatch(a, a2, length) < 0;
}
/**
* Returns true if the two specified arrays of floats, over the specified
* ranges, are equal to one another.
*
* Two arrays are considered equal if the number of elements covered by
* each range is the same, and all corresponding pairs of elements over the
* specified ranges in the two arrays are equal. In other words, two arrays
* are equal if they contain, over the specified ranges, the same elements
* in the same order.
*
*
Two floats {@code f1} and {@code f2} are considered equal if:
*
{@code new Float(f1).equals(new Float(f2))}
* (Unlike the {@code ==} operator, this method considers
* {@code NaN} equals to itself, and 0.0f unequal to -0.0f.)
*
* @param a the first array to be tested for equality
* @param aFromIndex the index (inclusive) of the first element in the
* first array to be tested
* @param aToIndex the index (exclusive) of the last element in the
* first array to be tested
* @param b the second array to be tested fro equality
* @param bFromIndex the index (inclusive) of the first element in the
* second array to be tested
* @param bToIndex the index (exclusive) of the last element in the
* second array to be tested
* @return {@code true} if the two arrays, over the specified ranges, are
* equal
* @throws IllegalArgumentException
* if {@code aFromIndex > aToIndex} or
* if {@code bFromIndex > bToIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code aFromIndex < 0 or aToIndex > a.length} or
* if {@code bFromIndex < 0 or bToIndex > b.length}
* @throws NullPointerException
* if either array is {@code null}
* @see Float#equals(Object)
* @since 9
*/
public static boolean equals(float[] a, int aFromIndex, int aToIndex,
float[] b, int bFromIndex, int bToIndex) {
rangeCheck(a.length, aFromIndex, aToIndex);
rangeCheck(b.length, bFromIndex, bToIndex);
int aLength = aToIndex - aFromIndex;
int bLength = bToIndex - bFromIndex;
if (aLength != bLength)
return false;
return ArraysSupport.mismatch(a, aFromIndex,
b, bFromIndex, aLength) < 0;
}
/**
* Returns {@code 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 {@code e1}
* and {@code e2} are considered equal if
* {@code Objects.equals(e1, 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 {@code null}.
*
* @param a one array to be tested for equality
* @param a2 the other array to be tested for equality
* @return {@code true} if the two arrays are equal
*/
public static boolean equals(Object[] a, Object[] a2) {
if (a==a2)
return true;
if (a==null || a2==null)
return false;
int length = a.length;
if (a2.length != length)
return false;
for (int i=0; iequal to one another.
*
* Two arrays are considered equal if the number of elements covered by
* each range is the same, and all corresponding pairs of elements over the
* specified ranges in the two arrays are equal. In other words, two arrays
* are equal if they contain, over the specified ranges, the same elements
* in the same order.
*
*
Two objects {@code e1} and {@code e2} are considered equal if
* {@code Objects.equals(e1, e2)}.
*
* @param a the first array to be tested for equality
* @param aFromIndex the index (inclusive) of the first element in the
* first array to be tested
* @param aToIndex the index (exclusive) of the last element in the
* first array to be tested
* @param b the second array to be tested fro equality
* @param bFromIndex the index (inclusive) of the first element in the
* second array to be tested
* @param bToIndex the index (exclusive) of the last element in the
* second array to be tested
* @return {@code true} if the two arrays, over the specified ranges, are
* equal
* @throws IllegalArgumentException
* if {@code aFromIndex > aToIndex} or
* if {@code bFromIndex > bToIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code aFromIndex < 0 or aToIndex > a.length} or
* if {@code bFromIndex < 0 or bToIndex > b.length}
* @throws NullPointerException
* if either array is {@code null}
* @since 9
*/
public static boolean equals(Object[] a, int aFromIndex, int aToIndex,
Object[] b, int bFromIndex, int bToIndex) {
rangeCheck(a.length, aFromIndex, aToIndex);
rangeCheck(b.length, bFromIndex, bToIndex);
int aLength = aToIndex - aFromIndex;
int bLength = bToIndex - bFromIndex;
if (aLength != bLength)
return false;
for (int i = 0; i < aLength; i++) {
if (!Objects.equals(a[aFromIndex++], b[bFromIndex++]))
return false;
}
return true;
}
/**
* Returns {@code true} if the two specified arrays of Objects 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, 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 {@code null}.
*
*
Two objects {@code e1} and {@code e2} are considered equal if,
* given the specified comparator, {@code cmp.compare(e1, e2) == 0}.
*
* @param a one array to be tested for equality
* @param a2 the other array to be tested for equality
* @param cmp the comparator to compare array elements
* @param the type of array elements
* @return {@code true} if the two arrays are equal
* @throws NullPointerException if the comparator is {@code null}
* @since 9
*/
public static boolean equals(T[] a, T[] a2, Comparator cmp) {
Objects.requireNonNull(cmp);
if (a==a2)
return true;
if (a==null || a2==null)
return false;
int length = a.length;
if (a2.length != length)
return false;
for (int i=0; iequal to one another.
*
* Two arrays are considered equal if the number of elements covered by
* each range is the same, and all corresponding pairs of elements over the
* specified ranges in the two arrays are equal. In other words, two arrays
* are equal if they contain, over the specified ranges, the same elements
* in the same order.
*
*
Two objects {@code e1} and {@code e2} are considered equal if,
* given the specified comparator, {@code cmp.compare(e1, e2) == 0}.
*
* @param a the first array to be tested for equality
* @param aFromIndex the index (inclusive) of the first element in the
* first array to be tested
* @param aToIndex the index (exclusive) of the last element in the
* first array to be tested
* @param b the second array to be tested fro equality
* @param bFromIndex the index (inclusive) of the first element in the
* second array to be tested
* @param bToIndex the index (exclusive) of the last element in the
* second array to be tested
* @param cmp the comparator to compare array elements
* @param the type of array elements
* @return {@code true} if the two arrays, over the specified ranges, are
* equal
* @throws IllegalArgumentException
* if {@code aFromIndex > aToIndex} or
* if {@code bFromIndex > bToIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code aFromIndex < 0 or aToIndex > a.length} or
* if {@code bFromIndex < 0 or bToIndex > b.length}
* @throws NullPointerException
* if either array or the comparator is {@code null}
* @since 9
*/
public static boolean equals(T[] a, int aFromIndex, int aToIndex,
T[] b, int bFromIndex, int bToIndex,
Comparator cmp) {
Objects.requireNonNull(cmp);
rangeCheck(a.length, aFromIndex, aToIndex);
rangeCheck(b.length, bFromIndex, bToIndex);
int aLength = aToIndex - aFromIndex;
int bLength = bToIndex - bFromIndex;
if (aLength != bLength)
return false;
for (int i = 0; i < aLength; i++) {
if (cmp.compare(a[aFromIndex++], b[bFromIndex++]) != 0)
return false;
}
return true;
}
// Filling
/**
* Assigns the specified long value to each element of the specified array
* of longs.
*
* @param a the array to be filled
* @param val the value to be stored in all elements of the array
*/
public static void fill(long[] a, long val) {
for (int i = 0, len = a.length; i < len; i++)
a[i] = val;
}
/**
* 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 {@code fromIndex}, inclusive, to index
* {@code toIndex}, exclusive. (If {@code fromIndex==toIndex}, the
* range to be filled is empty.)
*
* @param a the array to be filled
* @param fromIndex the index of the first element (inclusive) to be
* filled with the specified value
* @param toIndex the index of the last element (exclusive) to be
* filled with the specified value
* @param val the value to be stored in all elements of the array
* @throws IllegalArgumentException if {@code fromIndex > toIndex}
* @throws ArrayIndexOutOfBoundsException if {@code fromIndex < 0} or
* {@code toIndex > a.length}
*/
public static void fill(long[] a, int fromIndex, int toIndex, long val) {
rangeCheck(a.length, fromIndex, toIndex);
for (int i = fromIndex; i < toIndex; i++)
a[i] = val;
}
/**
* Assigns the specified int value to each element of the specified array
* of ints.
*
* @param a the array to be filled
* @param val the value to be stored in all elements of the array
*/
public static void fill(int[] a, int val) {
for (int i = 0, len = a.length; i < len; i++)
a[i] = val;
}
/**
* 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 {@code fromIndex}, inclusive, to index
* {@code toIndex}, exclusive. (If {@code fromIndex==toIndex}, the
* range to be filled is empty.)
*
* @param a the array to be filled
* @param fromIndex the index of the first element (inclusive) to be
* filled with the specified value
* @param toIndex the index of the last element (exclusive) to be
* filled with the specified value
* @param val the value to be stored in all elements of the array
* @throws IllegalArgumentException if {@code fromIndex > toIndex}
* @throws ArrayIndexOutOfBoundsException if {@code fromIndex < 0} or
* {@code toIndex > a.length}
*/
public static void fill(int[] a, int fromIndex, int toIndex, int val) {
rangeCheck(a.length, fromIndex, toIndex);
for (int i = fromIndex; i < toIndex; i++)
a[i] = val;
}
/**
* Assigns the specified short value to each element of the specified array
* of shorts.
*
* @param a the array to be filled
* @param val the value to be stored in all elements of the array
*/
public static void fill(short[] a, short val) {
for (int i = 0, len = a.length; i < len; i++)
a[i] = val;
}
/**
* Assigns the specified short value to each element of the specified
* range of the specified array of shorts. The range to be filled
* extends from index {@code fromIndex}, inclusive, to index
* {@code toIndex}, exclusive. (If {@code fromIndex==toIndex}, the
* range to be filled is empty.)
*
* @param a the array to be filled
* @param fromIndex the index of the first element (inclusive) to be
* filled with the specified value
* @param toIndex the index of the last element (exclusive) to be
* filled with the specified value
* @param val the value to be stored in all elements of the array
* @throws IllegalArgumentException if {@code fromIndex > toIndex}
* @throws ArrayIndexOutOfBoundsException if {@code fromIndex < 0} or
* {@code toIndex > a.length}
*/
public static void fill(short[] a, int fromIndex, int toIndex, short val) {
rangeCheck(a.length, fromIndex, toIndex);
for (int i = fromIndex; i < toIndex; i++)
a[i] = val;
}
/**
* Assigns the specified char value to each element of the specified array
* of chars.
*
* @param a the array to be filled
* @param val the value to be stored in all elements of the array
*/
public static void fill(char[] a, char val) {
for (int i = 0, len = a.length; i < len; i++)
a[i] = val;
}
/**
* Assigns the specified char value to each element of the specified
* range of the specified array of chars. The range to be filled
* extends from index {@code fromIndex}, inclusive, to index
* {@code toIndex}, exclusive. (If {@code fromIndex==toIndex}, the
* range to be filled is empty.)
*
* @param a the array to be filled
* @param fromIndex the index of the first element (inclusive) to be
* filled with the specified value
* @param toIndex the index of the last element (exclusive) to be
* filled with the specified value
* @param val the value to be stored in all elements of the array
* @throws IllegalArgumentException if {@code fromIndex > toIndex}
* @throws ArrayIndexOutOfBoundsException if {@code fromIndex < 0} or
* {@code toIndex > a.length}
*/
public static void fill(char[] a, int fromIndex, int toIndex, char val) {
rangeCheck(a.length, fromIndex, toIndex);
for (int i = fromIndex; i < toIndex; i++)
a[i] = val;
}
/**
* Assigns the specified byte value to each element of the specified array
* of bytes.
*
* @param a the array to be filled
* @param val the value to be stored in all elements of the array
*/
public static void fill(byte[] a, byte val) {
for (int i = 0, len = a.length; i < len; i++)
a[i] = val;
}
/**
* Assigns the specified byte value to each element of the specified
* range of the specified array of bytes. The range to be filled
* extends from index {@code fromIndex}, inclusive, to index
* {@code toIndex}, exclusive. (If {@code fromIndex==toIndex}, the
* range to be filled is empty.)
*
* @param a the array to be filled
* @param fromIndex the index of the first element (inclusive) to be
* filled with the specified value
* @param toIndex the index of the last element (exclusive) to be
* filled with the specified value
* @param val the value to be stored in all elements of the array
* @throws IllegalArgumentException if {@code fromIndex > toIndex}
* @throws ArrayIndexOutOfBoundsException if {@code fromIndex < 0} or
* {@code toIndex > a.length}
*/
public static void fill(byte[] a, int fromIndex, int toIndex, byte val) {
rangeCheck(a.length, fromIndex, toIndex);
for (int i = fromIndex; i < toIndex; i++)
a[i] = val;
}
/**
* Assigns the specified boolean value to each element of the specified
* array of booleans.
*
* @param a the array to be filled
* @param val the value to be stored in all elements of the array
*/
public static void fill(boolean[] a, boolean val) {
for (int i = 0, len = a.length; i < len; i++)
a[i] = val;
}
/**
* Assigns the specified boolean value to each element of the specified
* range of the specified array of booleans. The range to be filled
* extends from index {@code fromIndex}, inclusive, to index
* {@code toIndex}, exclusive. (If {@code fromIndex==toIndex}, the
* range to be filled is empty.)
*
* @param a the array to be filled
* @param fromIndex the index of the first element (inclusive) to be
* filled with the specified value
* @param toIndex the index of the last element (exclusive) to be
* filled with the specified value
* @param val the value to be stored in all elements of the array
* @throws IllegalArgumentException if {@code fromIndex > toIndex}
* @throws ArrayIndexOutOfBoundsException if {@code fromIndex < 0} or
* {@code toIndex > a.length}
*/
public static void fill(boolean[] a, int fromIndex, int toIndex,
boolean val) {
rangeCheck(a.length, fromIndex, toIndex);
for (int i = fromIndex; i < toIndex; i++)
a[i] = val;
}
/**
* Assigns the specified double value to each element of the specified
* array of doubles.
*
* @param a the array to be filled
* @param val the value to be stored in all elements of the array
*/
public static void fill(double[] a, double val) {
for (int i = 0, len = a.length; i < len; i++)
a[i] = val;
}
/**
* Assigns the specified double value to each element of the specified
* range of the specified array of doubles. The range to be filled
* extends from index {@code fromIndex}, inclusive, to index
* {@code toIndex}, exclusive. (If {@code fromIndex==toIndex}, the
* range to be filled is empty.)
*
* @param a the array to be filled
* @param fromIndex the index of the first element (inclusive) to be
* filled with the specified value
* @param toIndex the index of the last element (exclusive) to be
* filled with the specified value
* @param val the value to be stored in all elements of the array
* @throws IllegalArgumentException if {@code fromIndex > toIndex}
* @throws ArrayIndexOutOfBoundsException if {@code fromIndex < 0} or
* {@code toIndex > a.length}
*/
public static void fill(double[] a, int fromIndex, int toIndex,double val){
rangeCheck(a.length, fromIndex, toIndex);
for (int i = fromIndex; i < toIndex; i++)
a[i] = val;
}
/**
* Assigns the specified float value to each element of the specified array
* of floats.
*
* @param a the array to be filled
* @param val the value to be stored in all elements of the array
*/
public static void fill(float[] a, float val) {
for (int i = 0, len = a.length; i < len; i++)
a[i] = val;
}
/**
* Assigns the specified float value to each element of the specified
* range of the specified array of floats. The range to be filled
* extends from index {@code fromIndex}, inclusive, to index
* {@code toIndex}, exclusive. (If {@code fromIndex==toIndex}, the
* range to be filled is empty.)
*
* @param a the array to be filled
* @param fromIndex the index of the first element (inclusive) to be
* filled with the specified value
* @param toIndex the index of the last element (exclusive) to be
* filled with the specified value
* @param val the value to be stored in all elements of the array
* @throws IllegalArgumentException if {@code fromIndex > toIndex}
* @throws ArrayIndexOutOfBoundsException if {@code fromIndex < 0} or
* {@code toIndex > a.length}
*/
public static void fill(float[] a, int fromIndex, int toIndex, float val) {
rangeCheck(a.length, fromIndex, toIndex);
for (int i = fromIndex; i < toIndex; i++)
a[i] = val;
}
/**
* Assigns the specified Object reference to each element of the specified
* array of Objects.
*
* @param a the array to be filled
* @param val the value to be stored in all elements of the array
* @throws ArrayStoreException if the specified value is not of a
* runtime type that can be stored in the specified array
*/
public static void fill(Object[] a, Object val) {
for (int i = 0, len = a.length; i < len; i++)
a[i] = val;
}
/**
* Assigns the specified Object reference to each element of the specified
* range of the specified array of Objects. The range to be filled
* extends from index {@code fromIndex}, inclusive, to index
* {@code toIndex}, exclusive. (If {@code fromIndex==toIndex}, the
* range to be filled is empty.)
*
* @param a the array to be filled
* @param fromIndex the index of the first element (inclusive) to be
* filled with the specified value
* @param toIndex the index of the last element (exclusive) to be
* filled with the specified value
* @param val the value to be stored in all elements of the array
* @throws IllegalArgumentException if {@code fromIndex > toIndex}
* @throws ArrayIndexOutOfBoundsException if {@code fromIndex < 0} or
* {@code toIndex > a.length}
* @throws ArrayStoreException if the specified value is not of a
* runtime type that can be stored in the specified array
*/
public static void fill(Object[] a, int fromIndex, int toIndex, Object val) {
rangeCheck(a.length, fromIndex, toIndex);
for (int i = fromIndex; i < toIndex; i++)
a[i] = val;
}
// Cloning
/**
* 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 {@code 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.
*
* @param the class of the objects in the array
* @param original the array to be copied
* @param newLength the length of the copy to be returned
* @return a copy of the original array, truncated or padded with nulls
* to obtain the specified length
* @throws NegativeArraySizeException if {@code newLength} is negative
* @throws NullPointerException if {@code original} is null
* @since 1.6
*/
@SuppressWarnings("unchecked")
public static T[] copyOf(T[] original, int newLength) {
return (T[]) copyOf(original, newLength, original.getClass());
}
/**
* 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 {@code 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 {@code newType}.
*
* @param the class of the objects in the original array
* @param the class of the objects in the returned array
* @param original the array to be copied
* @param newLength the length of the copy to be returned
* @param newType the class of the copy to be returned
* @return a copy of the original array, truncated or padded with nulls
* to obtain the specified length
* @throws NegativeArraySizeException if {@code newLength} is negative
* @throws NullPointerException if {@code original} is null
* @throws ArrayStoreException if an element copied from
* {@code original} is not of a runtime type that can be stored in
* an array of class {@code newType}
* @since 1.6
*/
@HotSpotIntrinsicCandidate
public static T[] copyOf(U[] original, int newLength, Class newType) {
@SuppressWarnings("unchecked")
T[] copy = ((Object)newType == (Object)Object[].class)
? (T[]) new Object[newLength]
: (T[]) Array.newInstance(newType.getComponentType(), newLength);
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
/**
* 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 {@code (byte)0}.
* Such indices will exist if and only if the specified length
* is greater than that of the original array.
*
* @param original the array to be copied
* @param newLength the length of the copy to be returned
* @return a copy of the original array, truncated or padded with zeros
* to obtain the specified length
* @throws NegativeArraySizeException if {@code newLength} is negative
* @throws NullPointerException if {@code original} is null
* @since 1.6
*/
public static byte[] copyOf(byte[] original, int newLength) {
byte[] copy = new byte[newLength];
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
/**
* 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 {@code (short)0}.
* Such indices will exist if and only if the specified length
* is greater than that of the original array.
*
* @param original the array to be copied
* @param newLength the length of the copy to be returned
* @return a copy of the original array, truncated or padded with zeros
* to obtain the specified length
* @throws NegativeArraySizeException if {@code newLength} is negative
* @throws NullPointerException if {@code original} is null
* @since 1.6
*/
public static short[] copyOf(short[] original, int newLength) {
short[] copy = new short[newLength];
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
/**
* 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 {@code 0}.
* Such indices will exist if and only if the specified length
* is greater than that of the original array.
*
* @param original the array to be copied
* @param newLength the length of the copy to be returned
* @return a copy of the original array, truncated or padded with zeros
* to obtain the specified length
* @throws NegativeArraySizeException if {@code newLength} is negative
* @throws NullPointerException if {@code original} is null
* @since 1.6
*/
public static int[] copyOf(int[] original, int newLength) {
int[] copy = new int[newLength];
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
/**
* 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 {@code 0L}.
* Such indices will exist if and only if the specified length
* is greater than that of the original array.
*
* @param original the array to be copied
* @param newLength the length of the copy to be returned
* @return a copy of the original array, truncated or padded with zeros
* to obtain the specified length
* @throws NegativeArraySizeException if {@code newLength} is negative
* @throws NullPointerException if {@code original} is null
* @since 1.6
*/
public static long[] copyOf(long[] original, int newLength) {
long[] copy = new long[newLength];
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
/**
* 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 {@code '\\u000'}. Such indices
* will exist if and only if the specified length is greater than that of
* the original array.
*
* @param original the array to be copied
* @param newLength the length of the copy to be returned
* @return a copy of the original array, truncated or padded with null characters
* to obtain the specified length
* @throws NegativeArraySizeException if {@code newLength} is negative
* @throws NullPointerException if {@code original} is null
* @since 1.6
*/
public static char[] copyOf(char[] original, int newLength) {
char[] copy = new char[newLength];
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
/**
* 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 {@code 0f}.
* Such indices will exist if and only if the specified length
* is greater than that of the original array.
*
* @param original the array to be copied
* @param newLength the length of the copy to be returned
* @return a copy of the original array, truncated or padded with zeros
* to obtain the specified length
* @throws NegativeArraySizeException if {@code newLength} is negative
* @throws NullPointerException if {@code original} is null
* @since 1.6
*/
public static float[] copyOf(float[] original, int newLength) {
float[] copy = new float[newLength];
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
/**
* 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 {@code 0d}.
* Such indices will exist if and only if the specified length
* is greater than that of the original array.
*
* @param original the array to be copied
* @param newLength the length of the copy to be returned
* @return a copy of the original array, truncated or padded with zeros
* to obtain the specified length
* @throws NegativeArraySizeException if {@code newLength} is negative
* @throws NullPointerException if {@code original} is null
* @since 1.6
*/
public static double[] copyOf(double[] original, int newLength) {
double[] copy = new double[newLength];
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
/**
* Copies the specified array, truncating or padding with {@code 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 {@code false}.
* Such indices will exist if and only if the specified length
* is greater than that of the original array.
*
* @param original the array to be copied
* @param newLength the length of the copy to be returned
* @return a copy of the original array, truncated or padded with false elements
* to obtain the specified length
* @throws NegativeArraySizeException if {@code newLength} is negative
* @throws NullPointerException if {@code original} is null
* @since 1.6
*/
public static boolean[] copyOf(boolean[] original, int newLength) {
boolean[] copy = new boolean[newLength];
System.arraycopy(original, 0, copy, 0,
Math.min(original.length, newLength));
return copy;
}
/**
* Copies the specified range of the specified array into a new array.
* The initial index of the range ({@code from}) must lie between zero
* and {@code original.length}, inclusive. The value at
* {@code original[from]} is placed into the initial element of the copy
* (unless {@code from == original.length} or {@code from == to}).
* Values from subsequent elements in the original array are placed into
* subsequent elements in the copy. The final index of the range
* ({@code to}), which must be greater than or equal to {@code from},
* may be greater than {@code original.length}, in which case
* {@code null} is placed in all elements of the copy whose index is
* greater than or equal to {@code original.length - from}. The length
* of the returned array will be {@code to - from}.
*
* The resulting array is of exactly the same class as the original array.
*
* @param the class of the objects in the array
* @param original the array from which a range is to be copied
* @param from the initial index of the range to be copied, inclusive
* @param to the final index of the range to be copied, exclusive.
* (This index may lie outside the array.)
* @return a new array containing the specified range from the original array,
* truncated or padded with nulls to obtain the required length
* @throws ArrayIndexOutOfBoundsException if {@code from < 0}
* or {@code from > original.length}
* @throws IllegalArgumentException if {@code from > to}
* @throws NullPointerException if {@code original} is null
* @since 1.6
*/
@SuppressWarnings("unchecked")
public static T[] copyOfRange(T[] original, int from, int to) {
return copyOfRange(original, from, to, (Class) original.getClass());
}
/**
* Copies the specified range of the specified array into a new array.
* The initial index of the range ({@code from}) must lie between zero
* and {@code original.length}, inclusive. The value at
* {@code original[from]} is placed into the initial element of the copy
* (unless {@code from == original.length} or {@code from == to}).
* Values from subsequent elements in the original array are placed into
* subsequent elements in the copy. The final index of the range
* ({@code to}), which must be greater than or equal to {@code from},
* may be greater than {@code original.length}, in which case
* {@code null} is placed in all elements of the copy whose index is
* greater than or equal to {@code original.length - from}. The length
* of the returned array will be {@code to - from}.
* The resulting array is of the class {@code newType}.
*
* @param the class of the objects in the original array
* @param the class of the objects in the returned array
* @param original the array from which a range is to be copied
* @param from the initial index of the range to be copied, inclusive
* @param to the final index of the range to be copied, exclusive.
* (This index may lie outside the array.)
* @param newType the class of the copy to be returned
* @return a new array containing the specified range from the original array,
* truncated or padded with nulls to obtain the required length
* @throws ArrayIndexOutOfBoundsException if {@code from < 0}
* or {@code from > original.length}
* @throws IllegalArgumentException if {@code from > to}
* @throws NullPointerException if {@code original} is null
* @throws ArrayStoreException if an element copied from
* {@code original} is not of a runtime type that can be stored in
* an array of class {@code newType}.
* @since 1.6
*/
@HotSpotIntrinsicCandidate
public static T[] copyOfRange(U[] original, int from, int to, Class newType) {
int newLength = to - from;
if (newLength < 0)
throw new IllegalArgumentException(from + " > " + to);
@SuppressWarnings("unchecked")
T[] copy = ((Object)newType == (Object)Object[].class)
? (T[]) new Object[newLength]
: (T[]) Array.newInstance(newType.getComponentType(), newLength);
System.arraycopy(original, from, copy, 0,
Math.min(original.length - from, newLength));
return copy;
}
/**
* Copies the specified range of the specified array into a new array.
* The initial index of the range ({@code from}) must lie between zero
* and {@code original.length}, inclusive. The value at
* {@code original[from]} is placed into the initial element of the copy
* (unless {@code from == original.length} or {@code from == to}).
* Values from subsequent elements in the original array are placed into
* subsequent elements in the copy. The final index of the range
* ({@code to}), which must be greater than or equal to {@code from},
* may be greater than {@code original.length}, in which case
* {@code (byte)0} is placed in all elements of the copy whose index is
* greater than or equal to {@code original.length - from}. The length
* of the returned array will be {@code to - from}.
*
* @param original the array from which a range is to be copied
* @param from the initial index of the range to be copied, inclusive
* @param to the final index of the range to be copied, exclusive.
* (This index may lie outside the array.)
* @return a new array containing the specified range from the original array,
* truncated or padded with zeros to obtain the required length
* @throws ArrayIndexOutOfBoundsException if {@code from < 0}
* or {@code from > original.length}
* @throws IllegalArgumentException if {@code from > to}
* @throws NullPointerException if {@code original} is null
* @since 1.6
*/
public static byte[] copyOfRange(byte[] original, int from, int to) {
int newLength = to - from;
if (newLength < 0)
throw new IllegalArgumentException(from + " > " + to);
byte[] copy = new byte[newLength];
System.arraycopy(original, from, copy, 0,
Math.min(original.length - from, newLength));
return copy;
}
/**
* Copies the specified range of the specified array into a new array.
* The initial index of the range ({@code from}) must lie between zero
* and {@code original.length}, inclusive. The value at
* {@code original[from]} is placed into the initial element of the copy
* (unless {@code from == original.length} or {@code from == to}).
* Values from subsequent elements in the original array are placed into
* subsequent elements in the copy. The final index of the range
* ({@code to}), which must be greater than or equal to {@code from},
* may be greater than {@code original.length}, in which case
* {@code (short)0} is placed in all elements of the copy whose index is
* greater than or equal to {@code original.length - from}. The length
* of the returned array will be {@code to - from}.
*
* @param original the array from which a range is to be copied
* @param from the initial index of the range to be copied, inclusive
* @param to the final index of the range to be copied, exclusive.
* (This index may lie outside the array.)
* @return a new array containing the specified range from the original array,
* truncated or padded with zeros to obtain the required length
* @throws ArrayIndexOutOfBoundsException if {@code from < 0}
* or {@code from > original.length}
* @throws IllegalArgumentException if {@code from > to}
* @throws NullPointerException if {@code original} is null
* @since 1.6
*/
public static short[] copyOfRange(short[] original, int from, int to) {
int newLength = to - from;
if (newLength < 0)
throw new IllegalArgumentException(from + " > " + to);
short[] copy = new short[newLength];
System.arraycopy(original, from, copy, 0,
Math.min(original.length - from, newLength));
return copy;
}
/**
* Copies the specified range of the specified array into a new array.
* The initial index of the range ({@code from}) must lie between zero
* and {@code original.length}, inclusive. The value at
* {@code original[from]} is placed into the initial element of the copy
* (unless {@code from == original.length} or {@code from == to}).
* Values from subsequent elements in the original array are placed into
* subsequent elements in the copy. The final index of the range
* ({@code to}), which must be greater than or equal to {@code from},
* may be greater than {@code original.length}, in which case
* {@code 0} is placed in all elements of the copy whose index is
* greater than or equal to {@code original.length - from}. The length
* of the returned array will be {@code to - from}.
*
* @param original the array from which a range is to be copied
* @param from the initial index of the range to be copied, inclusive
* @param to the final index of the range to be copied, exclusive.
* (This index may lie outside the array.)
* @return a new array containing the specified range from the original array,
* truncated or padded with zeros to obtain the required length
* @throws ArrayIndexOutOfBoundsException if {@code from < 0}
* or {@code from > original.length}
* @throws IllegalArgumentException if {@code from > to}
* @throws NullPointerException if {@code original} is null
* @since 1.6
*/
public static int[] copyOfRange(int[] original, int from, int to) {
int newLength = to - from;
if (newLength < 0)
throw new IllegalArgumentException(from + " > " + to);
int[] copy = new int[newLength];
System.arraycopy(original, from, copy, 0,
Math.min(original.length - from, newLength));
return copy;
}
/**
* Copies the specified range of the specified array into a new array.
* The initial index of the range ({@code from}) must lie between zero
* and {@code original.length}, inclusive. The value at
* {@code original[from]} is placed into the initial element of the copy
* (unless {@code from == original.length} or {@code from == to}).
* Values from subsequent elements in the original array are placed into
* subsequent elements in the copy. The final index of the range
* ({@code to}), which must be greater than or equal to {@code from},
* may be greater than {@code original.length}, in which case
* {@code 0L} is placed in all elements of the copy whose index is
* greater than or equal to {@code original.length - from}. The length
* of the returned array will be {@code to - from}.
*
* @param original the array from which a range is to be copied
* @param from the initial index of the range to be copied, inclusive
* @param to the final index of the range to be copied, exclusive.
* (This index may lie outside the array.)
* @return a new array containing the specified range from the original array,
* truncated or padded with zeros to obtain the required length
* @throws ArrayIndexOutOfBoundsException if {@code from < 0}
* or {@code from > original.length}
* @throws IllegalArgumentException if {@code from > to}
* @throws NullPointerException if {@code original} is null
* @since 1.6
*/
public static long[] copyOfRange(long[] original, int from, int to) {
int newLength = to - from;
if (newLength < 0)
throw new IllegalArgumentException(from + " > " + to);
long[] copy = new long[newLength];
System.arraycopy(original, from, copy, 0,
Math.min(original.length - from, newLength));
return copy;
}
/**
* Copies the specified range of the specified array into a new array.
* The initial index of the range ({@code from}) must lie between zero
* and {@code original.length}, inclusive. The value at
* {@code original[from]} is placed into the initial element of the copy
* (unless {@code from == original.length} or {@code from == to}).
* Values from subsequent elements in the original array are placed into
* subsequent elements in the copy. The final index of the range
* ({@code to}), which must be greater than or equal to {@code from},
* may be greater than {@code original.length}, in which case
* {@code '\\u000'} is placed in all elements of the copy whose index is
* greater than or equal to {@code original.length - from}. The length
* of the returned array will be {@code to - from}.
*
* @param original the array from which a range is to be copied
* @param from the initial index of the range to be copied, inclusive
* @param to the final index of the range to be copied, exclusive.
* (This index may lie outside the array.)
* @return a new array containing the specified range from the original array,
* truncated or padded with null characters to obtain the required length
* @throws ArrayIndexOutOfBoundsException if {@code from < 0}
* or {@code from > original.length}
* @throws IllegalArgumentException if {@code from > to}
* @throws NullPointerException if {@code original} is null
* @since 1.6
*/
public static char[] copyOfRange(char[] original, int from, int to) {
int newLength = to - from;
if (newLength < 0)
throw new IllegalArgumentException(from + " > " + to);
char[] copy = new char[newLength];
System.arraycopy(original, from, copy, 0,
Math.min(original.length - from, newLength));
return copy;
}
/**
* Copies the specified range of the specified array into a new array.
* The initial index of the range ({@code from}) must lie between zero
* and {@code original.length}, inclusive. The value at
* {@code original[from]} is placed into the initial element of the copy
* (unless {@code from == original.length} or {@code from == to}).
* Values from subsequent elements in the original array are placed into
* subsequent elements in the copy. The final index of the range
* ({@code to}), which must be greater than or equal to {@code from},
* may be greater than {@code original.length}, in which case
* {@code 0f} is placed in all elements of the copy whose index is
* greater than or equal to {@code original.length - from}. The length
* of the returned array will be {@code to - from}.
*
* @param original the array from which a range is to be copied
* @param from the initial index of the range to be copied, inclusive
* @param to the final index of the range to be copied, exclusive.
* (This index may lie outside the array.)
* @return a new array containing the specified range from the original array,
* truncated or padded with zeros to obtain the required length
* @throws ArrayIndexOutOfBoundsException if {@code from < 0}
* or {@code from > original.length}
* @throws IllegalArgumentException if {@code from > to}
* @throws NullPointerException if {@code original} is null
* @since 1.6
*/
public static float[] copyOfRange(float[] original, int from, int to) {
int newLength = to - from;
if (newLength < 0)
throw new IllegalArgumentException(from + " > " + to);
float[] copy = new float[newLength];
System.arraycopy(original, from, copy, 0,
Math.min(original.length - from, newLength));
return copy;
}
/**
* Copies the specified range of the specified array into a new array.
* The initial index of the range ({@code from}) must lie between zero
* and {@code original.length}, inclusive. The value at
* {@code original[from]} is placed into the initial element of the copy
* (unless {@code from == original.length} or {@code from == to}).
* Values from subsequent elements in the original array are placed into
* subsequent elements in the copy. The final index of the range
* ({@code to}), which must be greater than or equal to {@code from},
* may be greater than {@code original.length}, in which case
* {@code 0d} is placed in all elements of the copy whose index is
* greater than or equal to {@code original.length - from}. The length
* of the returned array will be {@code to - from}.
*
* @param original the array from which a range is to be copied
* @param from the initial index of the range to be copied, inclusive
* @param to the final index of the range to be copied, exclusive.
* (This index may lie outside the array.)
* @return a new array containing the specified range from the original array,
* truncated or padded with zeros to obtain the required length
* @throws ArrayIndexOutOfBoundsException if {@code from < 0}
* or {@code from > original.length}
* @throws IllegalArgumentException if {@code from > to}
* @throws NullPointerException if {@code original} is null
* @since 1.6
*/
public static double[] copyOfRange(double[] original, int from, int to) {
int newLength = to - from;
if (newLength < 0)
throw new IllegalArgumentException(from + " > " + to);
double[] copy = new double[newLength];
System.arraycopy(original, from, copy, 0,
Math.min(original.length - from, newLength));
return copy;
}
/**
* Copies the specified range of the specified array into a new array.
* The initial index of the range ({@code from}) must lie between zero
* and {@code original.length}, inclusive. The value at
* {@code original[from]} is placed into the initial element of the copy
* (unless {@code from == original.length} or {@code from == to}).
* Values from subsequent elements in the original array are placed into
* subsequent elements in the copy. The final index of the range
* ({@code to}), which must be greater than or equal to {@code from},
* may be greater than {@code original.length}, in which case
* {@code false} is placed in all elements of the copy whose index is
* greater than or equal to {@code original.length - from}. The length
* of the returned array will be {@code to - from}.
*
* @param original the array from which a range is to be copied
* @param from the initial index of the range to be copied, inclusive
* @param to the final index of the range to be copied, exclusive.
* (This index may lie outside the array.)
* @return a new array containing the specified range from the original array,
* truncated or padded with false elements to obtain the required length
* @throws ArrayIndexOutOfBoundsException if {@code from < 0}
* or {@code from > original.length}
* @throws IllegalArgumentException if {@code from > to}
* @throws NullPointerException if {@code original} is null
* @since 1.6
*/
public static boolean[] copyOfRange(boolean[] original, int from, int to) {
int newLength = to - from;
if (newLength < 0)
throw new IllegalArgumentException(from + " > " + to);
boolean[] copy = new boolean[newLength];
System.arraycopy(original, from, copy, 0,
Math.min(original.length - from, newLength));
return copy;
}
// Misc
/**
* 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 {@link Collection#toArray}. The returned list is
* serializable and implements {@link 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");
*
*
* @param the class of the objects in the array
* @param a the array by which the list will be backed
* @return a list view of the specified array
*/
@SafeVarargs
@SuppressWarnings("varargs")
public static List asList(T... a) {
return new ArrayList<>(a);
}
/**
* @serial include
*/
private static class ArrayList extends AbstractList
implements RandomAccess, java.io.Serializable
{
private static final long serialVersionUID = -2764017481108945198L;
private final E[] a;
ArrayList(E[] array) {
a = Objects.requireNonNull(array);
}
@Override
public int size() {
return a.length;
}
@Override
public Object[] toArray() {
return Arrays.copyOf(a, a.length, Object[].class);
}
@Override
@SuppressWarnings("unchecked")
public T[] toArray(T[] a) {
int size = size();
if (a.length < size)
return Arrays.copyOf(this.a, size,
(Class) a.getClass());
System.arraycopy(this.a, 0, a, 0, size);
if (a.length > size)
a[size] = null;
return a;
}
@Override
public E get(int index) {
return a[index];
}
@Override
public E set(int index, E element) {
E oldValue = a[index];
a[index] = element;
return oldValue;
}
@Override
public int indexOf(Object o) {
E[] a = this.a;
if (o == null) {
for (int i = 0; i < a.length; i++)
if (a[i] == null)
return i;
} else {
for (int i = 0; i < a.length; i++)
if (o.equals(a[i]))
return i;
}
return -1;
}
@Override
public boolean contains(Object o) {
return indexOf(o) >= 0;
}
@Override
public Spliterator spliterator() {
return Spliterators.spliterator(a, Spliterator.ORDERED);
}
@Override
public void forEach(Consumer action) {
Objects.requireNonNull(action);
for (E e : a) {
action.accept(e);
}
}
@Override
public void replaceAll(UnaryOperator operator) {
Objects.requireNonNull(operator);
E[] a = this.a;
for (int i = 0; i < a.length; i++) {
a[i] = operator.apply(a[i]);
}
}
@Override
public void sort(Comparator c) {
Arrays.sort(a, c);
}
@Override
public Iterator iterator() {
return new ArrayItr<>(a);
}
}
private static class ArrayItr implements Iterator {
private int cursor;
private final E[] a;
ArrayItr(E[] a) {
this.a = a;
}
@Override
public boolean hasNext() {
return cursor < a.length;
}
@Override
public E next() {
int i = cursor;
if (i >= a.length) {
throw new NoSuchElementException();
}
cursor = i + 1;
return a[i];
}
}
/**
* Returns a hash code based on the contents of the specified array.
* For any two {@code long} arrays {@code a} and {@code b}
* such that {@code Arrays.equals(a, b)}, it is also the case that
* {@code Arrays.hashCode(a) == Arrays.hashCode(b)}.
*
* The value returned by this method is the same value that would be
* obtained by invoking the {@link List#hashCode() hashCode}
* method on a {@link List} containing a sequence of {@link Long}
* instances representing the elements of {@code a} in the same order.
* If {@code a} is {@code null}, this method returns 0.
*
* @param a the array whose hash value to compute
* @return a content-based hash code for {@code a}
* @since 1.5
*/
public static int hashCode(long a[]) {
if (a == null)
return 0;
int result = 1;
for (long element : a) {
int elementHash = (int)(element ^ (element >>> 32));
result = 31 * result + elementHash;
}
return result;
}
/**
* Returns a hash code based on the contents of the specified array.
* For any two non-null {@code int} arrays {@code a} and {@code b}
* such that {@code Arrays.equals(a, b)}, it is also the case that
* {@code Arrays.hashCode(a) == Arrays.hashCode(b)}.
*
*
The value returned by this method is the same value that would be
* obtained by invoking the {@link List#hashCode() hashCode}
* method on a {@link List} containing a sequence of {@link Integer}
* instances representing the elements of {@code a} in the same order.
* If {@code a} is {@code null}, this method returns 0.
*
* @param a the array whose hash value to compute
* @return a content-based hash code for {@code a}
* @since 1.5
*/
public static int hashCode(int a[]) {
if (a == null)
return 0;
int result = 1;
for (int element : a)
result = 31 * result + element;
return result;
}
/**
* Returns a hash code based on the contents of the specified array.
* For any two {@code short} arrays {@code a} and {@code b}
* such that {@code Arrays.equals(a, b)}, it is also the case that
* {@code Arrays.hashCode(a) == Arrays.hashCode(b)}.
*
*
The value returned by this method is the same value that would be
* obtained by invoking the {@link List#hashCode() hashCode}
* method on a {@link List} containing a sequence of {@link Short}
* instances representing the elements of {@code a} in the same order.
* If {@code a} is {@code null}, this method returns 0.
*
* @param a the array whose hash value to compute
* @return a content-based hash code for {@code a}
* @since 1.5
*/
public static int hashCode(short a[]) {
if (a == null)
return 0;
int result = 1;
for (short element : a)
result = 31 * result + element;
return result;
}
/**
* Returns a hash code based on the contents of the specified array.
* For any two {@code char} arrays {@code a} and {@code b}
* such that {@code Arrays.equals(a, b)}, it is also the case that
* {@code Arrays.hashCode(a) == Arrays.hashCode(b)}.
*
*
The value returned by this method is the same value that would be
* obtained by invoking the {@link List#hashCode() hashCode}
* method on a {@link List} containing a sequence of {@link Character}
* instances representing the elements of {@code a} in the same order.
* If {@code a} is {@code null}, this method returns 0.
*
* @param a the array whose hash value to compute
* @return a content-based hash code for {@code a}
* @since 1.5
*/
public static int hashCode(char a[]) {
if (a == null)
return 0;
int result = 1;
for (char element : a)
result = 31 * result + element;
return result;
}
/**
* Returns a hash code based on the contents of the specified array.
* For any two {@code byte} arrays {@code a} and {@code b}
* such that {@code Arrays.equals(a, b)}, it is also the case that
* {@code Arrays.hashCode(a) == Arrays.hashCode(b)}.
*
*
The value returned by this method is the same value that would be
* obtained by invoking the {@link List#hashCode() hashCode}
* method on a {@link List} containing a sequence of {@link Byte}
* instances representing the elements of {@code a} in the same order.
* If {@code a} is {@code null}, this method returns 0.
*
* @param a the array whose hash value to compute
* @return a content-based hash code for {@code a}
* @since 1.5
*/
public static int hashCode(byte a[]) {
if (a == null)
return 0;
int result = 1;
for (byte element : a)
result = 31 * result + element;
return result;
}
/**
* Returns a hash code based on the contents of the specified array.
* For any two {@code boolean} arrays {@code a} and {@code b}
* such that {@code Arrays.equals(a, b)}, it is also the case that
* {@code Arrays.hashCode(a) == Arrays.hashCode(b)}.
*
*
The value returned by this method is the same value that would be
* obtained by invoking the {@link List#hashCode() hashCode}
* method on a {@link List} containing a sequence of {@link Boolean}
* instances representing the elements of {@code a} in the same order.
* If {@code a} is {@code null}, this method returns 0.
*
* @param a the array whose hash value to compute
* @return a content-based hash code for {@code a}
* @since 1.5
*/
public static int hashCode(boolean a[]) {
if (a == null)
return 0;
int result = 1;
for (boolean element : a)
result = 31 * result + (element ? 1231 : 1237);
return result;
}
/**
* Returns a hash code based on the contents of the specified array.
* For any two {@code float} arrays {@code a} and {@code b}
* such that {@code Arrays.equals(a, b)}, it is also the case that
* {@code Arrays.hashCode(a) == Arrays.hashCode(b)}.
*
*
The value returned by this method is the same value that would be
* obtained by invoking the {@link List#hashCode() hashCode}
* method on a {@link List} containing a sequence of {@link Float}
* instances representing the elements of {@code a} in the same order.
* If {@code a} is {@code null}, this method returns 0.
*
* @param a the array whose hash value to compute
* @return a content-based hash code for {@code a}
* @since 1.5
*/
public static int hashCode(float a[]) {
if (a == null)
return 0;
int result = 1;
for (float element : a)
result = 31 * result + Float.floatToIntBits(element);
return result;
}
/**
* Returns a hash code based on the contents of the specified array.
* For any two {@code double} arrays {@code a} and {@code b}
* such that {@code Arrays.equals(a, b)}, it is also the case that
* {@code Arrays.hashCode(a) == Arrays.hashCode(b)}.
*
*
The value returned by this method is the same value that would be
* obtained by invoking the {@link List#hashCode() hashCode}
* method on a {@link List} containing a sequence of {@link Double}
* instances representing the elements of {@code a} in the same order.
* If {@code a} is {@code null}, this method returns 0.
*
* @param a the array whose hash value to compute
* @return a content-based hash code for {@code a}
* @since 1.5
*/
public static int hashCode(double a[]) {
if (a == null)
return 0;
int result = 1;
for (double element : a) {
long bits = Double.doubleToLongBits(element);
result = 31 * result + (int)(bits ^ (bits >>> 32));
}
return result;
}
/**
* Returns a hash code based on the contents of the specified array. If
* the array contains other arrays as elements, the hash code is based on
* their identities rather than their contents. It is therefore
* acceptable to invoke this method on an array that contains itself as an
* element, either directly or indirectly through one or more levels of
* arrays.
*
*
For any two arrays {@code a} and {@code b} such that
* {@code Arrays.equals(a, b)}, it is also the case that
* {@code Arrays.hashCode(a) == Arrays.hashCode(b)}.
*
*
The value returned by this method is equal to the value that would
* be returned by {@code Arrays.asList(a).hashCode()}, unless {@code a}
* is {@code null}, in which case {@code 0} is returned.
*
* @param a the array whose content-based hash code to compute
* @return a content-based hash code for {@code a}
* @see #deepHashCode(Object[])
* @since 1.5
*/
public static int hashCode(Object a[]) {
if (a == null)
return 0;
int result = 1;
for (Object element : a)
result = 31 * result + (element == null ? 0 : element.hashCode());
return result;
}
/**
* 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 {@code a} and {@code b} such that
* {@code Arrays.deepEquals(a, b)}, it is also the case that
* {@code Arrays.deepHashCode(a) == Arrays.deepHashCode(b)}.
*
*
The computation of the value returned by this method is similar to
* that of the value returned by {@link List#hashCode()} on a list
* containing the same elements as {@code a} in the same order, with one
* difference: If an element {@code e} of {@code a} is itself an array,
* its hash code is computed not by calling {@code e.hashCode()}, but as
* by calling the appropriate overloading of {@code Arrays.hashCode(e)}
* if {@code e} is an array of a primitive type, or as by calling
* {@code Arrays.deepHashCode(e)} recursively if {@code e} is an array
* of a reference type. If {@code a} is {@code null}, this method
* returns 0.
*
* @param a the array whose deep-content-based hash code to compute
* @return a deep-content-based hash code for {@code a}
* @see #hashCode(Object[])
* @since 1.5
*/
public static int deepHashCode(Object a[]) {
if (a == null)
return 0;
int result = 1;
for (Object element : a) {
int elementHash = 0;
if (element instanceof Object[])
elementHash = deepHashCode((Object[]) element);
else if (element instanceof byte[])
elementHash = hashCode((byte[]) element);
else if (element instanceof short[])
elementHash = hashCode((short[]) element);
else if (element instanceof int[])
elementHash = hashCode((int[]) element);
else if (element instanceof long[])
elementHash = hashCode((long[]) element);
else if (element instanceof char[])
elementHash = hashCode((char[]) element);
else if (element instanceof float[])
elementHash = hashCode((float[]) element);
else if (element instanceof double[])
elementHash = hashCode((double[]) element);
else if (element instanceof boolean[])
elementHash = hashCode((boolean[]) element);
else if (element != null)
elementHash = element.hashCode();
result = 31 * result + elementHash;
}
return result;
}
/**
* Returns {@code true} if the two specified arrays are deeply
* equal to one another. Unlike the {@link #equals(Object[],Object[])}
* method, this method is appropriate for use with nested arrays of
* arbitrary depth.
*
*
Two array references are considered deeply equal if both
* are {@code 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 {@code null} elements {@code e1} and {@code e2} are
* deeply equal if any of the following conditions hold:
*
* {@code e1} and {@code e2} are both arrays of object reference
* types, and {@code Arrays.deepEquals(e1, e2) would return true}
* {@code e1} and {@code e2} are arrays of the same primitive
* type, and the appropriate overloading of
* {@code Arrays.equals(e1, e2)} would return true.
* {@code e1 == e2}
* {@code e1.equals(e2)} would return true.
*
* Note that this definition permits {@code null} elements at any depth.
*
* 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.
*
* @param a1 one array to be tested for equality
* @param a2 the other array to be tested for equality
* @return {@code true} if the two arrays are equal
* @see #equals(Object[],Object[])
* @see Objects#deepEquals(Object, Object)
* @since 1.5
*/
public static boolean deepEquals(Object[] a1, Object[] a2) {
if (a1 == a2)
return true;
if (a1 == null || a2==null)
return false;
int length = a1.length;
if (a2.length != length)
return false;
for (int i = 0; i < length; i++) {
Object e1 = a1[i];
Object e2 = a2[i];
if (e1 == e2)
continue;
if (e1 == null)
return false;
// Figure out whether the two elements are equal
boolean eq = deepEquals0(e1, e2);
if (!eq)
return false;
}
return true;
}
static boolean deepEquals0(Object e1, Object e2) {
assert e1 != null;
boolean eq;
if (e1 instanceof Object[] && e2 instanceof Object[])
eq = deepEquals ((Object[]) e1, (Object[]) e2);
else if (e1 instanceof byte[] && e2 instanceof byte[])
eq = equals((byte[]) e1, (byte[]) e2);
else if (e1 instanceof short[] && e2 instanceof short[])
eq = equals((short[]) e1, (short[]) e2);
else if (e1 instanceof int[] && e2 instanceof int[])
eq = equals((int[]) e1, (int[]) e2);
else if (e1 instanceof long[] && e2 instanceof long[])
eq = equals((long[]) e1, (long[]) e2);
else if (e1 instanceof char[] && e2 instanceof char[])
eq = equals((char[]) e1, (char[]) e2);
else if (e1 instanceof float[] && e2 instanceof float[])
eq = equals((float[]) e1, (float[]) e2);
else if (e1 instanceof double[] && e2 instanceof double[])
eq = equals((double[]) e1, (double[]) e2);
else if (e1 instanceof boolean[] && e2 instanceof boolean[])
eq = equals((boolean[]) e1, (boolean[]) e2);
else
eq = e1.equals(e2);
return eq;
}
/**
* Returns a string representation of the contents of the specified array.
* The string representation consists of a list of the array's elements,
* enclosed in square brackets ({@code "[]"}). Adjacent elements are
* separated by the characters {@code ", "} (a comma followed by a
* space). Elements are converted to strings as by
* {@code String.valueOf(long)}. Returns {@code "null"} if {@code a}
* is {@code null}.
*
* @param a the array whose string representation to return
* @return a string representation of {@code a}
* @since 1.5
*/
public static String toString(long[] a) {
if (a == null)
return "null";
int iMax = a.length - 1;
if (iMax == -1)
return "[]";
StringBuilder b = new StringBuilder();
b.append('[');
for (int i = 0; ; i++) {
b.append(a[i]);
if (i == iMax)
return b.append(']').toString();
b.append(", ");
}
}
/**
* Returns a string representation of the contents of the specified array.
* The string representation consists of a list of the array's elements,
* enclosed in square brackets ({@code "[]"}). Adjacent elements are
* separated by the characters {@code ", "} (a comma followed by a
* space). Elements are converted to strings as by
* {@code String.valueOf(int)}. Returns {@code "null"} if {@code a} is
* {@code null}.
*
* @param a the array whose string representation to return
* @return a string representation of {@code a}
* @since 1.5
*/
public static String toString(int[] a) {
if (a == null)
return "null";
int iMax = a.length - 1;
if (iMax == -1)
return "[]";
StringBuilder b = new StringBuilder();
b.append('[');
for (int i = 0; ; i++) {
b.append(a[i]);
if (i == iMax)
return b.append(']').toString();
b.append(", ");
}
}
/**
* Returns a string representation of the contents of the specified array.
* The string representation consists of a list of the array's elements,
* enclosed in square brackets ({@code "[]"}). Adjacent elements are
* separated by the characters {@code ", "} (a comma followed by a
* space). Elements are converted to strings as by
* {@code String.valueOf(short)}. Returns {@code "null"} if {@code a}
* is {@code null}.
*
* @param a the array whose string representation to return
* @return a string representation of {@code a}
* @since 1.5
*/
public static String toString(short[] a) {
if (a == null)
return "null";
int iMax = a.length - 1;
if (iMax == -1)
return "[]";
StringBuilder b = new StringBuilder();
b.append('[');
for (int i = 0; ; i++) {
b.append(a[i]);
if (i == iMax)
return b.append(']').toString();
b.append(", ");
}
}
/**
* Returns a string representation of the contents of the specified array.
* The string representation consists of a list of the array's elements,
* enclosed in square brackets ({@code "[]"}). Adjacent elements are
* separated by the characters {@code ", "} (a comma followed by a
* space). Elements are converted to strings as by
* {@code String.valueOf(char)}. Returns {@code "null"} if {@code a}
* is {@code null}.
*
* @param a the array whose string representation to return
* @return a string representation of {@code a}
* @since 1.5
*/
public static String toString(char[] a) {
if (a == null)
return "null";
int iMax = a.length - 1;
if (iMax == -1)
return "[]";
StringBuilder b = new StringBuilder();
b.append('[');
for (int i = 0; ; i++) {
b.append(a[i]);
if (i == iMax)
return b.append(']').toString();
b.append(", ");
}
}
/**
* Returns a string representation of the contents of the specified array.
* The string representation consists of a list of the array's elements,
* enclosed in square brackets ({@code "[]"}). Adjacent elements
* are separated by the characters {@code ", "} (a comma followed
* by a space). Elements are converted to strings as by
* {@code String.valueOf(byte)}. Returns {@code "null"} if
* {@code a} is {@code null}.
*
* @param a the array whose string representation to return
* @return a string representation of {@code a}
* @since 1.5
*/
public static String toString(byte[] a) {
if (a == null)
return "null";
int iMax = a.length - 1;
if (iMax == -1)
return "[]";
StringBuilder b = new StringBuilder();
b.append('[');
for (int i = 0; ; i++) {
b.append(a[i]);
if (i == iMax)
return b.append(']').toString();
b.append(", ");
}
}
/**
* Returns a string representation of the contents of the specified array.
* The string representation consists of a list of the array's elements,
* enclosed in square brackets ({@code "[]"}). Adjacent elements are
* separated by the characters {@code ", "} (a comma followed by a
* space). Elements are converted to strings as by
* {@code String.valueOf(boolean)}. Returns {@code "null"} if
* {@code a} is {@code null}.
*
* @param a the array whose string representation to return
* @return a string representation of {@code a}
* @since 1.5
*/
public static String toString(boolean[] a) {
if (a == null)
return "null";
int iMax = a.length - 1;
if (iMax == -1)
return "[]";
StringBuilder b = new StringBuilder();
b.append('[');
for (int i = 0; ; i++) {
b.append(a[i]);
if (i == iMax)
return b.append(']').toString();
b.append(", ");
}
}
/**
* Returns a string representation of the contents of the specified array.
* The string representation consists of a list of the array's elements,
* enclosed in square brackets ({@code "[]"}). Adjacent elements are
* separated by the characters {@code ", "} (a comma followed by a
* space). Elements are converted to strings as by
* {@code String.valueOf(float)}. Returns {@code "null"} if {@code a}
* is {@code null}.
*
* @param a the array whose string representation to return
* @return a string representation of {@code a}
* @since 1.5
*/
public static String toString(float[] a) {
if (a == null)
return "null";
int iMax = a.length - 1;
if (iMax == -1)
return "[]";
StringBuilder b = new StringBuilder();
b.append('[');
for (int i = 0; ; i++) {
b.append(a[i]);
if (i == iMax)
return b.append(']').toString();
b.append(", ");
}
}
/**
* Returns a string representation of the contents of the specified array.
* The string representation consists of a list of the array's elements,
* enclosed in square brackets ({@code "[]"}). Adjacent elements are
* separated by the characters {@code ", "} (a comma followed by a
* space). Elements are converted to strings as by
* {@code String.valueOf(double)}. Returns {@code "null"} if {@code a}
* is {@code null}.
*
* @param a the array whose string representation to return
* @return a string representation of {@code a}
* @since 1.5
*/
public static String toString(double[] a) {
if (a == null)
return "null";
int iMax = a.length - 1;
if (iMax == -1)
return "[]";
StringBuilder b = new StringBuilder();
b.append('[');
for (int i = 0; ; i++) {
b.append(a[i]);
if (i == iMax)
return b.append(']').toString();
b.append(", ");
}
}
/**
* Returns a string representation of the contents of the specified array.
* If the array contains other arrays as elements, they are converted to
* strings by the {@link Object#toString} method inherited from
* {@code Object}, which describes their identities rather than
* their contents.
*
*
The value returned by this method is equal to the value that would
* be returned by {@code Arrays.asList(a).toString()}, unless {@code a}
* is {@code null}, in which case {@code "null"} is returned.
*
* @param a the array whose string representation to return
* @return a string representation of {@code a}
* @see #deepToString(Object[])
* @since 1.5
*/
public static String toString(Object[] a) {
if (a == null)
return "null";
int iMax = a.length - 1;
if (iMax == -1)
return "[]";
StringBuilder b = new StringBuilder();
b.append('[');
for (int i = 0; ; i++) {
b.append(String.valueOf(a[i]));
if (i == iMax)
return b.append(']').toString();
b.append(", ");
}
}
/**
* 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 ({@code "[]"}). Adjacent
* elements are separated by the characters {@code ", "} (a comma
* followed by a space). Elements are converted to strings as by
* {@code String.valueOf(Object)}, unless they are themselves
* arrays.
*
*
If an element {@code e} is an array of a primitive type, it is
* converted to a string as by invoking the appropriate overloading of
* {@code Arrays.toString(e)}. If an element {@code 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
* {@code "[...]"}. For example, an array containing only a reference
* to itself would be rendered as {@code "[[...]]"}.
*
*
This method returns {@code "null"} if the specified array
* is {@code null}.
*
* @param a the array whose string representation to return
* @return a string representation of {@code a}
* @see #toString(Object[])
* @since 1.5
*/
public static String deepToString(Object[] a) {
if (a == null)
return "null";
int bufLen = 20 * a.length;
if (a.length != 0 && bufLen <= 0)
bufLen = Integer.MAX_VALUE;
StringBuilder buf = new StringBuilder(bufLen);
deepToString(a, buf, new HashSet<>());
return buf.toString();
}
private static void deepToString(Object[] a, StringBuilder buf,
Set dejaVu) {
if (a == null) {
buf.append("null");
return;
}
int iMax = a.length - 1;
if (iMax == -1) {
buf.append("[]");
return;
}
dejaVu.add(a);
buf.append('[');
for (int i = 0; ; i++) {
Object element = a[i];
if (element == null) {
buf.append("null");
} else {
Class eClass = element.getClass();
if (eClass.isArray()) {
if (eClass == byte[].class)
buf.append(toString((byte[]) element));
else if (eClass == short[].class)
buf.append(toString((short[]) element));
else if (eClass == int[].class)
buf.append(toString((int[]) element));
else if (eClass == long[].class)
buf.append(toString((long[]) element));
else if (eClass == char[].class)
buf.append(toString((char[]) element));
else if (eClass == float[].class)
buf.append(toString((float[]) element));
else if (eClass == double[].class)
buf.append(toString((double[]) element));
else if (eClass == boolean[].class)
buf.append(toString((boolean[]) element));
else { // element is an array of object references
if (dejaVu.contains(element))
buf.append("[...]");
else
deepToString((Object[])element, buf, dejaVu);
}
} else { // element is non-null and not an array
buf.append(element.toString());
}
}
if (i == iMax)
break;
buf.append(", ");
}
buf.append(']');
dejaVu.remove(a);
}
/**
* Set all elements of the specified array, using the provided
* generator function to compute each element.
*
* If the generator function throws an exception, it is relayed to
* the caller and the array is left in an indeterminate state.
*
* @apiNote
* Setting a subrange of an array, using a generator function to compute
* each element, can be written as follows:
*
{@code
* IntStream.range(startInclusive, endExclusive)
* .forEach(i -> array[i] = generator.apply(i));
* }
*
* @param type of elements of the array
* @param array array to be initialized
* @param generator a function accepting an index and producing the desired
* value for that position
* @throws NullPointerException if the generator is null
* @since 1.8
*/
public static void setAll(T[] array, IntFunction generator) {
Objects.requireNonNull(generator);
for (int i = 0; i < array.length; i++)
array[i] = generator.apply(i);
}
/**
* Set all elements of the specified array, in parallel, using the
* provided generator function to compute each element.
*
* If the generator function throws an exception, an unchecked exception
* is thrown from {@code parallelSetAll} and the array is left in an
* indeterminate state.
*
* @apiNote
* Setting a subrange of an array, in parallel, using a generator function
* to compute each element, can be written as follows:
*
{@code
* IntStream.range(startInclusive, endExclusive)
* .parallel()
* .forEach(i -> array[i] = generator.apply(i));
* }
*
* @param type of elements of the array
* @param array array to be initialized
* @param generator a function accepting an index and producing the desired
* value for that position
* @throws NullPointerException if the generator is null
* @since 1.8
*/
public static void parallelSetAll(T[] array, IntFunction generator) {
Objects.requireNonNull(generator);
IntStream.range(0, array.length).parallel().forEach(i -> { array[i] = generator.apply(i); });
}
/**
* Set all elements of the specified array, using the provided
* generator function to compute each element.
*
* If the generator function throws an exception, it is relayed to
* the caller and the array is left in an indeterminate state.
*
* @apiNote
* Setting a subrange of an array, using a generator function to compute
* each element, can be written as follows:
*
{@code
* IntStream.range(startInclusive, endExclusive)
* .forEach(i -> array[i] = generator.applyAsInt(i));
* }
*
* @param array array to be initialized
* @param generator a function accepting an index and producing the desired
* value for that position
* @throws NullPointerException if the generator is null
* @since 1.8
*/
public static void setAll(int[] array, IntUnaryOperator generator) {
Objects.requireNonNull(generator);
for (int i = 0; i < array.length; i++)
array[i] = generator.applyAsInt(i);
}
/**
* Set all elements of the specified array, in parallel, using the
* provided generator function to compute each element.
*
* If the generator function throws an exception, an unchecked exception
* is thrown from {@code parallelSetAll} and the array is left in an
* indeterminate state.
*
* @apiNote
* Setting a subrange of an array, in parallel, using a generator function
* to compute each element, can be written as follows:
*
{@code
* IntStream.range(startInclusive, endExclusive)
* .parallel()
* .forEach(i -> array[i] = generator.applyAsInt(i));
* }
*
* @param array array to be initialized
* @param generator a function accepting an index and producing the desired
* value for that position
* @throws NullPointerException if the generator is null
* @since 1.8
*/
public static void parallelSetAll(int[] array, IntUnaryOperator generator) {
Objects.requireNonNull(generator);
IntStream.range(0, array.length).parallel().forEach(i -> { array[i] = generator.applyAsInt(i); });
}
/**
* Set all elements of the specified array, using the provided
* generator function to compute each element.
*
* If the generator function throws an exception, it is relayed to
* the caller and the array is left in an indeterminate state.
*
* @apiNote
* Setting a subrange of an array, using a generator function to compute
* each element, can be written as follows:
*
{@code
* IntStream.range(startInclusive, endExclusive)
* .forEach(i -> array[i] = generator.applyAsLong(i));
* }
*
* @param array array to be initialized
* @param generator a function accepting an index and producing the desired
* value for that position
* @throws NullPointerException if the generator is null
* @since 1.8
*/
public static void setAll(long[] array, IntToLongFunction generator) {
Objects.requireNonNull(generator);
for (int i = 0; i < array.length; i++)
array[i] = generator.applyAsLong(i);
}
/**
* Set all elements of the specified array, in parallel, using the
* provided generator function to compute each element.
*
* If the generator function throws an exception, an unchecked exception
* is thrown from {@code parallelSetAll} and the array is left in an
* indeterminate state.
*
* @apiNote
* Setting a subrange of an array, in parallel, using a generator function
* to compute each element, can be written as follows:
*
{@code
* IntStream.range(startInclusive, endExclusive)
* .parallel()
* .forEach(i -> array[i] = generator.applyAsLong(i));
* }
*
* @param array array to be initialized
* @param generator a function accepting an index and producing the desired
* value for that position
* @throws NullPointerException if the generator is null
* @since 1.8
*/
public static void parallelSetAll(long[] array, IntToLongFunction generator) {
Objects.requireNonNull(generator);
IntStream.range(0, array.length).parallel().forEach(i -> { array[i] = generator.applyAsLong(i); });
}
/**
* Set all elements of the specified array, using the provided
* generator function to compute each element.
*
* If the generator function throws an exception, it is relayed to
* the caller and the array is left in an indeterminate state.
*
* @apiNote
* Setting a subrange of an array, using a generator function to compute
* each element, can be written as follows:
*
{@code
* IntStream.range(startInclusive, endExclusive)
* .forEach(i -> array[i] = generator.applyAsDouble(i));
* }
*
* @param array array to be initialized
* @param generator a function accepting an index and producing the desired
* value for that position
* @throws NullPointerException if the generator is null
* @since 1.8
*/
public static void setAll(double[] array, IntToDoubleFunction generator) {
Objects.requireNonNull(generator);
for (int i = 0; i < array.length; i++)
array[i] = generator.applyAsDouble(i);
}
/**
* Set all elements of the specified array, in parallel, using the
* provided generator function to compute each element.
*
* If the generator function throws an exception, an unchecked exception
* is thrown from {@code parallelSetAll} and the array is left in an
* indeterminate state.
*
* @apiNote
* Setting a subrange of an array, in parallel, using a generator function
* to compute each element, can be written as follows:
*
{@code
* IntStream.range(startInclusive, endExclusive)
* .parallel()
* .forEach(i -> array[i] = generator.applyAsDouble(i));
* }
*
* @param array array to be initialized
* @param generator a function accepting an index and producing the desired
* value for that position
* @throws NullPointerException if the generator is null
* @since 1.8
*/
public static void parallelSetAll(double[] array, IntToDoubleFunction generator) {
Objects.requireNonNull(generator);
IntStream.range(0, array.length).parallel().forEach(i -> { array[i] = generator.applyAsDouble(i); });
}
/**
* Returns a {@link Spliterator} covering all of the specified array.
*
* The spliterator reports {@link Spliterator#SIZED},
* {@link Spliterator#SUBSIZED}, {@link Spliterator#ORDERED}, and
* {@link Spliterator#IMMUTABLE}.
*
* @param type of elements
* @param array the array, assumed to be unmodified during use
* @return a spliterator for the array elements
* @since 1.8
*/
public static Spliterator spliterator(T[] array) {
return Spliterators.spliterator(array,
Spliterator.ORDERED | Spliterator.IMMUTABLE);
}
/**
* Returns a {@link Spliterator} covering the specified range of the
* specified array.
*
* The spliterator reports {@link Spliterator#SIZED},
* {@link Spliterator#SUBSIZED}, {@link Spliterator#ORDERED}, and
* {@link Spliterator#IMMUTABLE}.
*
* @param type of elements
* @param array the array, assumed to be unmodified during use
* @param startInclusive the first index to cover, inclusive
* @param endExclusive index immediately past the last index to cover
* @return a spliterator for the array elements
* @throws ArrayIndexOutOfBoundsException if {@code startInclusive} is
* negative, {@code endExclusive} is less than
* {@code startInclusive}, or {@code endExclusive} is greater than
* the array size
* @since 1.8
*/
public static Spliterator spliterator(T[] array, int startInclusive, int endExclusive) {
return Spliterators.spliterator(array, startInclusive, endExclusive,
Spliterator.ORDERED | Spliterator.IMMUTABLE);
}
/**
* Returns a {@link Spliterator.OfInt} covering all of the specified array.
*
* The spliterator reports {@link Spliterator#SIZED},
* {@link Spliterator#SUBSIZED}, {@link Spliterator#ORDERED}, and
* {@link Spliterator#IMMUTABLE}.
*
* @param array the array, assumed to be unmodified during use
* @return a spliterator for the array elements
* @since 1.8
*/
public static Spliterator.OfInt spliterator(int[] array) {
return Spliterators.spliterator(array,
Spliterator.ORDERED | Spliterator.IMMUTABLE);
}
/**
* Returns a {@link Spliterator.OfInt} covering the specified range of the
* specified array.
*
*
The spliterator reports {@link Spliterator#SIZED},
* {@link Spliterator#SUBSIZED}, {@link Spliterator#ORDERED}, and
* {@link Spliterator#IMMUTABLE}.
*
* @param array the array, assumed to be unmodified during use
* @param startInclusive the first index to cover, inclusive
* @param endExclusive index immediately past the last index to cover
* @return a spliterator for the array elements
* @throws ArrayIndexOutOfBoundsException if {@code startInclusive} is
* negative, {@code endExclusive} is less than
* {@code startInclusive}, or {@code endExclusive} is greater than
* the array size
* @since 1.8
*/
public static Spliterator.OfInt spliterator(int[] array, int startInclusive, int endExclusive) {
return Spliterators.spliterator(array, startInclusive, endExclusive,
Spliterator.ORDERED | Spliterator.IMMUTABLE);
}
/**
* Returns a {@link Spliterator.OfLong} covering all of the specified array.
*
*
The spliterator reports {@link Spliterator#SIZED},
* {@link Spliterator#SUBSIZED}, {@link Spliterator#ORDERED}, and
* {@link Spliterator#IMMUTABLE}.
*
* @param array the array, assumed to be unmodified during use
* @return the spliterator for the array elements
* @since 1.8
*/
public static Spliterator.OfLong spliterator(long[] array) {
return Spliterators.spliterator(array,
Spliterator.ORDERED | Spliterator.IMMUTABLE);
}
/**
* Returns a {@link Spliterator.OfLong} covering the specified range of the
* specified array.
*
*
The spliterator reports {@link Spliterator#SIZED},
* {@link Spliterator#SUBSIZED}, {@link Spliterator#ORDERED}, and
* {@link Spliterator#IMMUTABLE}.
*
* @param array the array, assumed to be unmodified during use
* @param startInclusive the first index to cover, inclusive
* @param endExclusive index immediately past the last index to cover
* @return a spliterator for the array elements
* @throws ArrayIndexOutOfBoundsException if {@code startInclusive} is
* negative, {@code endExclusive} is less than
* {@code startInclusive}, or {@code endExclusive} is greater than
* the array size
* @since 1.8
*/
public static Spliterator.OfLong spliterator(long[] array, int startInclusive, int endExclusive) {
return Spliterators.spliterator(array, startInclusive, endExclusive,
Spliterator.ORDERED | Spliterator.IMMUTABLE);
}
/**
* Returns a {@link Spliterator.OfDouble} covering all of the specified
* array.
*
*
The spliterator reports {@link Spliterator#SIZED},
* {@link Spliterator#SUBSIZED}, {@link Spliterator#ORDERED}, and
* {@link Spliterator#IMMUTABLE}.
*
* @param array the array, assumed to be unmodified during use
* @return a spliterator for the array elements
* @since 1.8
*/
public static Spliterator.OfDouble spliterator(double[] array) {
return Spliterators.spliterator(array,
Spliterator.ORDERED | Spliterator.IMMUTABLE);
}
/**
* Returns a {@link Spliterator.OfDouble} covering the specified range of
* the specified array.
*
*
The spliterator reports {@link Spliterator#SIZED},
* {@link Spliterator#SUBSIZED}, {@link Spliterator#ORDERED}, and
* {@link Spliterator#IMMUTABLE}.
*
* @param array the array, assumed to be unmodified during use
* @param startInclusive the first index to cover, inclusive
* @param endExclusive index immediately past the last index to cover
* @return a spliterator for the array elements
* @throws ArrayIndexOutOfBoundsException if {@code startInclusive} is
* negative, {@code endExclusive} is less than
* {@code startInclusive}, or {@code endExclusive} is greater than
* the array size
* @since 1.8
*/
public static Spliterator.OfDouble spliterator(double[] array, int startInclusive, int endExclusive) {
return Spliterators.spliterator(array, startInclusive, endExclusive,
Spliterator.ORDERED | Spliterator.IMMUTABLE);
}
/**
* Returns a sequential {@link Stream} with the specified array as its
* source.
*
* @param The type of the array elements
* @param array The array, assumed to be unmodified during use
* @return a {@code Stream} for the array
* @since 1.8
*/
public static Stream stream(T[] array) {
return stream(array, 0, array.length);
}
/**
* Returns a sequential {@link Stream} with the specified range of the
* specified array as its source.
*
* @param the type of the array elements
* @param array the array, assumed to be unmodified during use
* @param startInclusive the first index to cover, inclusive
* @param endExclusive index immediately past the last index to cover
* @return a {@code Stream} for the array range
* @throws ArrayIndexOutOfBoundsException if {@code startInclusive} is
* negative, {@code endExclusive} is less than
* {@code startInclusive}, or {@code endExclusive} is greater than
* the array size
* @since 1.8
*/
public static Stream stream(T[] array, int startInclusive, int endExclusive) {
return StreamSupport.stream(spliterator(array, startInclusive, endExclusive), false);
}
/**
* Returns a sequential {@link IntStream} with the specified array as its
* source.
*
* @param array the array, assumed to be unmodified during use
* @return an {@code IntStream} for the array
* @since 1.8
*/
public static IntStream stream(int[] array) {
return stream(array, 0, array.length);
}
/**
* Returns a sequential {@link IntStream} with the specified range of the
* specified array as its source.
*
* @param array the array, assumed to be unmodified during use
* @param startInclusive the first index to cover, inclusive
* @param endExclusive index immediately past the last index to cover
* @return an {@code IntStream} for the array range
* @throws ArrayIndexOutOfBoundsException if {@code startInclusive} is
* negative, {@code endExclusive} is less than
* {@code startInclusive}, or {@code endExclusive} is greater than
* the array size
* @since 1.8
*/
public static IntStream stream(int[] array, int startInclusive, int endExclusive) {
return StreamSupport.intStream(spliterator(array, startInclusive, endExclusive), false);
}
/**
* Returns a sequential {@link LongStream} with the specified array as its
* source.
*
* @param array the array, assumed to be unmodified during use
* @return a {@code LongStream} for the array
* @since 1.8
*/
public static LongStream stream(long[] array) {
return stream(array, 0, array.length);
}
/**
* Returns a sequential {@link LongStream} with the specified range of the
* specified array as its source.
*
* @param array the array, assumed to be unmodified during use
* @param startInclusive the first index to cover, inclusive
* @param endExclusive index immediately past the last index to cover
* @return a {@code LongStream} for the array range
* @throws ArrayIndexOutOfBoundsException if {@code startInclusive} is
* negative, {@code endExclusive} is less than
* {@code startInclusive}, or {@code endExclusive} is greater than
* the array size
* @since 1.8
*/
public static LongStream stream(long[] array, int startInclusive, int endExclusive) {
return StreamSupport.longStream(spliterator(array, startInclusive, endExclusive), false);
}
/**
* Returns a sequential {@link DoubleStream} with the specified array as its
* source.
*
* @param array the array, assumed to be unmodified during use
* @return a {@code DoubleStream} for the array
* @since 1.8
*/
public static DoubleStream stream(double[] array) {
return stream(array, 0, array.length);
}
/**
* Returns a sequential {@link DoubleStream} with the specified range of the
* specified array as its source.
*
* @param array the array, assumed to be unmodified during use
* @param startInclusive the first index to cover, inclusive
* @param endExclusive index immediately past the last index to cover
* @return a {@code DoubleStream} for the array range
* @throws ArrayIndexOutOfBoundsException if {@code startInclusive} is
* negative, {@code endExclusive} is less than
* {@code startInclusive}, or {@code endExclusive} is greater than
* the array size
* @since 1.8
*/
public static DoubleStream stream(double[] array, int startInclusive, int endExclusive) {
return StreamSupport.doubleStream(spliterator(array, startInclusive, endExclusive), false);
}
// Comparison methods
// Compare boolean
/**
* Compares two {@code boolean} arrays lexicographically.
*
* If the two arrays share a common prefix then the lexicographic
* comparison is the result of comparing two elements, as if by
* {@link Boolean#compare(boolean, boolean)}, at an index within the
* respective arrays that is the prefix length.
* Otherwise, one array is a proper prefix of the other and, lexicographic
* comparison is the result of comparing the two array lengths.
* (See {@link #mismatch(boolean[], boolean[])} for the definition of a
* common and proper prefix.)
*
*
A {@code null} array reference is considered lexicographically less
* than a non-{@code null} array reference. Two {@code null} array
* references are considered equal.
*
*
The comparison is consistent with {@link #equals(boolean[], boolean[]) equals},
* more specifically the following holds for arrays {@code a} and {@code b}:
*
{@code
* Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
* }
*
* @apiNote
* This method behaves as if (for non-{@code null} array references):
*
{@code
* int i = Arrays.mismatch(a, b);
* if (i >= 0 && i < Math.min(a.length, b.length))
* return Boolean.compare(a[i], b[i]);
* return a.length - b.length;
* }
*
* @param a the first array to compare
* @param b the second array to compare
* @return the value {@code 0} if the first and second array are equal and
* contain the same elements in the same order;
* a value less than {@code 0} if the first array is
* lexicographically less than the second array; and
* a value greater than {@code 0} if the first array is
* lexicographically greater than the second array
* @since 9
*/
public static int compare(boolean[] a, boolean[] b) {
if (a == b)
return 0;
if (a == null || b == null)
return a == null ? -1 : 1;
int i = ArraysSupport.mismatch(a, b,
Math.min(a.length, b.length));
if (i >= 0) {
return Boolean.compare(a[i], b[i]);
}
return a.length - b.length;
}
/**
* Compares two {@code boolean} arrays lexicographically over the specified
* ranges.
*
* If the two arrays, over the specified ranges, share a common prefix
* then the lexicographic comparison is the result of comparing two
* elements, as if by {@link Boolean#compare(boolean, boolean)}, at a
* relative index within the respective arrays that is the length of the
* prefix.
* Otherwise, one array is a proper prefix of the other and, lexicographic
* comparison is the result of comparing the two range lengths.
* (See {@link #mismatch(boolean[], int, int, boolean[], int, int)} for the
* definition of a common and proper prefix.)
*
*
The comparison is consistent with
* {@link #equals(boolean[], int, int, boolean[], int, int) equals}, more
* specifically the following holds for arrays {@code a} and {@code b} with
* specified ranges [{@code aFromIndex}, {@code atoIndex}) and
* [{@code bFromIndex}, {@code btoIndex}) respectively:
*
{@code
* Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
* (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
* }
*
* @apiNote
* This method behaves as if:
*
{@code
* int i = Arrays.mismatch(a, aFromIndex, aToIndex,
* b, bFromIndex, bToIndex);
* if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
* return Boolean.compare(a[aFromIndex + i], b[bFromIndex + i]);
* return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
* }
*
* @param a the first array to compare
* @param aFromIndex the index (inclusive) of the first element in the
* first array to be compared
* @param aToIndex the index (exclusive) of the last element in the
* first array to be compared
* @param b the second array to compare
* @param bFromIndex the index (inclusive) of the first element in the
* second array to be compared
* @param bToIndex the index (exclusive) of the last element in the
* second array to be compared
* @return the value {@code 0} if, over the specified ranges, the first and
* second array are equal and contain the same elements in the same
* order;
* a value less than {@code 0} if, over the specified ranges, the
* first array is lexicographically less than the second array; and
* a value greater than {@code 0} if, over the specified ranges, the
* first array is lexicographically greater than the second array
* @throws IllegalArgumentException
* if {@code aFromIndex > aToIndex} or
* if {@code bFromIndex > bToIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code aFromIndex < 0 or aToIndex > a.length} or
* if {@code bFromIndex < 0 or bToIndex > b.length}
* @throws NullPointerException
* if either array is {@code null}
* @since 9
*/
public static int compare(boolean[] a, int aFromIndex, int aToIndex,
boolean[] b, int bFromIndex, int bToIndex) {
rangeCheck(a.length, aFromIndex, aToIndex);
rangeCheck(b.length, bFromIndex, bToIndex);
int aLength = aToIndex - aFromIndex;
int bLength = bToIndex - bFromIndex;
int i = ArraysSupport.mismatch(a, aFromIndex,
b, bFromIndex,
Math.min(aLength, bLength));
if (i >= 0) {
return Boolean.compare(a[aFromIndex + i], b[bFromIndex + i]);
}
return aLength - bLength;
}
// Compare byte
/**
* Compares two {@code byte} arrays lexicographically.
*
* If the two arrays share a common prefix then the lexicographic
* comparison is the result of comparing two elements, as if by
* {@link Byte#compare(byte, byte)}, at an index within the respective
* arrays that is the prefix length.
* Otherwise, one array is a proper prefix of the other and, lexicographic
* comparison is the result of comparing the two array lengths.
* (See {@link #mismatch(byte[], byte[])} for the definition of a common and
* proper prefix.)
*
*
A {@code null} array reference is considered lexicographically less
* than a non-{@code null} array reference. Two {@code null} array
* references are considered equal.
*
*
The comparison is consistent with {@link #equals(byte[], byte[]) equals},
* more specifically the following holds for arrays {@code a} and {@code b}:
*
{@code
* Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
* }
*
* @apiNote
* This method behaves as if (for non-{@code null} array references):
*
{@code
* int i = Arrays.mismatch(a, b);
* if (i >= 0 && i < Math.min(a.length, b.length))
* return Byte.compare(a[i], b[i]);
* return a.length - b.length;
* }
*
* @param a the first array to compare
* @param b the second array to compare
* @return the value {@code 0} if the first and second array are equal and
* contain the same elements in the same order;
* a value less than {@code 0} if the first array is
* lexicographically less than the second array; and
* a value greater than {@code 0} if the first array is
* lexicographically greater than the second array
* @since 9
*/
public static int compare(byte[] a, byte[] b) {
if (a == b)
return 0;
if (a == null || b == null)
return a == null ? -1 : 1;
int i = ArraysSupport.mismatch(a, b,
Math.min(a.length, b.length));
if (i >= 0) {
return Byte.compare(a[i], b[i]);
}
return a.length - b.length;
}
/**
* Compares two {@code byte} arrays lexicographically over the specified
* ranges.
*
* If the two arrays, over the specified ranges, share a common prefix
* then the lexicographic comparison is the result of comparing two
* elements, as if by {@link Byte#compare(byte, byte)}, at a relative index
* within the respective arrays that is the length of the prefix.
* Otherwise, one array is a proper prefix of the other and, lexicographic
* comparison is the result of comparing the two range lengths.
* (See {@link #mismatch(byte[], int, int, byte[], int, int)} for the
* definition of a common and proper prefix.)
*
*
The comparison is consistent with
* {@link #equals(byte[], int, int, byte[], int, int) equals}, more
* specifically the following holds for arrays {@code a} and {@code b} with
* specified ranges [{@code aFromIndex}, {@code atoIndex}) and
* [{@code bFromIndex}, {@code btoIndex}) respectively:
*
{@code
* Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
* (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
* }
*
* @apiNote
* This method behaves as if:
*
{@code
* int i = Arrays.mismatch(a, aFromIndex, aToIndex,
* b, bFromIndex, bToIndex);
* if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
* return Byte.compare(a[aFromIndex + i], b[bFromIndex + i]);
* return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
* }
*
* @param a the first array to compare
* @param aFromIndex the index (inclusive) of the first element in the
* first array to be compared
* @param aToIndex the index (exclusive) of the last element in the
* first array to be compared
* @param b the second array to compare
* @param bFromIndex the index (inclusive) of the first element in the
* second array to be compared
* @param bToIndex the index (exclusive) of the last element in the
* second array to be compared
* @return the value {@code 0} if, over the specified ranges, the first and
* second array are equal and contain the same elements in the same
* order;
* a value less than {@code 0} if, over the specified ranges, the
* first array is lexicographically less than the second array; and
* a value greater than {@code 0} if, over the specified ranges, the
* first array is lexicographically greater than the second array
* @throws IllegalArgumentException
* if {@code aFromIndex > aToIndex} or
* if {@code bFromIndex > bToIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code aFromIndex < 0 or aToIndex > a.length} or
* if {@code bFromIndex < 0 or bToIndex > b.length}
* @throws NullPointerException
* if either array is {@code null}
* @since 9
*/
public static int compare(byte[] a, int aFromIndex, int aToIndex,
byte[] b, int bFromIndex, int bToIndex) {
rangeCheck(a.length, aFromIndex, aToIndex);
rangeCheck(b.length, bFromIndex, bToIndex);
int aLength = aToIndex - aFromIndex;
int bLength = bToIndex - bFromIndex;
int i = ArraysSupport.mismatch(a, aFromIndex,
b, bFromIndex,
Math.min(aLength, bLength));
if (i >= 0) {
return Byte.compare(a[aFromIndex + i], b[bFromIndex + i]);
}
return aLength - bLength;
}
/**
* Compares two {@code byte} arrays lexicographically, numerically treating
* elements as unsigned.
*
* If the two arrays share a common prefix then the lexicographic
* comparison is the result of comparing two elements, as if by
* {@link Byte#compareUnsigned(byte, byte)}, at an index within the
* respective arrays that is the prefix length.
* Otherwise, one array is a proper prefix of the other and, lexicographic
* comparison is the result of comparing the two array lengths.
* (See {@link #mismatch(byte[], byte[])} for the definition of a common
* and proper prefix.)
*
*
A {@code null} array reference is considered lexicographically less
* than a non-{@code null} array reference. Two {@code null} array
* references are considered equal.
*
* @apiNote
*
This method behaves as if (for non-{@code null} array references):
*
{@code
* int i = Arrays.mismatch(a, b);
* if (i >= 0 && i < Math.min(a.length, b.length))
* return Byte.compareUnsigned(a[i], b[i]);
* return a.length - b.length;
* }
*
* @param a the first array to compare
* @param b the second array to compare
* @return the value {@code 0} if the first and second array are
* equal and contain the same elements in the same order;
* a value less than {@code 0} if the first array is
* lexicographically less than the second array; and
* a value greater than {@code 0} if the first array is
* lexicographically greater than the second array
* @since 9
*/
public static int compareUnsigned(byte[] a, byte[] b) {
if (a == b)
return 0;
if (a == null || b == null)
return a == null ? -1 : 1;
int i = ArraysSupport.mismatch(a, b,
Math.min(a.length, b.length));
if (i >= 0) {
return Byte.compareUnsigned(a[i], b[i]);
}
return a.length - b.length;
}
/**
* Compares two {@code byte} arrays lexicographically over the specified
* ranges, numerically treating elements as unsigned.
*
* If the two arrays, over the specified ranges, share a common prefix
* then the lexicographic comparison is the result of comparing two
* elements, as if by {@link Byte#compareUnsigned(byte, byte)}, at a
* relative index within the respective arrays that is the length of the
* prefix.
* Otherwise, one array is a proper prefix of the other and, lexicographic
* comparison is the result of comparing the two range lengths.
* (See {@link #mismatch(byte[], int, int, byte[], int, int)} for the
* definition of a common and proper prefix.)
*
* @apiNote
*
This method behaves as if:
*
{@code
* int i = Arrays.mismatch(a, aFromIndex, aToIndex,
* b, bFromIndex, bToIndex);
* if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
* return Byte.compareUnsigned(a[aFromIndex + i], b[bFromIndex + i]);
* return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
* }
*
* @param a the first array to compare
* @param aFromIndex the index (inclusive) of the first element in the
* first array to be compared
* @param aToIndex the index (exclusive) of the last element in the
* first array to be compared
* @param b the second array to compare
* @param bFromIndex the index (inclusive) of the first element in the
* second array to be compared
* @param bToIndex the index (exclusive) of the last element in the
* second array to be compared
* @return the value {@code 0} if, over the specified ranges, the first and
* second array are equal and contain the same elements in the same
* order;
* a value less than {@code 0} if, over the specified ranges, the
* first array is lexicographically less than the second array; and
* a value greater than {@code 0} if, over the specified ranges, the
* first array is lexicographically greater than the second array
* @throws IllegalArgumentException
* if {@code aFromIndex > aToIndex} or
* if {@code bFromIndex > bToIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code aFromIndex < 0 or aToIndex > a.length} or
* if {@code bFromIndex < 0 or bToIndex > b.length}
* @throws NullPointerException
* if either array is null
* @since 9
*/
public static int compareUnsigned(byte[] a, int aFromIndex, int aToIndex,
byte[] b, int bFromIndex, int bToIndex) {
rangeCheck(a.length, aFromIndex, aToIndex);
rangeCheck(b.length, bFromIndex, bToIndex);
int aLength = aToIndex - aFromIndex;
int bLength = bToIndex - bFromIndex;
int i = ArraysSupport.mismatch(a, aFromIndex,
b, bFromIndex,
Math.min(aLength, bLength));
if (i >= 0) {
return Byte.compareUnsigned(a[aFromIndex + i], b[bFromIndex + i]);
}
return aLength - bLength;
}
// Compare short
/**
* Compares two {@code short} arrays lexicographically.
*
* If the two arrays share a common prefix then the lexicographic
* comparison is the result of comparing two elements, as if by
* {@link Short#compare(short, short)}, at an index within the respective
* arrays that is the prefix length.
* Otherwise, one array is a proper prefix of the other and, lexicographic
* comparison is the result of comparing the two array lengths.
* (See {@link #mismatch(short[], short[])} for the definition of a common
* and proper prefix.)
*
*
A {@code null} array reference is considered lexicographically less
* than a non-{@code null} array reference. Two {@code null} array
* references are considered equal.
*
*
The comparison is consistent with {@link #equals(short[], short[]) equals},
* more specifically the following holds for arrays {@code a} and {@code b}:
*
{@code
* Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
* }
*
* @apiNote
* This method behaves as if (for non-{@code null} array references):
*
{@code
* int i = Arrays.mismatch(a, b);
* if (i >= 0 && i < Math.min(a.length, b.length))
* return Short.compare(a[i], b[i]);
* return a.length - b.length;
* }
*
* @param a the first array to compare
* @param b the second array to compare
* @return the value {@code 0} if the first and second array are equal and
* contain the same elements in the same order;
* a value less than {@code 0} if the first array is
* lexicographically less than the second array; and
* a value greater than {@code 0} if the first array is
* lexicographically greater than the second array
* @since 9
*/
public static int compare(short[] a, short[] b) {
if (a == b)
return 0;
if (a == null || b == null)
return a == null ? -1 : 1;
int i = ArraysSupport.mismatch(a, b,
Math.min(a.length, b.length));
if (i >= 0) {
return Short.compare(a[i], b[i]);
}
return a.length - b.length;
}
/**
* Compares two {@code short} arrays lexicographically over the specified
* ranges.
*
* If the two arrays, over the specified ranges, share a common prefix
* then the lexicographic comparison is the result of comparing two
* elements, as if by {@link Short#compare(short, short)}, at a relative
* index within the respective arrays that is the length of the prefix.
* Otherwise, one array is a proper prefix of the other and, lexicographic
* comparison is the result of comparing the two range lengths.
* (See {@link #mismatch(short[], int, int, short[], int, int)} for the
* definition of a common and proper prefix.)
*
*
The comparison is consistent with
* {@link #equals(short[], int, int, short[], int, int) equals}, more
* specifically the following holds for arrays {@code a} and {@code b} with
* specified ranges [{@code aFromIndex}, {@code atoIndex}) and
* [{@code bFromIndex}, {@code btoIndex}) respectively:
*
{@code
* Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
* (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
* }
*
* @apiNote
* This method behaves as if:
*
{@code
* int i = Arrays.mismatch(a, aFromIndex, aToIndex,
* b, bFromIndex, bToIndex);
* if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
* return Short.compare(a[aFromIndex + i], b[bFromIndex + i]);
* return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
* }
*
* @param a the first array to compare
* @param aFromIndex the index (inclusive) of the first element in the
* first array to be compared
* @param aToIndex the index (exclusive) of the last element in the
* first array to be compared
* @param b the second array to compare
* @param bFromIndex the index (inclusive) of the first element in the
* second array to be compared
* @param bToIndex the index (exclusive) of the last element in the
* second array to be compared
* @return the value {@code 0} if, over the specified ranges, the first and
* second array are equal and contain the same elements in the same
* order;
* a value less than {@code 0} if, over the specified ranges, the
* first array is lexicographically less than the second array; and
* a value greater than {@code 0} if, over the specified ranges, the
* first array is lexicographically greater than the second array
* @throws IllegalArgumentException
* if {@code aFromIndex > aToIndex} or
* if {@code bFromIndex > bToIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code aFromIndex < 0 or aToIndex > a.length} or
* if {@code bFromIndex < 0 or bToIndex > b.length}
* @throws NullPointerException
* if either array is {@code null}
* @since 9
*/
public static int compare(short[] a, int aFromIndex, int aToIndex,
short[] b, int bFromIndex, int bToIndex) {
rangeCheck(a.length, aFromIndex, aToIndex);
rangeCheck(b.length, bFromIndex, bToIndex);
int aLength = aToIndex - aFromIndex;
int bLength = bToIndex - bFromIndex;
int i = ArraysSupport.mismatch(a, aFromIndex,
b, bFromIndex,
Math.min(aLength, bLength));
if (i >= 0) {
return Short.compare(a[aFromIndex + i], b[bFromIndex + i]);
}
return aLength - bLength;
}
/**
* Compares two {@code short} arrays lexicographically, numerically treating
* elements as unsigned.
*
* If the two arrays share a common prefix then the lexicographic
* comparison is the result of comparing two elements, as if by
* {@link Short#compareUnsigned(short, short)}, at an index within the
* respective arrays that is the prefix length.
* Otherwise, one array is a proper prefix of the other and, lexicographic
* comparison is the result of comparing the two array lengths.
* (See {@link #mismatch(short[], short[])} for the definition of a common
* and proper prefix.)
*
*
A {@code null} array reference is considered lexicographically less
* than a non-{@code null} array reference. Two {@code null} array
* references are considered equal.
*
* @apiNote
*
This method behaves as if (for non-{@code null} array references):
*
{@code
* int i = Arrays.mismatch(a, b);
* if (i >= 0 && i < Math.min(a.length, b.length))
* return Short.compareUnsigned(a[i], b[i]);
* return a.length - b.length;
* }
*
* @param a the first array to compare
* @param b the second array to compare
* @return the value {@code 0} if the first and second array are
* equal and contain the same elements in the same order;
* a value less than {@code 0} if the first array is
* lexicographically less than the second array; and
* a value greater than {@code 0} if the first array is
* lexicographically greater than the second array
* @since 9
*/
public static int compareUnsigned(short[] a, short[] b) {
if (a == b)
return 0;
if (a == null || b == null)
return a == null ? -1 : 1;
int i = ArraysSupport.mismatch(a, b,
Math.min(a.length, b.length));
if (i >= 0) {
return Short.compareUnsigned(a[i], b[i]);
}
return a.length - b.length;
}
/**
* Compares two {@code short} arrays lexicographically over the specified
* ranges, numerically treating elements as unsigned.
*
* If the two arrays, over the specified ranges, share a common prefix
* then the lexicographic comparison is the result of comparing two
* elements, as if by {@link Short#compareUnsigned(short, short)}, at a
* relative index within the respective arrays that is the length of the
* prefix.
* Otherwise, one array is a proper prefix of the other and, lexicographic
* comparison is the result of comparing the two range lengths.
* (See {@link #mismatch(short[], int, int, short[], int, int)} for the
* definition of a common and proper prefix.)
*
* @apiNote
*
This method behaves as if:
*
{@code
* int i = Arrays.mismatch(a, aFromIndex, aToIndex,
* b, bFromIndex, bToIndex);
* if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
* return Short.compareUnsigned(a[aFromIndex + i], b[bFromIndex + i]);
* return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
* }
*
* @param a the first array to compare
* @param aFromIndex the index (inclusive) of the first element in the
* first array to be compared
* @param aToIndex the index (exclusive) of the last element in the
* first array to be compared
* @param b the second array to compare
* @param bFromIndex the index (inclusive) of the first element in the
* second array to be compared
* @param bToIndex the index (exclusive) of the last element in the
* second array to be compared
* @return the value {@code 0} if, over the specified ranges, the first and
* second array are equal and contain the same elements in the same
* order;
* a value less than {@code 0} if, over the specified ranges, the
* first array is lexicographically less than the second array; and
* a value greater than {@code 0} if, over the specified ranges, the
* first array is lexicographically greater than the second array
* @throws IllegalArgumentException
* if {@code aFromIndex > aToIndex} or
* if {@code bFromIndex > bToIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code aFromIndex < 0 or aToIndex > a.length} or
* if {@code bFromIndex < 0 or bToIndex > b.length}
* @throws NullPointerException
* if either array is null
* @since 9
*/
public static int compareUnsigned(short[] a, int aFromIndex, int aToIndex,
short[] b, int bFromIndex, int bToIndex) {
rangeCheck(a.length, aFromIndex, aToIndex);
rangeCheck(b.length, bFromIndex, bToIndex);
int aLength = aToIndex - aFromIndex;
int bLength = bToIndex - bFromIndex;
int i = ArraysSupport.mismatch(a, aFromIndex,
b, bFromIndex,
Math.min(aLength, bLength));
if (i >= 0) {
return Short.compareUnsigned(a[aFromIndex + i], b[bFromIndex + i]);
}
return aLength - bLength;
}
// Compare char
/**
* Compares two {@code char} arrays lexicographically.
*
* If the two arrays share a common prefix then the lexicographic
* comparison is the result of comparing two elements, as if by
* {@link Character#compare(char, char)}, at an index within the respective
* arrays that is the prefix length.
* Otherwise, one array is a proper prefix of the other and, lexicographic
* comparison is the result of comparing the two array lengths.
* (See {@link #mismatch(char[], char[])} for the definition of a common and
* proper prefix.)
*
*
A {@code null} array reference is considered lexicographically less
* than a non-{@code null} array reference. Two {@code null} array
* references are considered equal.
*
*
The comparison is consistent with {@link #equals(char[], char[]) equals},
* more specifically the following holds for arrays {@code a} and {@code b}:
*
{@code
* Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
* }
*
* @apiNote
* This method behaves as if (for non-{@code null} array references):
*
{@code
* int i = Arrays.mismatch(a, b);
* if (i >= 0 && i < Math.min(a.length, b.length))
* return Character.compare(a[i], b[i]);
* return a.length - b.length;
* }
*
* @param a the first array to compare
* @param b the second array to compare
* @return the value {@code 0} if the first and second array are equal and
* contain the same elements in the same order;
* a value less than {@code 0} if the first array is
* lexicographically less than the second array; and
* a value greater than {@code 0} if the first array is
* lexicographically greater than the second array
* @since 9
*/
public static int compare(char[] a, char[] b) {
if (a == b)
return 0;
if (a == null || b == null)
return a == null ? -1 : 1;
int i = ArraysSupport.mismatch(a, b,
Math.min(a.length, b.length));
if (i >= 0) {
return Character.compare(a[i], b[i]);
}
return a.length - b.length;
}
/**
* Compares two {@code char} arrays lexicographically over the specified
* ranges.
*
* If the two arrays, over the specified ranges, share a common prefix
* then the lexicographic comparison is the result of comparing two
* elements, as if by {@link Character#compare(char, char)}, at a relative
* index within the respective arrays that is the length of the prefix.
* Otherwise, one array is a proper prefix of the other and, lexicographic
* comparison is the result of comparing the two range lengths.
* (See {@link #mismatch(char[], int, int, char[], int, int)} for the
* definition of a common and proper prefix.)
*
*
The comparison is consistent with
* {@link #equals(char[], int, int, char[], int, int) equals}, more
* specifically the following holds for arrays {@code a} and {@code b} with
* specified ranges [{@code aFromIndex}, {@code atoIndex}) and
* [{@code bFromIndex}, {@code btoIndex}) respectively:
*
{@code
* Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
* (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
* }
*
* @apiNote
* This method behaves as if:
*
{@code
* int i = Arrays.mismatch(a, aFromIndex, aToIndex,
* b, bFromIndex, bToIndex);
* if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
* return Character.compare(a[aFromIndex + i], b[bFromIndex + i]);
* return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
* }
*
* @param a the first array to compare
* @param aFromIndex the index (inclusive) of the first element in the
* first array to be compared
* @param aToIndex the index (exclusive) of the last element in the
* first array to be compared
* @param b the second array to compare
* @param bFromIndex the index (inclusive) of the first element in the
* second array to be compared
* @param bToIndex the index (exclusive) of the last element in the
* second array to be compared
* @return the value {@code 0} if, over the specified ranges, the first and
* second array are equal and contain the same elements in the same
* order;
* a value less than {@code 0} if, over the specified ranges, the
* first array is lexicographically less than the second array; and
* a value greater than {@code 0} if, over the specified ranges, the
* first array is lexicographically greater than the second array
* @throws IllegalArgumentException
* if {@code aFromIndex > aToIndex} or
* if {@code bFromIndex > bToIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code aFromIndex < 0 or aToIndex > a.length} or
* if {@code bFromIndex < 0 or bToIndex > b.length}
* @throws NullPointerException
* if either array is {@code null}
* @since 9
*/
public static int compare(char[] a, int aFromIndex, int aToIndex,
char[] b, int bFromIndex, int bToIndex) {
rangeCheck(a.length, aFromIndex, aToIndex);
rangeCheck(b.length, bFromIndex, bToIndex);
int aLength = aToIndex - aFromIndex;
int bLength = bToIndex - bFromIndex;
int i = ArraysSupport.mismatch(a, aFromIndex,
b, bFromIndex,
Math.min(aLength, bLength));
if (i >= 0) {
return Character.compare(a[aFromIndex + i], b[bFromIndex + i]);
}
return aLength - bLength;
}
// Compare int
/**
* Compares two {@code int} arrays lexicographically.
*
* If the two arrays share a common prefix then the lexicographic
* comparison is the result of comparing two elements, as if by
* {@link Integer#compare(int, int)}, at an index within the respective
* arrays that is the prefix length.
* Otherwise, one array is a proper prefix of the other and, lexicographic
* comparison is the result of comparing the two array lengths.
* (See {@link #mismatch(int[], int[])} for the definition of a common and
* proper prefix.)
*
*
A {@code null} array reference is considered lexicographically less
* than a non-{@code null} array reference. Two {@code null} array
* references are considered equal.
*
*
The comparison is consistent with {@link #equals(int[], int[]) equals},
* more specifically the following holds for arrays {@code a} and {@code b}:
*
{@code
* Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
* }
*
* @apiNote
* This method behaves as if (for non-{@code null} array references):
*
{@code
* int i = Arrays.mismatch(a, b);
* if (i >= 0 && i < Math.min(a.length, b.length))
* return Integer.compare(a[i], b[i]);
* return a.length - b.length;
* }
*
* @param a the first array to compare
* @param b the second array to compare
* @return the value {@code 0} if the first and second array are equal and
* contain the same elements in the same order;
* a value less than {@code 0} if the first array is
* lexicographically less than the second array; and
* a value greater than {@code 0} if the first array is
* lexicographically greater than the second array
* @since 9
*/
public static int compare(int[] a, int[] b) {
if (a == b)
return 0;
if (a == null || b == null)
return a == null ? -1 : 1;
int i = ArraysSupport.mismatch(a, b,
Math.min(a.length, b.length));
if (i >= 0) {
return Integer.compare(a[i], b[i]);
}
return a.length - b.length;
}
/**
* Compares two {@code int} arrays lexicographically over the specified
* ranges.
*
* If the two arrays, over the specified ranges, share a common prefix
* then the lexicographic comparison is the result of comparing two
* elements, as if by {@link Integer#compare(int, int)}, at a relative index
* within the respective arrays that is the length of the prefix.
* Otherwise, one array is a proper prefix of the other and, lexicographic
* comparison is the result of comparing the two range lengths.
* (See {@link #mismatch(int[], int, int, int[], int, int)} for the
* definition of a common and proper prefix.)
*
*
The comparison is consistent with
* {@link #equals(int[], int, int, int[], int, int) equals}, more
* specifically the following holds for arrays {@code a} and {@code b} with
* specified ranges [{@code aFromIndex}, {@code atoIndex}) and
* [{@code bFromIndex}, {@code btoIndex}) respectively:
*
{@code
* Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
* (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
* }
*
* @apiNote
* This method behaves as if:
*
{@code
* int i = Arrays.mismatch(a, aFromIndex, aToIndex,
* b, bFromIndex, bToIndex);
* if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
* return Integer.compare(a[aFromIndex + i], b[bFromIndex + i]);
* return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
* }
*
* @param a the first array to compare
* @param aFromIndex the index (inclusive) of the first element in the
* first array to be compared
* @param aToIndex the index (exclusive) of the last element in the
* first array to be compared
* @param b the second array to compare
* @param bFromIndex the index (inclusive) of the first element in the
* second array to be compared
* @param bToIndex the index (exclusive) of the last element in the
* second array to be compared
* @return the value {@code 0} if, over the specified ranges, the first and
* second array are equal and contain the same elements in the same
* order;
* a value less than {@code 0} if, over the specified ranges, the
* first array is lexicographically less than the second array; and
* a value greater than {@code 0} if, over the specified ranges, the
* first array is lexicographically greater than the second array
* @throws IllegalArgumentException
* if {@code aFromIndex > aToIndex} or
* if {@code bFromIndex > bToIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code aFromIndex < 0 or aToIndex > a.length} or
* if {@code bFromIndex < 0 or bToIndex > b.length}
* @throws NullPointerException
* if either array is {@code null}
* @since 9
*/
public static int compare(int[] a, int aFromIndex, int aToIndex,
int[] b, int bFromIndex, int bToIndex) {
rangeCheck(a.length, aFromIndex, aToIndex);
rangeCheck(b.length, bFromIndex, bToIndex);
int aLength = aToIndex - aFromIndex;
int bLength = bToIndex - bFromIndex;
int i = ArraysSupport.mismatch(a, aFromIndex,
b, bFromIndex,
Math.min(aLength, bLength));
if (i >= 0) {
return Integer.compare(a[aFromIndex + i], b[bFromIndex + i]);
}
return aLength - bLength;
}
/**
* Compares two {@code int} arrays lexicographically, numerically treating
* elements as unsigned.
*
* If the two arrays share a common prefix then the lexicographic
* comparison is the result of comparing two elements, as if by
* {@link Integer#compareUnsigned(int, int)}, at an index within the
* respective arrays that is the prefix length.
* Otherwise, one array is a proper prefix of the other and, lexicographic
* comparison is the result of comparing the two array lengths.
* (See {@link #mismatch(int[], int[])} for the definition of a common
* and proper prefix.)
*
*
A {@code null} array reference is considered lexicographically less
* than a non-{@code null} array reference. Two {@code null} array
* references are considered equal.
*
* @apiNote
*
This method behaves as if (for non-{@code null} array references):
*
{@code
* int i = Arrays.mismatch(a, b);
* if (i >= 0 && i < Math.min(a.length, b.length))
* return Integer.compareUnsigned(a[i], b[i]);
* return a.length - b.length;
* }
*
* @param a the first array to compare
* @param b the second array to compare
* @return the value {@code 0} if the first and second array are
* equal and contain the same elements in the same order;
* a value less than {@code 0} if the first array is
* lexicographically less than the second array; and
* a value greater than {@code 0} if the first array is
* lexicographically greater than the second array
* @since 9
*/
public static int compareUnsigned(int[] a, int[] b) {
if (a == b)
return 0;
if (a == null || b == null)
return a == null ? -1 : 1;
int i = ArraysSupport.mismatch(a, b,
Math.min(a.length, b.length));
if (i >= 0) {
return Integer.compareUnsigned(a[i], b[i]);
}
return a.length - b.length;
}
/**
* Compares two {@code int} arrays lexicographically over the specified
* ranges, numerically treating elements as unsigned.
*
* If the two arrays, over the specified ranges, share a common prefix
* then the lexicographic comparison is the result of comparing two
* elements, as if by {@link Integer#compareUnsigned(int, int)}, at a
* relative index within the respective arrays that is the length of the
* prefix.
* Otherwise, one array is a proper prefix of the other and, lexicographic
* comparison is the result of comparing the two range lengths.
* (See {@link #mismatch(int[], int, int, int[], int, int)} for the
* definition of a common and proper prefix.)
*
* @apiNote
*
This method behaves as if:
*
{@code
* int i = Arrays.mismatch(a, aFromIndex, aToIndex,
* b, bFromIndex, bToIndex);
* if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
* return Integer.compareUnsigned(a[aFromIndex + i], b[bFromIndex + i]);
* return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
* }
*
* @param a the first array to compare
* @param aFromIndex the index (inclusive) of the first element in the
* first array to be compared
* @param aToIndex the index (exclusive) of the last element in the
* first array to be compared
* @param b the second array to compare
* @param bFromIndex the index (inclusive) of the first element in the
* second array to be compared
* @param bToIndex the index (exclusive) of the last element in the
* second array to be compared
* @return the value {@code 0} if, over the specified ranges, the first and
* second array are equal and contain the same elements in the same
* order;
* a value less than {@code 0} if, over the specified ranges, the
* first array is lexicographically less than the second array; and
* a value greater than {@code 0} if, over the specified ranges, the
* first array is lexicographically greater than the second array
* @throws IllegalArgumentException
* if {@code aFromIndex > aToIndex} or
* if {@code bFromIndex > bToIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code aFromIndex < 0 or aToIndex > a.length} or
* if {@code bFromIndex < 0 or bToIndex > b.length}
* @throws NullPointerException
* if either array is null
* @since 9
*/
public static int compareUnsigned(int[] a, int aFromIndex, int aToIndex,
int[] b, int bFromIndex, int bToIndex) {
rangeCheck(a.length, aFromIndex, aToIndex);
rangeCheck(b.length, bFromIndex, bToIndex);
int aLength = aToIndex - aFromIndex;
int bLength = bToIndex - bFromIndex;
int i = ArraysSupport.mismatch(a, aFromIndex,
b, bFromIndex,
Math.min(aLength, bLength));
if (i >= 0) {
return Integer.compareUnsigned(a[aFromIndex + i], b[bFromIndex + i]);
}
return aLength - bLength;
}
// Compare long
/**
* Compares two {@code long} arrays lexicographically.
*
* If the two arrays share a common prefix then the lexicographic
* comparison is the result of comparing two elements, as if by
* {@link Long#compare(long, long)}, at an index within the respective
* arrays that is the prefix length.
* Otherwise, one array is a proper prefix of the other and, lexicographic
* comparison is the result of comparing the two array lengths.
* (See {@link #mismatch(long[], long[])} for the definition of a common and
* proper prefix.)
*
*
A {@code null} array reference is considered lexicographically less
* than a non-{@code null} array reference. Two {@code null} array
* references are considered equal.
*
*
The comparison is consistent with {@link #equals(long[], long[]) equals},
* more specifically the following holds for arrays {@code a} and {@code b}:
*
{@code
* Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
* }
*
* @apiNote
* This method behaves as if (for non-{@code null} array references):
*
{@code
* int i = Arrays.mismatch(a, b);
* if (i >= 0 && i < Math.min(a.length, b.length))
* return Long.compare(a[i], b[i]);
* return a.length - b.length;
* }
*
* @param a the first array to compare
* @param b the second array to compare
* @return the value {@code 0} if the first and second array are equal and
* contain the same elements in the same order;
* a value less than {@code 0} if the first array is
* lexicographically less than the second array; and
* a value greater than {@code 0} if the first array is
* lexicographically greater than the second array
* @since 9
*/
public static int compare(long[] a, long[] b) {
if (a == b)
return 0;
if (a == null || b == null)
return a == null ? -1 : 1;
int i = ArraysSupport.mismatch(a, b,
Math.min(a.length, b.length));
if (i >= 0) {
return Long.compare(a[i], b[i]);
}
return a.length - b.length;
}
/**
* Compares two {@code long} arrays lexicographically over the specified
* ranges.
*
* If the two arrays, over the specified ranges, share a common prefix
* then the lexicographic comparison is the result of comparing two
* elements, as if by {@link Long#compare(long, long)}, at a relative index
* within the respective arrays that is the length of the prefix.
* Otherwise, one array is a proper prefix of the other and, lexicographic
* comparison is the result of comparing the two range lengths.
* (See {@link #mismatch(long[], int, int, long[], int, int)} for the
* definition of a common and proper prefix.)
*
*
The comparison is consistent with
* {@link #equals(long[], int, int, long[], int, int) equals}, more
* specifically the following holds for arrays {@code a} and {@code b} with
* specified ranges [{@code aFromIndex}, {@code atoIndex}) and
* [{@code bFromIndex}, {@code btoIndex}) respectively:
*
{@code
* Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
* (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
* }
*
* @apiNote
* This method behaves as if:
*
{@code
* int i = Arrays.mismatch(a, aFromIndex, aToIndex,
* b, bFromIndex, bToIndex);
* if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
* return Long.compare(a[aFromIndex + i], b[bFromIndex + i]);
* return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
* }
*
* @param a the first array to compare
* @param aFromIndex the index (inclusive) of the first element in the
* first array to be compared
* @param aToIndex the index (exclusive) of the last element in the
* first array to be compared
* @param b the second array to compare
* @param bFromIndex the index (inclusive) of the first element in the
* second array to be compared
* @param bToIndex the index (exclusive) of the last element in the
* second array to be compared
* @return the value {@code 0} if, over the specified ranges, the first and
* second array are equal and contain the same elements in the same
* order;
* a value less than {@code 0} if, over the specified ranges, the
* first array is lexicographically less than the second array; and
* a value greater than {@code 0} if, over the specified ranges, the
* first array is lexicographically greater than the second array
* @throws IllegalArgumentException
* if {@code aFromIndex > aToIndex} or
* if {@code bFromIndex > bToIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code aFromIndex < 0 or aToIndex > a.length} or
* if {@code bFromIndex < 0 or bToIndex > b.length}
* @throws NullPointerException
* if either array is {@code null}
* @since 9
*/
public static int compare(long[] a, int aFromIndex, int aToIndex,
long[] b, int bFromIndex, int bToIndex) {
rangeCheck(a.length, aFromIndex, aToIndex);
rangeCheck(b.length, bFromIndex, bToIndex);
int aLength = aToIndex - aFromIndex;
int bLength = bToIndex - bFromIndex;
int i = ArraysSupport.mismatch(a, aFromIndex,
b, bFromIndex,
Math.min(aLength, bLength));
if (i >= 0) {
return Long.compare(a[aFromIndex + i], b[bFromIndex + i]);
}
return aLength - bLength;
}
/**
* Compares two {@code long} arrays lexicographically, numerically treating
* elements as unsigned.
*
* If the two arrays share a common prefix then the lexicographic
* comparison is the result of comparing two elements, as if by
* {@link Long#compareUnsigned(long, long)}, at an index within the
* respective arrays that is the prefix length.
* Otherwise, one array is a proper prefix of the other and, lexicographic
* comparison is the result of comparing the two array lengths.
* (See {@link #mismatch(long[], long[])} for the definition of a common
* and proper prefix.)
*
*
A {@code null} array reference is considered lexicographically less
* than a non-{@code null} array reference. Two {@code null} array
* references are considered equal.
*
* @apiNote
*
This method behaves as if (for non-{@code null} array references):
*
{@code
* int i = Arrays.mismatch(a, b);
* if (i >= 0 && i < Math.min(a.length, b.length))
* return Long.compareUnsigned(a[i], b[i]);
* return a.length - b.length;
* }
*
* @param a the first array to compare
* @param b the second array to compare
* @return the value {@code 0} if the first and second array are
* equal and contain the same elements in the same order;
* a value less than {@code 0} if the first array is
* lexicographically less than the second array; and
* a value greater than {@code 0} if the first array is
* lexicographically greater than the second array
* @since 9
*/
public static int compareUnsigned(long[] a, long[] b) {
if (a == b)
return 0;
if (a == null || b == null)
return a == null ? -1 : 1;
int i = ArraysSupport.mismatch(a, b,
Math.min(a.length, b.length));
if (i >= 0) {
return Long.compareUnsigned(a[i], b[i]);
}
return a.length - b.length;
}
/**
* Compares two {@code long} arrays lexicographically over the specified
* ranges, numerically treating elements as unsigned.
*
* If the two arrays, over the specified ranges, share a common prefix
* then the lexicographic comparison is the result of comparing two
* elements, as if by {@link Long#compareUnsigned(long, long)}, at a
* relative index within the respective arrays that is the length of the
* prefix.
* Otherwise, one array is a proper prefix of the other and, lexicographic
* comparison is the result of comparing the two range lengths.
* (See {@link #mismatch(long[], int, int, long[], int, int)} for the
* definition of a common and proper prefix.)
*
* @apiNote
*
This method behaves as if:
*
{@code
* int i = Arrays.mismatch(a, aFromIndex, aToIndex,
* b, bFromIndex, bToIndex);
* if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
* return Long.compareUnsigned(a[aFromIndex + i], b[bFromIndex + i]);
* return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
* }
*
* @param a the first array to compare
* @param aFromIndex the index (inclusive) of the first element in the
* first array to be compared
* @param aToIndex the index (exclusive) of the last element in the
* first array to be compared
* @param b the second array to compare
* @param bFromIndex the index (inclusive) of the first element in the
* second array to be compared
* @param bToIndex the index (exclusive) of the last element in the
* second array to be compared
* @return the value {@code 0} if, over the specified ranges, the first and
* second array are equal and contain the same elements in the same
* order;
* a value less than {@code 0} if, over the specified ranges, the
* first array is lexicographically less than the second array; and
* a value greater than {@code 0} if, over the specified ranges, the
* first array is lexicographically greater than the second array
* @throws IllegalArgumentException
* if {@code aFromIndex > aToIndex} or
* if {@code bFromIndex > bToIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code aFromIndex < 0 or aToIndex > a.length} or
* if {@code bFromIndex < 0 or bToIndex > b.length}
* @throws NullPointerException
* if either array is null
* @since 9
*/
public static int compareUnsigned(long[] a, int aFromIndex, int aToIndex,
long[] b, int bFromIndex, int bToIndex) {
rangeCheck(a.length, aFromIndex, aToIndex);
rangeCheck(b.length, bFromIndex, bToIndex);
int aLength = aToIndex - aFromIndex;
int bLength = bToIndex - bFromIndex;
int i = ArraysSupport.mismatch(a, aFromIndex,
b, bFromIndex,
Math.min(aLength, bLength));
if (i >= 0) {
return Long.compareUnsigned(a[aFromIndex + i], b[bFromIndex + i]);
}
return aLength - bLength;
}
// Compare float
/**
* Compares two {@code float} arrays lexicographically.
*
* If the two arrays share a common prefix then the lexicographic
* comparison is the result of comparing two elements, as if by
* {@link Float#compare(float, float)}, at an index within the respective
* arrays that is the prefix length.
* Otherwise, one array is a proper prefix of the other and, lexicographic
* comparison is the result of comparing the two array lengths.
* (See {@link #mismatch(float[], float[])} for the definition of a common
* and proper prefix.)
*
*
A {@code null} array reference is considered lexicographically less
* than a non-{@code null} array reference. Two {@code null} array
* references are considered equal.
*
*
The comparison is consistent with {@link #equals(float[], float[]) equals},
* more specifically the following holds for arrays {@code a} and {@code b}:
*
{@code
* Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
* }
*
* @apiNote
* This method behaves as if (for non-{@code null} array references):
*
{@code
* int i = Arrays.mismatch(a, b);
* if (i >= 0 && i < Math.min(a.length, b.length))
* return Float.compare(a[i], b[i]);
* return a.length - b.length;
* }
*
* @param a the first array to compare
* @param b the second array to compare
* @return the value {@code 0} if the first and second array are equal and
* contain the same elements in the same order;
* a value less than {@code 0} if the first array is
* lexicographically less than the second array; and
* a value greater than {@code 0} if the first array is
* lexicographically greater than the second array
* @since 9
*/
public static int compare(float[] a, float[] b) {
if (a == b)
return 0;
if (a == null || b == null)
return a == null ? -1 : 1;
int i = ArraysSupport.mismatch(a, b,
Math.min(a.length, b.length));
if (i >= 0) {
return Float.compare(a[i], b[i]);
}
return a.length - b.length;
}
/**
* Compares two {@code float} arrays lexicographically over the specified
* ranges.
*
* If the two arrays, over the specified ranges, share a common prefix
* then the lexicographic comparison is the result of comparing two
* elements, as if by {@link Float#compare(float, float)}, at a relative
* index within the respective arrays that is the length of the prefix.
* Otherwise, one array is a proper prefix of the other and, lexicographic
* comparison is the result of comparing the two range lengths.
* (See {@link #mismatch(float[], int, int, float[], int, int)} for the
* definition of a common and proper prefix.)
*
*
The comparison is consistent with
* {@link #equals(float[], int, int, float[], int, int) equals}, more
* specifically the following holds for arrays {@code a} and {@code b} with
* specified ranges [{@code aFromIndex}, {@code atoIndex}) and
* [{@code bFromIndex}, {@code btoIndex}) respectively:
*
{@code
* Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
* (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
* }
*
* @apiNote
* This method behaves as if:
*
{@code
* int i = Arrays.mismatch(a, aFromIndex, aToIndex,
* b, bFromIndex, bToIndex);
* if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
* return Float.compare(a[aFromIndex + i], b[bFromIndex + i]);
* return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
* }
*
* @param a the first array to compare
* @param aFromIndex the index (inclusive) of the first element in the
* first array to be compared
* @param aToIndex the index (exclusive) of the last element in the
* first array to be compared
* @param b the second array to compare
* @param bFromIndex the index (inclusive) of the first element in the
* second array to be compared
* @param bToIndex the index (exclusive) of the last element in the
* second array to be compared
* @return the value {@code 0} if, over the specified ranges, the first and
* second array are equal and contain the same elements in the same
* order;
* a value less than {@code 0} if, over the specified ranges, the
* first array is lexicographically less than the second array; and
* a value greater than {@code 0} if, over the specified ranges, the
* first array is lexicographically greater than the second array
* @throws IllegalArgumentException
* if {@code aFromIndex > aToIndex} or
* if {@code bFromIndex > bToIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code aFromIndex < 0 or aToIndex > a.length} or
* if {@code bFromIndex < 0 or bToIndex > b.length}
* @throws NullPointerException
* if either array is {@code null}
* @since 9
*/
public static int compare(float[] a, int aFromIndex, int aToIndex,
float[] b, int bFromIndex, int bToIndex) {
rangeCheck(a.length, aFromIndex, aToIndex);
rangeCheck(b.length, bFromIndex, bToIndex);
int aLength = aToIndex - aFromIndex;
int bLength = bToIndex - bFromIndex;
int i = ArraysSupport.mismatch(a, aFromIndex,
b, bFromIndex,
Math.min(aLength, bLength));
if (i >= 0) {
return Float.compare(a[aFromIndex + i], b[bFromIndex + i]);
}
return aLength - bLength;
}
// Compare double
/**
* Compares two {@code double} arrays lexicographically.
*
* If the two arrays share a common prefix then the lexicographic
* comparison is the result of comparing two elements, as if by
* {@link Double#compare(double, double)}, at an index within the respective
* arrays that is the prefix length.
* Otherwise, one array is a proper prefix of the other and, lexicographic
* comparison is the result of comparing the two array lengths.
* (See {@link #mismatch(double[], double[])} for the definition of a common
* and proper prefix.)
*
*
A {@code null} array reference is considered lexicographically less
* than a non-{@code null} array reference. Two {@code null} array
* references are considered equal.
*
*
The comparison is consistent with {@link #equals(double[], double[]) equals},
* more specifically the following holds for arrays {@code a} and {@code b}:
*
{@code
* Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
* }
*
* @apiNote
* This method behaves as if (for non-{@code null} array references):
*
{@code
* int i = Arrays.mismatch(a, b);
* if (i >= 0 && i < Math.min(a.length, b.length))
* return Double.compare(a[i], b[i]);
* return a.length - b.length;
* }
*
* @param a the first array to compare
* @param b the second array to compare
* @return the value {@code 0} if the first and second array are equal and
* contain the same elements in the same order;
* a value less than {@code 0} if the first array is
* lexicographically less than the second array; and
* a value greater than {@code 0} if the first array is
* lexicographically greater than the second array
* @since 9
*/
public static int compare(double[] a, double[] b) {
if (a == b)
return 0;
if (a == null || b == null)
return a == null ? -1 : 1;
int i = ArraysSupport.mismatch(a, b,
Math.min(a.length, b.length));
if (i >= 0) {
return Double.compare(a[i], b[i]);
}
return a.length - b.length;
}
/**
* Compares two {@code double} arrays lexicographically over the specified
* ranges.
*
* If the two arrays, over the specified ranges, share a common prefix
* then the lexicographic comparison is the result of comparing two
* elements, as if by {@link Double#compare(double, double)}, at a relative
* index within the respective arrays that is the length of the prefix.
* Otherwise, one array is a proper prefix of the other and, lexicographic
* comparison is the result of comparing the two range lengths.
* (See {@link #mismatch(double[], int, int, double[], int, int)} for the
* definition of a common and proper prefix.)
*
*
The comparison is consistent with
* {@link #equals(double[], int, int, double[], int, int) equals}, more
* specifically the following holds for arrays {@code a} and {@code b} with
* specified ranges [{@code aFromIndex}, {@code atoIndex}) and
* [{@code bFromIndex}, {@code btoIndex}) respectively:
*
{@code
* Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
* (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
* }
*
* @apiNote
* This method behaves as if:
*
{@code
* int i = Arrays.mismatch(a, aFromIndex, aToIndex,
* b, bFromIndex, bToIndex);
* if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
* return Double.compare(a[aFromIndex + i], b[bFromIndex + i]);
* return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
* }
*
* @param a the first array to compare
* @param aFromIndex the index (inclusive) of the first element in the
* first array to be compared
* @param aToIndex the index (exclusive) of the last element in the
* first array to be compared
* @param b the second array to compare
* @param bFromIndex the index (inclusive) of the first element in the
* second array to be compared
* @param bToIndex the index (exclusive) of the last element in the
* second array to be compared
* @return the value {@code 0} if, over the specified ranges, the first and
* second array are equal and contain the same elements in the same
* order;
* a value less than {@code 0} if, over the specified ranges, the
* first array is lexicographically less than the second array; and
* a value greater than {@code 0} if, over the specified ranges, the
* first array is lexicographically greater than the second array
* @throws IllegalArgumentException
* if {@code aFromIndex > aToIndex} or
* if {@code bFromIndex > bToIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code aFromIndex < 0 or aToIndex > a.length} or
* if {@code bFromIndex < 0 or bToIndex > b.length}
* @throws NullPointerException
* if either array is {@code null}
* @since 9
*/
public static int compare(double[] a, int aFromIndex, int aToIndex,
double[] b, int bFromIndex, int bToIndex) {
rangeCheck(a.length, aFromIndex, aToIndex);
rangeCheck(b.length, bFromIndex, bToIndex);
int aLength = aToIndex - aFromIndex;
int bLength = bToIndex - bFromIndex;
int i = ArraysSupport.mismatch(a, aFromIndex,
b, bFromIndex,
Math.min(aLength, bLength));
if (i >= 0) {
return Double.compare(a[aFromIndex + i], b[bFromIndex + i]);
}
return aLength - bLength;
}
// Compare objects
/**
* Compares two {@code Object} arrays, within comparable elements,
* lexicographically.
*
* If the two arrays share a common prefix then the lexicographic
* comparison is the result of comparing two elements of type {@code T} at
* an index {@code i} within the respective arrays that is the prefix
* length, as if by:
*
{@code
* Comparator.nullsFirst(Comparator.naturalOrder()).
* compare(a[i], b[i])
* }
* Otherwise, one array is a proper prefix of the other and, lexicographic
* comparison is the result of comparing the two array lengths.
* (See {@link #mismatch(Object[], Object[])} for the definition of a common
* and proper prefix.)
*
* A {@code null} array reference is considered lexicographically less
* than a non-{@code null} array reference. Two {@code null} array
* references are considered equal.
* A {@code null} array element is considered lexicographically than a
* non-{@code null} array element. Two {@code null} array elements are
* considered equal.
*
*
The comparison is consistent with {@link #equals(Object[], Object[]) equals},
* more specifically the following holds for arrays {@code a} and {@code b}:
*
{@code
* Arrays.equals(a, b) == (Arrays.compare(a, b) == 0)
* }
*
* @apiNote
* This method behaves as if (for non-{@code null} array references
* and elements):
*
{@code
* int i = Arrays.mismatch(a, b);
* if (i >= 0 && i < Math.min(a.length, b.length))
* return a[i].compareTo(b[i]);
* return a.length - b.length;
* }
*
* @param a the first array to compare
* @param b the second array to compare
* @param the type of comparable array elements
* @return the value {@code 0} if the first and second array are equal and
* contain the same elements in the same order;
* a value less than {@code 0} if the first array is
* lexicographically less than the second array; and
* a value greater than {@code 0} if the first array is
* lexicographically greater than the second array
* @since 9
*/
public static > int compare(T[] a, T[] b) {
if (a == b)
return 0;
// A null array is less than a non-null array
if (a == null || b == null)
return a == null ? -1 : 1;
int length = Math.min(a.length, b.length);
for (int i = 0; i < length; i++) {
T oa = a[i];
T ob = b[i];
if (oa != ob) {
// A null element is less than a non-null element
if (oa == null || ob == null)
return oa == null ? -1 : 1;
int v = oa.compareTo(ob);
if (v != 0) {
return v;
}
}
}
return a.length - b.length;
}
/**
* Compares two {@code Object} arrays lexicographically over the specified
* ranges.
*
* If the two arrays, over the specified ranges, share a common prefix
* then the lexicographic comparison is the result of comparing two
* elements of type {@code T} at a relative index {@code i} within the
* respective arrays that is the prefix length, as if by:
*
{@code
* Comparator.nullsFirst(Comparator.naturalOrder()).
* compare(a[aFromIndex + i, b[bFromIndex + i])
* }
* Otherwise, one array is a proper prefix of the other and, lexicographic
* comparison is the result of comparing the two range lengths.
* (See {@link #mismatch(Object[], int, int, Object[], int, int)} for the
* definition of a common and proper prefix.)
*
* The comparison is consistent with
* {@link #equals(Object[], int, int, Object[], int, int) equals}, more
* specifically the following holds for arrays {@code a} and {@code b} with
* specified ranges [{@code aFromIndex}, {@code atoIndex}) and
* [{@code bFromIndex}, {@code btoIndex}) respectively:
*
{@code
* Arrays.equals(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) ==
* (Arrays.compare(a, aFromIndex, aToIndex, b, bFromIndex, bToIndex) == 0)
* }
*
* @apiNote
* This method behaves as if (for non-{@code null} array elements):
*
{@code
* int i = Arrays.mismatch(a, aFromIndex, aToIndex,
* b, bFromIndex, bToIndex);
* if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
* return a[aFromIndex + i].compareTo(b[bFromIndex + i]);
* return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
* }
*
* @param a the first array to compare
* @param aFromIndex the index (inclusive) of the first element in the
* first array to be compared
* @param aToIndex the index (exclusive) of the last element in the
* first array to be compared
* @param b the second array to compare
* @param bFromIndex the index (inclusive) of the first element in the
* second array to be compared
* @param bToIndex the index (exclusive) of the last element in the
* second array to be compared
* @param the type of comparable array elements
* @return the value {@code 0} if, over the specified ranges, the first and
* second array are equal and contain the same elements in the same
* order;
* a value less than {@code 0} if, over the specified ranges, the
* first array is lexicographically less than the second array; and
* a value greater than {@code 0} if, over the specified ranges, the
* first array is lexicographically greater than the second array
* @throws IllegalArgumentException
* if {@code aFromIndex > aToIndex} or
* if {@code bFromIndex > bToIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code aFromIndex < 0 or aToIndex > a.length} or
* if {@code bFromIndex < 0 or bToIndex > b.length}
* @throws NullPointerException
* if either array is {@code null}
* @since 9
*/
public static > int compare(
T[] a, int aFromIndex, int aToIndex,
T[] b, int bFromIndex, int bToIndex) {
rangeCheck(a.length, aFromIndex, aToIndex);
rangeCheck(b.length, bFromIndex, bToIndex);
int aLength = aToIndex - aFromIndex;
int bLength = bToIndex - bFromIndex;
int length = Math.min(aLength, bLength);
for (int i = 0; i < length; i++) {
T oa = a[aFromIndex++];
T ob = b[bFromIndex++];
if (oa != ob) {
if (oa == null || ob == null)
return oa == null ? -1 : 1;
int v = oa.compareTo(ob);
if (v != 0) {
return v;
}
}
}
return aLength - bLength;
}
/**
* Compares two {@code Object} arrays lexicographically using a specified
* comparator.
*
* If the two arrays share a common prefix then the lexicographic
* comparison is the result of comparing with the specified comparator two
* elements at an index within the respective arrays that is the prefix
* length.
* Otherwise, one array is a proper prefix of the other and, lexicographic
* comparison is the result of comparing the two array lengths.
* (See {@link #mismatch(Object[], Object[])} for the definition of a common
* and proper prefix.)
*
*
A {@code null} array reference is considered lexicographically less
* than a non-{@code null} array reference. Two {@code null} array
* references are considered equal.
*
* @apiNote
*
This method behaves as if (for non-{@code null} array references):
*
{@code
* int i = Arrays.mismatch(a, b, cmp);
* if (i >= 0 && i < Math.min(a.length, b.length))
* return cmp.compare(a[i], b[i]);
* return a.length - b.length;
* }
*
* @param a the first array to compare
* @param b the second array to compare
* @param cmp the comparator to compare array elements
* @param the type of array elements
* @return the value {@code 0} if the first and second array are equal and
* contain the same elements in the same order;
* a value less than {@code 0} if the first array is
* lexicographically less than the second array; and
* a value greater than {@code 0} if the first array is
* lexicographically greater than the second array
* @throws NullPointerException if the comparator is {@code null}
* @since 9
*/
public static int compare(T[] a, T[] b,
Comparator cmp) {
Objects.requireNonNull(cmp);
if (a == b)
return 0;
if (a == null || b == null)
return a == null ? -1 : 1;
int length = Math.min(a.length, b.length);
for (int i = 0; i < length; i++) {
T oa = a[i];
T ob = b[i];
if (oa != ob) {
// Null-value comparison is deferred to the comparator
int v = cmp.compare(oa, ob);
if (v != 0) {
return v;
}
}
}
return a.length - b.length;
}
/**
* Compares two {@code Object} arrays lexicographically over the specified
* ranges.
*
* If the two arrays, over the specified ranges, share a common prefix
* then the lexicographic comparison is the result of comparing with the
* specified comparator two elements at a relative index within the
* respective arrays that is the prefix length.
* Otherwise, one array is a proper prefix of the other and, lexicographic
* comparison is the result of comparing the two range lengths.
* (See {@link #mismatch(Object[], int, int, Object[], int, int)} for the
* definition of a common and proper prefix.)
*
* @apiNote
*
This method behaves as if (for non-{@code null} array elements):
*
{@code
* int i = Arrays.mismatch(a, aFromIndex, aToIndex,
* b, bFromIndex, bToIndex, cmp);
* if (i >= 0 && i < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
* return cmp.compare(a[aFromIndex + i], b[bFromIndex + i]);
* return (aToIndex - aFromIndex) - (bToIndex - bFromIndex);
* }
*
* @param a the first array to compare
* @param aFromIndex the index (inclusive) of the first element in the
* first array to be compared
* @param aToIndex the index (exclusive) of the last element in the
* first array to be compared
* @param b the second array to compare
* @param bFromIndex the index (inclusive) of the first element in the
* second array to be compared
* @param bToIndex the index (exclusive) of the last element in the
* second array to be compared
* @param cmp the comparator to compare array elements
* @param the type of array elements
* @return the value {@code 0} if, over the specified ranges, the first and
* second array are equal and contain the same elements in the same
* order;
* a value less than {@code 0} if, over the specified ranges, the
* first array is lexicographically less than the second array; and
* a value greater than {@code 0} if, over the specified ranges, the
* first array is lexicographically greater than the second array
* @throws IllegalArgumentException
* if {@code aFromIndex > aToIndex} or
* if {@code bFromIndex > bToIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code aFromIndex < 0 or aToIndex > a.length} or
* if {@code bFromIndex < 0 or bToIndex > b.length}
* @throws NullPointerException
* if either array or the comparator is {@code null}
* @since 9
*/
public static int compare(
T[] a, int aFromIndex, int aToIndex,
T[] b, int bFromIndex, int bToIndex,
Comparator cmp) {
Objects.requireNonNull(cmp);
rangeCheck(a.length, aFromIndex, aToIndex);
rangeCheck(b.length, bFromIndex, bToIndex);
int aLength = aToIndex - aFromIndex;
int bLength = bToIndex - bFromIndex;
int length = Math.min(aLength, bLength);
for (int i = 0; i < length; i++) {
T oa = a[aFromIndex++];
T ob = b[bFromIndex++];
if (oa != ob) {
// Null-value comparison is deferred to the comparator
int v = cmp.compare(oa, ob);
if (v != 0) {
return v;
}
}
}
return aLength - bLength;
}
// Mismatch methods
// Mismatch boolean
/**
* Finds and returns the index of the first mismatch between two
* {@code boolean} arrays, otherwise return -1 if no mismatch is found. The
* index will be in the range of 0 (inclusive) up to the length (inclusive)
* of the smaller array.
*
* If the two arrays share a common prefix then the returned index is the
* length of the common prefix and it follows that there is a mismatch
* between the two elements at that index within the respective arrays.
* If one array is a proper prefix of the other then the returned index is
* the length of the smaller array and it follows that the index is only
* valid for the larger array.
* Otherwise, there is no mismatch.
*
*
Two non-{@code null} arrays, {@code a} and {@code b}, share a common
* prefix of length {@code pl} if the following expression is true:
*
{@code
* pl >= 0 &&
* pl < Math.min(a.length, b.length) &&
* Arrays.equals(a, 0, pl, b, 0, pl) &&
* a[pl] != b[pl]
* }
* Note that a common prefix length of {@code 0} indicates that the first
* elements from each array mismatch.
*
* Two non-{@code null} arrays, {@code a} and {@code b}, share a proper
* prefix if the following expression is true:
*
{@code
* a.length != b.length &&
* Arrays.equals(a, 0, Math.min(a.length, b.length),
* b, 0, Math.min(a.length, b.length))
* }
*
* @param a the first array to be tested for a mismatch
* @param b the second array to be tested for a mismatch
* @return the index of the first mismatch between the two arrays,
* otherwise {@code -1}.
* @throws NullPointerException
* if either array is {@code null}
* @since 9
*/
public static int mismatch(boolean[] a, boolean[] b) {
int length = Math.min(a.length, b.length); // Check null array refs
if (a == b)
return -1;
int i = ArraysSupport.mismatch(a, b, length);
return (i < 0 && a.length != b.length) ? length : i;
}
/**
* Finds and returns the relative index of the first mismatch between two
* {@code boolean} arrays over the specified ranges, otherwise return -1 if
* no mismatch is found. The index will be in the range of 0 (inclusive) up
* to the length (inclusive) of the smaller range.
*
* If the two arrays, over the specified ranges, share a common prefix
* then the returned relative index is the length of the common prefix and
* it follows that there is a mismatch between the two elements at that
* relative index within the respective arrays.
* If one array is a proper prefix of the other, over the specified ranges,
* then the returned relative index is the length of the smaller range and
* it follows that the relative index is only valid for the array with the
* larger range.
* Otherwise, there is no mismatch.
*
*
Two non-{@code null} arrays, {@code a} and {@code b} with specified
* ranges [{@code aFromIndex}, {@code atoIndex}) and
* [{@code bFromIndex}, {@code btoIndex}) respectively, share a common
* prefix of length {@code pl} if the following expression is true:
*
{@code
* pl >= 0 &&
* pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) &&
* Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) &&
* a[aFromIndex + pl] != b[bFromIndex + pl]
* }
* Note that a common prefix length of {@code 0} indicates that the first
* elements from each array mismatch.
*
* Two non-{@code null} arrays, {@code a} and {@code b} with specified
* ranges [{@code aFromIndex}, {@code atoIndex}) and
* [{@code bFromIndex}, {@code btoIndex}) respectively, share a proper
* if the following expression is true:
*
{@code
* (aToIndex - aFromIndex) != (bToIndex - bFromIndex) &&
* Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
* b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
* }
*
* @param a the first array to be tested for a mismatch
* @param aFromIndex the index (inclusive) of the first element in the
* first array to be tested
* @param aToIndex the index (exclusive) of the last element in the
* first array to be tested
* @param b the second array to be tested for a mismatch
* @param bFromIndex the index (inclusive) of the first element in the
* second array to be tested
* @param bToIndex the index (exclusive) of the last element in the
* second array to be tested
* @return the relative index of the first mismatch between the two arrays
* over the specified ranges, otherwise {@code -1}.
* @throws IllegalArgumentException
* if {@code aFromIndex > aToIndex} or
* if {@code bFromIndex > bToIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code aFromIndex < 0 or aToIndex > a.length} or
* if {@code bFromIndex < 0 or bToIndex > b.length}
* @throws NullPointerException
* if either array is {@code null}
* @since 9
*/
public static int mismatch(boolean[] a, int aFromIndex, int aToIndex,
boolean[] b, int bFromIndex, int bToIndex) {
rangeCheck(a.length, aFromIndex, aToIndex);
rangeCheck(b.length, bFromIndex, bToIndex);
int aLength = aToIndex - aFromIndex;
int bLength = bToIndex - bFromIndex;
int length = Math.min(aLength, bLength);
int i = ArraysSupport.mismatch(a, aFromIndex,
b, bFromIndex,
length);
return (i < 0 && aLength != bLength) ? length : i;
}
// Mismatch byte
/**
* Finds and returns the index of the first mismatch between two {@code byte}
* arrays, otherwise return -1 if no mismatch is found. The index will be
* in the range of 0 (inclusive) up to the length (inclusive) of the smaller
* array.
*
* If the two arrays share a common prefix then the returned index is the
* length of the common prefix and it follows that there is a mismatch
* between the two elements at that index within the respective arrays.
* If one array is a proper prefix of the other then the returned index is
* the length of the smaller array and it follows that the index is only
* valid for the larger array.
* Otherwise, there is no mismatch.
*
*
Two non-{@code null} arrays, {@code a} and {@code b}, share a common
* prefix of length {@code pl} if the following expression is true:
*
{@code
* pl >= 0 &&
* pl < Math.min(a.length, b.length) &&
* Arrays.equals(a, 0, pl, b, 0, pl) &&
* a[pl] != b[pl]
* }
* Note that a common prefix length of {@code 0} indicates that the first
* elements from each array mismatch.
*
* Two non-{@code null} arrays, {@code a} and {@code b}, share a proper
* prefix if the following expression is true:
*
{@code
* a.length != b.length &&
* Arrays.equals(a, 0, Math.min(a.length, b.length),
* b, 0, Math.min(a.length, b.length))
* }
*
* @param a the first array to be tested for a mismatch
* @param b the second array to be tested for a mismatch
* @return the index of the first mismatch between the two arrays,
* otherwise {@code -1}.
* @throws NullPointerException
* if either array is {@code null}
* @since 9
*/
public static int mismatch(byte[] a, byte[] b) {
int length = Math.min(a.length, b.length); // Check null array refs
if (a == b)
return -1;
int i = ArraysSupport.mismatch(a, b, length);
return (i < 0 && a.length != b.length) ? length : i;
}
/**
* Finds and returns the relative index of the first mismatch between two
* {@code byte} arrays over the specified ranges, otherwise return -1 if no
* mismatch is found. The index will be in the range of 0 (inclusive) up to
* the length (inclusive) of the smaller range.
*
* If the two arrays, over the specified ranges, share a common prefix
* then the returned relative index is the length of the common prefix and
* it follows that there is a mismatch between the two elements at that
* relative index within the respective arrays.
* If one array is a proper prefix of the other, over the specified ranges,
* then the returned relative index is the length of the smaller range and
* it follows that the relative index is only valid for the array with the
* larger range.
* Otherwise, there is no mismatch.
*
*
Two non-{@code null} arrays, {@code a} and {@code b} with specified
* ranges [{@code aFromIndex}, {@code atoIndex}) and
* [{@code bFromIndex}, {@code btoIndex}) respectively, share a common
* prefix of length {@code pl} if the following expression is true:
*
{@code
* pl >= 0 &&
* pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) &&
* Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) &&
* a[aFromIndex + pl] != b[bFromIndex + pl]
* }
* Note that a common prefix length of {@code 0} indicates that the first
* elements from each array mismatch.
*
* Two non-{@code null} arrays, {@code a} and {@code b} with specified
* ranges [{@code aFromIndex}, {@code atoIndex}) and
* [{@code bFromIndex}, {@code btoIndex}) respectively, share a proper
* if the following expression is true:
*
{@code
* (aToIndex - aFromIndex) != (bToIndex - bFromIndex) &&
* Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
* b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
* }
*
* @param a the first array to be tested for a mismatch
* @param aFromIndex the index (inclusive) of the first element in the
* first array to be tested
* @param aToIndex the index (exclusive) of the last element in the
* first array to be tested
* @param b the second array to be tested for a mismatch
* @param bFromIndex the index (inclusive) of the first element in the
* second array to be tested
* @param bToIndex the index (exclusive) of the last element in the
* second array to be tested
* @return the relative index of the first mismatch between the two arrays
* over the specified ranges, otherwise {@code -1}.
* @throws IllegalArgumentException
* if {@code aFromIndex > aToIndex} or
* if {@code bFromIndex > bToIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code aFromIndex < 0 or aToIndex > a.length} or
* if {@code bFromIndex < 0 or bToIndex > b.length}
* @throws NullPointerException
* if either array is {@code null}
* @since 9
*/
public static int mismatch(byte[] a, int aFromIndex, int aToIndex,
byte[] b, int bFromIndex, int bToIndex) {
rangeCheck(a.length, aFromIndex, aToIndex);
rangeCheck(b.length, bFromIndex, bToIndex);
int aLength = aToIndex - aFromIndex;
int bLength = bToIndex - bFromIndex;
int length = Math.min(aLength, bLength);
int i = ArraysSupport.mismatch(a, aFromIndex,
b, bFromIndex,
length);
return (i < 0 && aLength != bLength) ? length : i;
}
// Mismatch char
/**
* Finds and returns the index of the first mismatch between two {@code char}
* arrays, otherwise return -1 if no mismatch is found. The index will be
* in the range of 0 (inclusive) up to the length (inclusive) of the smaller
* array.
*
* If the two arrays share a common prefix then the returned index is the
* length of the common prefix and it follows that there is a mismatch
* between the two elements at that index within the respective arrays.
* If one array is a proper prefix of the other then the returned index is
* the length of the smaller array and it follows that the index is only
* valid for the larger array.
* Otherwise, there is no mismatch.
*
*
Two non-{@code null} arrays, {@code a} and {@code b}, share a common
* prefix of length {@code pl} if the following expression is true:
*
{@code
* pl >= 0 &&
* pl < Math.min(a.length, b.length) &&
* Arrays.equals(a, 0, pl, b, 0, pl) &&
* a[pl] != b[pl]
* }
* Note that a common prefix length of {@code 0} indicates that the first
* elements from each array mismatch.
*
* Two non-{@code null} arrays, {@code a} and {@code b}, share a proper
* prefix if the following expression is true:
*
{@code
* a.length != b.length &&
* Arrays.equals(a, 0, Math.min(a.length, b.length),
* b, 0, Math.min(a.length, b.length))
* }
*
* @param a the first array to be tested for a mismatch
* @param b the second array to be tested for a mismatch
* @return the index of the first mismatch between the two arrays,
* otherwise {@code -1}.
* @throws NullPointerException
* if either array is {@code null}
* @since 9
*/
public static int mismatch(char[] a, char[] b) {
int length = Math.min(a.length, b.length); // Check null array refs
if (a == b)
return -1;
int i = ArraysSupport.mismatch(a, b, length);
return (i < 0 && a.length != b.length) ? length : i;
}
/**
* Finds and returns the relative index of the first mismatch between two
* {@code char} arrays over the specified ranges, otherwise return -1 if no
* mismatch is found. The index will be in the range of 0 (inclusive) up to
* the length (inclusive) of the smaller range.
*
* If the two arrays, over the specified ranges, share a common prefix
* then the returned relative index is the length of the common prefix and
* it follows that there is a mismatch between the two elements at that
* relative index within the respective arrays.
* If one array is a proper prefix of the other, over the specified ranges,
* then the returned relative index is the length of the smaller range and
* it follows that the relative index is only valid for the array with the
* larger range.
* Otherwise, there is no mismatch.
*
*
Two non-{@code null} arrays, {@code a} and {@code b} with specified
* ranges [{@code aFromIndex}, {@code atoIndex}) and
* [{@code bFromIndex}, {@code btoIndex}) respectively, share a common
* prefix of length {@code pl} if the following expression is true:
*
{@code
* pl >= 0 &&
* pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) &&
* Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) &&
* a[aFromIndex + pl] != b[bFromIndex + pl]
* }
* Note that a common prefix length of {@code 0} indicates that the first
* elements from each array mismatch.
*
* Two non-{@code null} arrays, {@code a} and {@code b} with specified
* ranges [{@code aFromIndex}, {@code atoIndex}) and
* [{@code bFromIndex}, {@code btoIndex}) respectively, share a proper
* if the following expression is true:
*
{@code
* (aToIndex - aFromIndex) != (bToIndex - bFromIndex) &&
* Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
* b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
* }
*
* @param a the first array to be tested for a mismatch
* @param aFromIndex the index (inclusive) of the first element in the
* first array to be tested
* @param aToIndex the index (exclusive) of the last element in the
* first array to be tested
* @param b the second array to be tested for a mismatch
* @param bFromIndex the index (inclusive) of the first element in the
* second array to be tested
* @param bToIndex the index (exclusive) of the last element in the
* second array to be tested
* @return the relative index of the first mismatch between the two arrays
* over the specified ranges, otherwise {@code -1}.
* @throws IllegalArgumentException
* if {@code aFromIndex > aToIndex} or
* if {@code bFromIndex > bToIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code aFromIndex < 0 or aToIndex > a.length} or
* if {@code bFromIndex < 0 or bToIndex > b.length}
* @throws NullPointerException
* if either array is {@code null}
* @since 9
*/
public static int mismatch(char[] a, int aFromIndex, int aToIndex,
char[] b, int bFromIndex, int bToIndex) {
rangeCheck(a.length, aFromIndex, aToIndex);
rangeCheck(b.length, bFromIndex, bToIndex);
int aLength = aToIndex - aFromIndex;
int bLength = bToIndex - bFromIndex;
int length = Math.min(aLength, bLength);
int i = ArraysSupport.mismatch(a, aFromIndex,
b, bFromIndex,
length);
return (i < 0 && aLength != bLength) ? length : i;
}
// Mismatch short
/**
* Finds and returns the index of the first mismatch between two {@code short}
* arrays, otherwise return -1 if no mismatch is found. The index will be
* in the range of 0 (inclusive) up to the length (inclusive) of the smaller
* array.
*
* If the two arrays share a common prefix then the returned index is the
* length of the common prefix and it follows that there is a mismatch
* between the two elements at that index within the respective arrays.
* If one array is a proper prefix of the other then the returned index is
* the length of the smaller array and it follows that the index is only
* valid for the larger array.
* Otherwise, there is no mismatch.
*
*
Two non-{@code null} arrays, {@code a} and {@code b}, share a common
* prefix of length {@code pl} if the following expression is true:
*
{@code
* pl >= 0 &&
* pl < Math.min(a.length, b.length) &&
* Arrays.equals(a, 0, pl, b, 0, pl) &&
* a[pl] != b[pl]
* }
* Note that a common prefix length of {@code 0} indicates that the first
* elements from each array mismatch.
*
* Two non-{@code null} arrays, {@code a} and {@code b}, share a proper
* prefix if the following expression is true:
*
{@code
* a.length != b.length &&
* Arrays.equals(a, 0, Math.min(a.length, b.length),
* b, 0, Math.min(a.length, b.length))
* }
*
* @param a the first array to be tested for a mismatch
* @param b the second array to be tested for a mismatch
* @return the index of the first mismatch between the two arrays,
* otherwise {@code -1}.
* @throws NullPointerException
* if either array is {@code null}
* @since 9
*/
public static int mismatch(short[] a, short[] b) {
int length = Math.min(a.length, b.length); // Check null array refs
if (a == b)
return -1;
int i = ArraysSupport.mismatch(a, b, length);
return (i < 0 && a.length != b.length) ? length : i;
}
/**
* Finds and returns the relative index of the first mismatch between two
* {@code short} arrays over the specified ranges, otherwise return -1 if no
* mismatch is found. The index will be in the range of 0 (inclusive) up to
* the length (inclusive) of the smaller range.
*
* If the two arrays, over the specified ranges, share a common prefix
* then the returned relative index is the length of the common prefix and
* it follows that there is a mismatch between the two elements at that
* relative index within the respective arrays.
* If one array is a proper prefix of the other, over the specified ranges,
* then the returned relative index is the length of the smaller range and
* it follows that the relative index is only valid for the array with the
* larger range.
* Otherwise, there is no mismatch.
*
*
Two non-{@code null} arrays, {@code a} and {@code b} with specified
* ranges [{@code aFromIndex}, {@code atoIndex}) and
* [{@code bFromIndex}, {@code btoIndex}) respectively, share a common
* prefix of length {@code pl} if the following expression is true:
*
{@code
* pl >= 0 &&
* pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) &&
* Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) &&
* a[aFromIndex + pl] != b[bFromIndex + pl]
* }
* Note that a common prefix length of {@code 0} indicates that the first
* elements from each array mismatch.
*
* Two non-{@code null} arrays, {@code a} and {@code b} with specified
* ranges [{@code aFromIndex}, {@code atoIndex}) and
* [{@code bFromIndex}, {@code btoIndex}) respectively, share a proper
* if the following expression is true:
*
{@code
* (aToIndex - aFromIndex) != (bToIndex - bFromIndex) &&
* Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
* b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
* }
*
* @param a the first array to be tested for a mismatch
* @param aFromIndex the index (inclusive) of the first element in the
* first array to be tested
* @param aToIndex the index (exclusive) of the last element in the
* first array to be tested
* @param b the second array to be tested for a mismatch
* @param bFromIndex the index (inclusive) of the first element in the
* second array to be tested
* @param bToIndex the index (exclusive) of the last element in the
* second array to be tested
* @return the relative index of the first mismatch between the two arrays
* over the specified ranges, otherwise {@code -1}.
* @throws IllegalArgumentException
* if {@code aFromIndex > aToIndex} or
* if {@code bFromIndex > bToIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code aFromIndex < 0 or aToIndex > a.length} or
* if {@code bFromIndex < 0 or bToIndex > b.length}
* @throws NullPointerException
* if either array is {@code null}
* @since 9
*/
public static int mismatch(short[] a, int aFromIndex, int aToIndex,
short[] b, int bFromIndex, int bToIndex) {
rangeCheck(a.length, aFromIndex, aToIndex);
rangeCheck(b.length, bFromIndex, bToIndex);
int aLength = aToIndex - aFromIndex;
int bLength = bToIndex - bFromIndex;
int length = Math.min(aLength, bLength);
int i = ArraysSupport.mismatch(a, aFromIndex,
b, bFromIndex,
length);
return (i < 0 && aLength != bLength) ? length : i;
}
// Mismatch int
/**
* Finds and returns the index of the first mismatch between two {@code int}
* arrays, otherwise return -1 if no mismatch is found. The index will be
* in the range of 0 (inclusive) up to the length (inclusive) of the smaller
* array.
*
* If the two arrays share a common prefix then the returned index is the
* length of the common prefix and it follows that there is a mismatch
* between the two elements at that index within the respective arrays.
* If one array is a proper prefix of the other then the returned index is
* the length of the smaller array and it follows that the index is only
* valid for the larger array.
* Otherwise, there is no mismatch.
*
*
Two non-{@code null} arrays, {@code a} and {@code b}, share a common
* prefix of length {@code pl} if the following expression is true:
*
{@code
* pl >= 0 &&
* pl < Math.min(a.length, b.length) &&
* Arrays.equals(a, 0, pl, b, 0, pl) &&
* a[pl] != b[pl]
* }
* Note that a common prefix length of {@code 0} indicates that the first
* elements from each array mismatch.
*
* Two non-{@code null} arrays, {@code a} and {@code b}, share a proper
* prefix if the following expression is true:
*
{@code
* a.length != b.length &&
* Arrays.equals(a, 0, Math.min(a.length, b.length),
* b, 0, Math.min(a.length, b.length))
* }
*
* @param a the first array to be tested for a mismatch
* @param b the second array to be tested for a mismatch
* @return the index of the first mismatch between the two arrays,
* otherwise {@code -1}.
* @throws NullPointerException
* if either array is {@code null}
* @since 9
*/
public static int mismatch(int[] a, int[] b) {
int length = Math.min(a.length, b.length); // Check null array refs
if (a == b)
return -1;
int i = ArraysSupport.mismatch(a, b, length);
return (i < 0 && a.length != b.length) ? length : i;
}
/**
* Finds and returns the relative index of the first mismatch between two
* {@code int} arrays over the specified ranges, otherwise return -1 if no
* mismatch is found. The index will be in the range of 0 (inclusive) up to
* the length (inclusive) of the smaller range.
*
* If the two arrays, over the specified ranges, share a common prefix
* then the returned relative index is the length of the common prefix and
* it follows that there is a mismatch between the two elements at that
* relative index within the respective arrays.
* If one array is a proper prefix of the other, over the specified ranges,
* then the returned relative index is the length of the smaller range and
* it follows that the relative index is only valid for the array with the
* larger range.
* Otherwise, there is no mismatch.
*
*
Two non-{@code null} arrays, {@code a} and {@code b} with specified
* ranges [{@code aFromIndex}, {@code atoIndex}) and
* [{@code bFromIndex}, {@code btoIndex}) respectively, share a common
* prefix of length {@code pl} if the following expression is true:
*
{@code
* pl >= 0 &&
* pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) &&
* Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) &&
* a[aFromIndex + pl] != b[bFromIndex + pl]
* }
* Note that a common prefix length of {@code 0} indicates that the first
* elements from each array mismatch.
*
* Two non-{@code null} arrays, {@code a} and {@code b} with specified
* ranges [{@code aFromIndex}, {@code atoIndex}) and
* [{@code bFromIndex}, {@code btoIndex}) respectively, share a proper
* if the following expression is true:
*
{@code
* (aToIndex - aFromIndex) != (bToIndex - bFromIndex) &&
* Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
* b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
* }
*
* @param a the first array to be tested for a mismatch
* @param aFromIndex the index (inclusive) of the first element in the
* first array to be tested
* @param aToIndex the index (exclusive) of the last element in the
* first array to be tested
* @param b the second array to be tested for a mismatch
* @param bFromIndex the index (inclusive) of the first element in the
* second array to be tested
* @param bToIndex the index (exclusive) of the last element in the
* second array to be tested
* @return the relative index of the first mismatch between the two arrays
* over the specified ranges, otherwise {@code -1}.
* @throws IllegalArgumentException
* if {@code aFromIndex > aToIndex} or
* if {@code bFromIndex > bToIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code aFromIndex < 0 or aToIndex > a.length} or
* if {@code bFromIndex < 0 or bToIndex > b.length}
* @throws NullPointerException
* if either array is {@code null}
* @since 9
*/
public static int mismatch(int[] a, int aFromIndex, int aToIndex,
int[] b, int bFromIndex, int bToIndex) {
rangeCheck(a.length, aFromIndex, aToIndex);
rangeCheck(b.length, bFromIndex, bToIndex);
int aLength = aToIndex - aFromIndex;
int bLength = bToIndex - bFromIndex;
int length = Math.min(aLength, bLength);
int i = ArraysSupport.mismatch(a, aFromIndex,
b, bFromIndex,
length);
return (i < 0 && aLength != bLength) ? length : i;
}
// Mismatch long
/**
* Finds and returns the index of the first mismatch between two {@code long}
* arrays, otherwise return -1 if no mismatch is found. The index will be
* in the range of 0 (inclusive) up to the length (inclusive) of the smaller
* array.
*
* If the two arrays share a common prefix then the returned index is the
* length of the common prefix and it follows that there is a mismatch
* between the two elements at that index within the respective arrays.
* If one array is a proper prefix of the other then the returned index is
* the length of the smaller array and it follows that the index is only
* valid for the larger array.
* Otherwise, there is no mismatch.
*
*
Two non-{@code null} arrays, {@code a} and {@code b}, share a common
* prefix of length {@code pl} if the following expression is true:
*
{@code
* pl >= 0 &&
* pl < Math.min(a.length, b.length) &&
* Arrays.equals(a, 0, pl, b, 0, pl) &&
* a[pl] != b[pl]
* }
* Note that a common prefix length of {@code 0} indicates that the first
* elements from each array mismatch.
*
* Two non-{@code null} arrays, {@code a} and {@code b}, share a proper
* prefix if the following expression is true:
*
{@code
* a.length != b.length &&
* Arrays.equals(a, 0, Math.min(a.length, b.length),
* b, 0, Math.min(a.length, b.length))
* }
*
* @param a the first array to be tested for a mismatch
* @param b the second array to be tested for a mismatch
* @return the index of the first mismatch between the two arrays,
* otherwise {@code -1}.
* @throws NullPointerException
* if either array is {@code null}
* @since 9
*/
public static int mismatch(long[] a, long[] b) {
int length = Math.min(a.length, b.length); // Check null array refs
if (a == b)
return -1;
int i = ArraysSupport.mismatch(a, b, length);
return (i < 0 && a.length != b.length) ? length : i;
}
/**
* Finds and returns the relative index of the first mismatch between two
* {@code long} arrays over the specified ranges, otherwise return -1 if no
* mismatch is found. The index will be in the range of 0 (inclusive) up to
* the length (inclusive) of the smaller range.
*
* If the two arrays, over the specified ranges, share a common prefix
* then the returned relative index is the length of the common prefix and
* it follows that there is a mismatch between the two elements at that
* relative index within the respective arrays.
* If one array is a proper prefix of the other, over the specified ranges,
* then the returned relative index is the length of the smaller range and
* it follows that the relative index is only valid for the array with the
* larger range.
* Otherwise, there is no mismatch.
*
*
Two non-{@code null} arrays, {@code a} and {@code b} with specified
* ranges [{@code aFromIndex}, {@code atoIndex}) and
* [{@code bFromIndex}, {@code btoIndex}) respectively, share a common
* prefix of length {@code pl} if the following expression is true:
*
{@code
* pl >= 0 &&
* pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) &&
* Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) &&
* a[aFromIndex + pl] != b[bFromIndex + pl]
* }
* Note that a common prefix length of {@code 0} indicates that the first
* elements from each array mismatch.
*
* Two non-{@code null} arrays, {@code a} and {@code b} with specified
* ranges [{@code aFromIndex}, {@code atoIndex}) and
* [{@code bFromIndex}, {@code btoIndex}) respectively, share a proper
* if the following expression is true:
*
{@code
* (aToIndex - aFromIndex) != (bToIndex - bFromIndex) &&
* Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
* b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
* }
*
* @param a the first array to be tested for a mismatch
* @param aFromIndex the index (inclusive) of the first element in the
* first array to be tested
* @param aToIndex the index (exclusive) of the last element in the
* first array to be tested
* @param b the second array to be tested for a mismatch
* @param bFromIndex the index (inclusive) of the first element in the
* second array to be tested
* @param bToIndex the index (exclusive) of the last element in the
* second array to be tested
* @return the relative index of the first mismatch between the two arrays
* over the specified ranges, otherwise {@code -1}.
* @throws IllegalArgumentException
* if {@code aFromIndex > aToIndex} or
* if {@code bFromIndex > bToIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code aFromIndex < 0 or aToIndex > a.length} or
* if {@code bFromIndex < 0 or bToIndex > b.length}
* @throws NullPointerException
* if either array is {@code null}
* @since 9
*/
public static int mismatch(long[] a, int aFromIndex, int aToIndex,
long[] b, int bFromIndex, int bToIndex) {
rangeCheck(a.length, aFromIndex, aToIndex);
rangeCheck(b.length, bFromIndex, bToIndex);
int aLength = aToIndex - aFromIndex;
int bLength = bToIndex - bFromIndex;
int length = Math.min(aLength, bLength);
int i = ArraysSupport.mismatch(a, aFromIndex,
b, bFromIndex,
length);
return (i < 0 && aLength != bLength) ? length : i;
}
// Mismatch float
/**
* Finds and returns the index of the first mismatch between two {@code float}
* arrays, otherwise return -1 if no mismatch is found. The index will be
* in the range of 0 (inclusive) up to the length (inclusive) of the smaller
* array.
*
* If the two arrays share a common prefix then the returned index is the
* length of the common prefix and it follows that there is a mismatch
* between the two elements at that index within the respective arrays.
* If one array is a proper prefix of the other then the returned index is
* the length of the smaller array and it follows that the index is only
* valid for the larger array.
* Otherwise, there is no mismatch.
*
*
Two non-{@code null} arrays, {@code a} and {@code b}, share a common
* prefix of length {@code pl} if the following expression is true:
*
{@code
* pl >= 0 &&
* pl < Math.min(a.length, b.length) &&
* Arrays.equals(a, 0, pl, b, 0, pl) &&
* Float.compare(a[pl], b[pl]) != 0
* }
* Note that a common prefix length of {@code 0} indicates that the first
* elements from each array mismatch.
*
* Two non-{@code null} arrays, {@code a} and {@code b}, share a proper
* prefix if the following expression is true:
*
{@code
* a.length != b.length &&
* Arrays.equals(a, 0, Math.min(a.length, b.length),
* b, 0, Math.min(a.length, b.length))
* }
*
* @param a the first array to be tested for a mismatch
* @param b the second array to be tested for a mismatch
* @return the index of the first mismatch between the two arrays,
* otherwise {@code -1}.
* @throws NullPointerException
* if either array is {@code null}
* @since 9
*/
public static int mismatch(float[] a, float[] b) {
int length = Math.min(a.length, b.length); // Check null array refs
if (a == b)
return -1;
int i = ArraysSupport.mismatch(a, b, length);
return (i < 0 && a.length != b.length) ? length : i;
}
/**
* Finds and returns the relative index of the first mismatch between two
* {@code float} arrays over the specified ranges, otherwise return -1 if no
* mismatch is found. The index will be in the range of 0 (inclusive) up to
* the length (inclusive) of the smaller range.
*
* If the two arrays, over the specified ranges, share a common prefix
* then the returned relative index is the length of the common prefix and
* it follows that there is a mismatch between the two elements at that
* relative index within the respective arrays.
* If one array is a proper prefix of the other, over the specified ranges,
* then the returned relative index is the length of the smaller range and
* it follows that the relative index is only valid for the array with the
* larger range.
* Otherwise, there is no mismatch.
*
*
Two non-{@code null} arrays, {@code a} and {@code b} with specified
* ranges [{@code aFromIndex}, {@code atoIndex}) and
* [{@code bFromIndex}, {@code btoIndex}) respectively, share a common
* prefix of length {@code pl} if the following expression is true:
*
{@code
* pl >= 0 &&
* pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) &&
* Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) &&
* Float.compare(a[aFromIndex + pl], b[bFromIndex + pl]) != 0
* }
* Note that a common prefix length of {@code 0} indicates that the first
* elements from each array mismatch.
*
* Two non-{@code null} arrays, {@code a} and {@code b} with specified
* ranges [{@code aFromIndex}, {@code atoIndex}) and
* [{@code bFromIndex}, {@code btoIndex}) respectively, share a proper
* if the following expression is true:
*
{@code
* (aToIndex - aFromIndex) != (bToIndex - bFromIndex) &&
* Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
* b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
* }
*
* @param a the first array to be tested for a mismatch
* @param aFromIndex the index (inclusive) of the first element in the
* first array to be tested
* @param aToIndex the index (exclusive) of the last element in the
* first array to be tested
* @param b the second array to be tested for a mismatch
* @param bFromIndex the index (inclusive) of the first element in the
* second array to be tested
* @param bToIndex the index (exclusive) of the last element in the
* second array to be tested
* @return the relative index of the first mismatch between the two arrays
* over the specified ranges, otherwise {@code -1}.
* @throws IllegalArgumentException
* if {@code aFromIndex > aToIndex} or
* if {@code bFromIndex > bToIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code aFromIndex < 0 or aToIndex > a.length} or
* if {@code bFromIndex < 0 or bToIndex > b.length}
* @throws NullPointerException
* if either array is {@code null}
* @since 9
*/
public static int mismatch(float[] a, int aFromIndex, int aToIndex,
float[] b, int bFromIndex, int bToIndex) {
rangeCheck(a.length, aFromIndex, aToIndex);
rangeCheck(b.length, bFromIndex, bToIndex);
int aLength = aToIndex - aFromIndex;
int bLength = bToIndex - bFromIndex;
int length = Math.min(aLength, bLength);
int i = ArraysSupport.mismatch(a, aFromIndex,
b, bFromIndex,
length);
return (i < 0 && aLength != bLength) ? length : i;
}
// Mismatch double
/**
* Finds and returns the index of the first mismatch between two
* {@code double} arrays, otherwise return -1 if no mismatch is found. The
* index will be in the range of 0 (inclusive) up to the length (inclusive)
* of the smaller array.
*
* If the two arrays share a common prefix then the returned index is the
* length of the common prefix and it follows that there is a mismatch
* between the two elements at that index within the respective arrays.
* If one array is a proper prefix of the other then the returned index is
* the length of the smaller array and it follows that the index is only
* valid for the larger array.
* Otherwise, there is no mismatch.
*
*
Two non-{@code null} arrays, {@code a} and {@code b}, share a common
* prefix of length {@code pl} if the following expression is true:
*
{@code
* pl >= 0 &&
* pl < Math.min(a.length, b.length) &&
* Arrays.equals(a, 0, pl, b, 0, pl) &&
* Double.compare(a[pl], b[pl]) != 0
* }
* Note that a common prefix length of {@code 0} indicates that the first
* elements from each array mismatch.
*
* Two non-{@code null} arrays, {@code a} and {@code b}, share a proper
* prefix if the following expression is true:
*
{@code
* a.length != b.length &&
* Arrays.equals(a, 0, Math.min(a.length, b.length),
* b, 0, Math.min(a.length, b.length))
* }
*
* @param a the first array to be tested for a mismatch
* @param b the second array to be tested for a mismatch
* @return the index of the first mismatch between the two arrays,
* otherwise {@code -1}.
* @throws NullPointerException
* if either array is {@code null}
* @since 9
*/
public static int mismatch(double[] a, double[] b) {
int length = Math.min(a.length, b.length); // Check null array refs
if (a == b)
return -1;
int i = ArraysSupport.mismatch(a, b, length);
return (i < 0 && a.length != b.length) ? length : i;
}
/**
* Finds and returns the relative index of the first mismatch between two
* {@code double} arrays over the specified ranges, otherwise return -1 if
* no mismatch is found. The index will be in the range of 0 (inclusive) up
* to the length (inclusive) of the smaller range.
*
* If the two arrays, over the specified ranges, share a common prefix
* then the returned relative index is the length of the common prefix and
* it follows that there is a mismatch between the two elements at that
* relative index within the respective arrays.
* If one array is a proper prefix of the other, over the specified ranges,
* then the returned relative index is the length of the smaller range and
* it follows that the relative index is only valid for the array with the
* larger range.
* Otherwise, there is no mismatch.
*
*
Two non-{@code null} arrays, {@code a} and {@code b} with specified
* ranges [{@code aFromIndex}, {@code atoIndex}) and
* [{@code bFromIndex}, {@code btoIndex}) respectively, share a common
* prefix of length {@code pl} if the following expression is true:
*
{@code
* pl >= 0 &&
* pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) &&
* Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) &&
* Double.compare(a[aFromIndex + pl], b[bFromIndex + pl]) != 0
* }
* Note that a common prefix length of {@code 0} indicates that the first
* elements from each array mismatch.
*
* Two non-{@code null} arrays, {@code a} and {@code b} with specified
* ranges [{@code aFromIndex}, {@code atoIndex}) and
* [{@code bFromIndex}, {@code btoIndex}) respectively, share a proper
* if the following expression is true:
*
{@code
* (aToIndex - aFromIndex) != (bToIndex - bFromIndex) &&
* Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
* b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
* }
*
* @param a the first array to be tested for a mismatch
* @param aFromIndex the index (inclusive) of the first element in the
* first array to be tested
* @param aToIndex the index (exclusive) of the last element in the
* first array to be tested
* @param b the second array to be tested for a mismatch
* @param bFromIndex the index (inclusive) of the first element in the
* second array to be tested
* @param bToIndex the index (exclusive) of the last element in the
* second array to be tested
* @return the relative index of the first mismatch between the two arrays
* over the specified ranges, otherwise {@code -1}.
* @throws IllegalArgumentException
* if {@code aFromIndex > aToIndex} or
* if {@code bFromIndex > bToIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code aFromIndex < 0 or aToIndex > a.length} or
* if {@code bFromIndex < 0 or bToIndex > b.length}
* @throws NullPointerException
* if either array is {@code null}
* @since 9
*/
public static int mismatch(double[] a, int aFromIndex, int aToIndex,
double[] b, int bFromIndex, int bToIndex) {
rangeCheck(a.length, aFromIndex, aToIndex);
rangeCheck(b.length, bFromIndex, bToIndex);
int aLength = aToIndex - aFromIndex;
int bLength = bToIndex - bFromIndex;
int length = Math.min(aLength, bLength);
int i = ArraysSupport.mismatch(a, aFromIndex,
b, bFromIndex,
length);
return (i < 0 && aLength != bLength) ? length : i;
}
// Mismatch objects
/**
* Finds and returns the index of the first mismatch between two
* {@code Object} arrays, otherwise return -1 if no mismatch is found. The
* index will be in the range of 0 (inclusive) up to the length (inclusive)
* of the smaller array.
*
* If the two arrays share a common prefix then the returned index is the
* length of the common prefix and it follows that there is a mismatch
* between the two elements at that index within the respective arrays.
* If one array is a proper prefix of the other then the returned index is
* the length of the smaller array and it follows that the index is only
* valid for the larger array.
* Otherwise, there is no mismatch.
*
*
Two non-{@code null} arrays, {@code a} and {@code b}, share a common
* prefix of length {@code pl} if the following expression is true:
*
{@code
* pl >= 0 &&
* pl < Math.min(a.length, b.length) &&
* Arrays.equals(a, 0, pl, b, 0, pl) &&
* !Objects.equals(a[pl], b[pl])
* }
* Note that a common prefix length of {@code 0} indicates that the first
* elements from each array mismatch.
*
* Two non-{@code null} arrays, {@code a} and {@code b}, share a proper
* prefix if the following expression is true:
*
{@code
* a.length != b.length &&
* Arrays.equals(a, 0, Math.min(a.length, b.length),
* b, 0, Math.min(a.length, b.length))
* }
*
* @param a the first array to be tested for a mismatch
* @param b the second array to be tested for a mismatch
* @return the index of the first mismatch between the two arrays,
* otherwise {@code -1}.
* @throws NullPointerException
* if either array is {@code null}
* @since 9
*/
public static int mismatch(Object[] a, Object[] b) {
int length = Math.min(a.length, b.length); // Check null array refs
if (a == b)
return -1;
for (int i = 0; i < length; i++) {
if (!Objects.equals(a[i], b[i]))
return i;
}
return a.length != b.length ? length : -1;
}
/**
* Finds and returns the relative index of the first mismatch between two
* {@code Object} arrays over the specified ranges, otherwise return -1 if
* no mismatch is found. The index will be in the range of 0 (inclusive) up
* to the length (inclusive) of the smaller range.
*
* If the two arrays, over the specified ranges, share a common prefix
* then the returned relative index is the length of the common prefix and
* it follows that there is a mismatch between the two elements at that
* relative index within the respective arrays.
* If one array is a proper prefix of the other, over the specified ranges,
* then the returned relative index is the length of the smaller range and
* it follows that the relative index is only valid for the array with the
* larger range.
* Otherwise, there is no mismatch.
*
*
Two non-{@code null} arrays, {@code a} and {@code b} with specified
* ranges [{@code aFromIndex}, {@code atoIndex}) and
* [{@code bFromIndex}, {@code btoIndex}) respectively, share a common
* prefix of length {@code pl} if the following expression is true:
*
{@code
* pl >= 0 &&
* pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) &&
* Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl) &&
* !Objects.equals(a[aFromIndex + pl], b[bFromIndex + pl])
* }
* Note that a common prefix length of {@code 0} indicates that the first
* elements from each array mismatch.
*
* Two non-{@code null} arrays, {@code a} and {@code b} with specified
* ranges [{@code aFromIndex}, {@code atoIndex}) and
* [{@code bFromIndex}, {@code btoIndex}) respectively, share a proper
* if the following expression is true:
*
{@code
* (aToIndex - aFromIndex) != (bToIndex - bFromIndex) &&
* Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
* b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex))
* }
*
* @param a the first array to be tested for a mismatch
* @param aFromIndex the index (inclusive) of the first element in the
* first array to be tested
* @param aToIndex the index (exclusive) of the last element in the
* first array to be tested
* @param b the second array to be tested for a mismatch
* @param bFromIndex the index (inclusive) of the first element in the
* second array to be tested
* @param bToIndex the index (exclusive) of the last element in the
* second array to be tested
* @return the relative index of the first mismatch between the two arrays
* over the specified ranges, otherwise {@code -1}.
* @throws IllegalArgumentException
* if {@code aFromIndex > aToIndex} or
* if {@code bFromIndex > bToIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code aFromIndex < 0 or aToIndex > a.length} or
* if {@code bFromIndex < 0 or bToIndex > b.length}
* @throws NullPointerException
* if either array is {@code null}
* @since 9
*/
public static int mismatch(
Object[] a, int aFromIndex, int aToIndex,
Object[] b, int bFromIndex, int bToIndex) {
rangeCheck(a.length, aFromIndex, aToIndex);
rangeCheck(b.length, bFromIndex, bToIndex);
int aLength = aToIndex - aFromIndex;
int bLength = bToIndex - bFromIndex;
int length = Math.min(aLength, bLength);
for (int i = 0; i < length; i++) {
if (!Objects.equals(a[aFromIndex++], b[bFromIndex++]))
return i;
}
return aLength != bLength ? length : -1;
}
/**
* Finds and returns the index of the first mismatch between two
* {@code Object} arrays, otherwise return -1 if no mismatch is found.
* The index will be in the range of 0 (inclusive) up to the length
* (inclusive) of the smaller array.
*
* The specified comparator is used to determine if two array elements
* from the each array are not equal.
*
*
If the two arrays share a common prefix then the returned index is the
* length of the common prefix and it follows that there is a mismatch
* between the two elements at that index within the respective arrays.
* If one array is a proper prefix of the other then the returned index is
* the length of the smaller array and it follows that the index is only
* valid for the larger array.
* Otherwise, there is no mismatch.
*
*
Two non-{@code null} arrays, {@code a} and {@code b}, share a common
* prefix of length {@code pl} if the following expression is true:
*
{@code
* pl >= 0 &&
* pl < Math.min(a.length, b.length) &&
* Arrays.equals(a, 0, pl, b, 0, pl, cmp)
* cmp.compare(a[pl], b[pl]) != 0
* }
* Note that a common prefix length of {@code 0} indicates that the first
* elements from each array mismatch.
*
* Two non-{@code null} arrays, {@code a} and {@code b}, share a proper
* prefix if the following expression is true:
*
{@code
* a.length != b.length &&
* Arrays.equals(a, 0, Math.min(a.length, b.length),
* b, 0, Math.min(a.length, b.length),
* cmp)
* }
*
* @param a the first array to be tested for a mismatch
* @param b the second array to be tested for a mismatch
* @param cmp the comparator to compare array elements
* @param the type of array elements
* @return the index of the first mismatch between the two arrays,
* otherwise {@code -1}.
* @throws NullPointerException
* if either array or the comparator is {@code null}
* @since 9
*/
public static int mismatch(T[] a, T[] b, Comparator cmp) {
Objects.requireNonNull(cmp);
int length = Math.min(a.length, b.length); // Check null array refs
if (a == b)
return -1;
for (int i = 0; i < length; i++) {
T oa = a[i];
T ob = b[i];
if (oa != ob) {
// Null-value comparison is deferred to the comparator
int v = cmp.compare(oa, ob);
if (v != 0) {
return i;
}
}
}
return a.length != b.length ? length : -1;
}
/**
* Finds and returns the relative index of the first mismatch between two
* {@code Object} arrays over the specified ranges, otherwise return -1 if
* no mismatch is found. The index will be in the range of 0 (inclusive) up
* to the length (inclusive) of the smaller range.
*
* If the two arrays, over the specified ranges, share a common prefix
* then the returned relative index is the length of the common prefix and
* it follows that there is a mismatch between the two elements at that
* relative index within the respective arrays.
* If one array is a proper prefix of the other, over the specified ranges,
* then the returned relative index is the length of the smaller range and
* it follows that the relative index is only valid for the array with the
* larger range.
* Otherwise, there is no mismatch.
*
*
Two non-{@code null} arrays, {@code a} and {@code b} with specified
* ranges [{@code aFromIndex}, {@code atoIndex}) and
* [{@code bFromIndex}, {@code btoIndex}) respectively, share a common
* prefix of length {@code pl} if the following expression is true:
*
{@code
* pl >= 0 &&
* pl < Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex) &&
* Arrays.equals(a, aFromIndex, aFromIndex + pl, b, bFromIndex, bFromIndex + pl, cmp) &&
* cmp.compare(a[aFromIndex + pl], b[bFromIndex + pl]) != 0
* }
* Note that a common prefix length of {@code 0} indicates that the first
* elements from each array mismatch.
*
* Two non-{@code null} arrays, {@code a} and {@code b} with specified
* ranges [{@code aFromIndex}, {@code atoIndex}) and
* [{@code bFromIndex}, {@code btoIndex}) respectively, share a proper
* if the following expression is true:
*
{@code
* (aToIndex - aFromIndex) != (bToIndex - bFromIndex) &&
* Arrays.equals(a, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
* b, 0, Math.min(aToIndex - aFromIndex, bToIndex - bFromIndex),
* cmp)
* }
*
* @param a the first array to be tested for a mismatch
* @param aFromIndex the index (inclusive) of the first element in the
* first array to be tested
* @param aToIndex the index (exclusive) of the last element in the
* first array to be tested
* @param b the second array to be tested for a mismatch
* @param bFromIndex the index (inclusive) of the first element in the
* second array to be tested
* @param bToIndex the index (exclusive) of the last element in the
* second array to be tested
* @param cmp the comparator to compare array elements
* @param the type of array elements
* @return the relative index of the first mismatch between the two arrays
* over the specified ranges, otherwise {@code -1}.
* @throws IllegalArgumentException
* if {@code aFromIndex > aToIndex} or
* if {@code bFromIndex > bToIndex}
* @throws ArrayIndexOutOfBoundsException
* if {@code aFromIndex < 0 or aToIndex > a.length} or
* if {@code bFromIndex < 0 or bToIndex > b.length}
* @throws NullPointerException
* if either array or the comparator is {@code null}
* @since 9
*/
public static int mismatch(
T[] a, int aFromIndex, int aToIndex,
T[] b, int bFromIndex, int bToIndex,
Comparator cmp) {
Objects.requireNonNull(cmp);
rangeCheck(a.length, aFromIndex, aToIndex);
rangeCheck(b.length, bFromIndex, bToIndex);
int aLength = aToIndex - aFromIndex;
int bLength = bToIndex - bFromIndex;
int length = Math.min(aLength, bLength);
for (int i = 0; i < length; i++) {
T oa = a[aFromIndex++];
T ob = b[bFromIndex++];
if (oa != ob) {
// Null-value comparison is deferred to the comparator
int v = cmp.compare(oa, ob);
if (v != 0) {
return i;
}
}
}
return aLength != bLength ? length : -1;
}
}