< prev index next >
src/java.base/share/classes/java/util/Arrays.java
Print this page
*** 1770,1783 ****
* 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, <tt>(-(<i>insertion point</i>) - 1)</tt>. The
* <i>insertion point</i> 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 <tt>a.length</tt> 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) {
--- 1770,1783 ----
* 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, <code>(-(<i>insertion point</i>) - 1)</code>. The
* <i>insertion point</i> 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) {
*** 1800,1814 ****
* 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, <tt>(-(<i>insertion point</i>) - 1)</tt>. The
* <i>insertion point</i> 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 <tt>toIndex</tt> 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}
--- 1800,1814 ----
* 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, <code>(-(<i>insertion point</i>) - 1)</code>. The
* <i>insertion point</i> 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}
*** 1851,1864 ****
* 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, <tt>(-(<i>insertion point</i>) - 1)</tt>. The
* <i>insertion point</i> 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 <tt>a.length</tt> 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) {
--- 1851,1864 ----
* 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, <code>(-(<i>insertion point</i>) - 1)</code>. The
* <i>insertion point</i> 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) {
*** 1881,1895 ****
* 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, <tt>(-(<i>insertion point</i>) - 1)</tt>. The
* <i>insertion point</i> 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 <tt>toIndex</tt> 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}
--- 1881,1895 ----
* 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, <code>(-(<i>insertion point</i>) - 1)</code>. The
* <i>insertion point</i> 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}
*** 1932,1945 ****
* 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, <tt>(-(<i>insertion point</i>) - 1)</tt>. The
* <i>insertion point</i> 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 <tt>a.length</tt> 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) {
--- 1932,1945 ----
* 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, <code>(-(<i>insertion point</i>) - 1)</code>. The
* <i>insertion point</i> 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) {
*** 1962,1976 ****
* 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, <tt>(-(<i>insertion point</i>) - 1)</tt>. The
* <i>insertion point</i> 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 <tt>toIndex</tt> 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}
--- 1962,1976 ----
* 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, <code>(-(<i>insertion point</i>) - 1)</code>. The
* <i>insertion point</i> 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}
*** 2013,2026 ****
* 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, <tt>(-(<i>insertion point</i>) - 1)</tt>. The
* <i>insertion point</i> 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 <tt>a.length</tt> 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) {
--- 2013,2026 ----
* 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, <code>(-(<i>insertion point</i>) - 1)</code>. The
* <i>insertion point</i> 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) {
*** 2043,2057 ****
* 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, <tt>(-(<i>insertion point</i>) - 1)</tt>. The
* <i>insertion point</i> 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 <tt>toIndex</tt> 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}
--- 2043,2057 ----
* 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, <code>(-(<i>insertion point</i>) - 1)</code>. The
* <i>insertion point</i> 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}
*** 2094,2107 ****
* 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, <tt>(-(<i>insertion point</i>) - 1)</tt>. The
* <i>insertion point</i> 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 <tt>a.length</tt> 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) {
--- 2094,2107 ----
* 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, <code>(-(<i>insertion point</i>) - 1)</code>. The
* <i>insertion point</i> 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) {
*** 2124,2138 ****
* 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, <tt>(-(<i>insertion point</i>) - 1)</tt>. The
* <i>insertion point</i> 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 <tt>toIndex</tt> 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}
--- 2124,2138 ----
* 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, <code>(-(<i>insertion point</i>) - 1)</code>. The
* <i>insertion point</i> 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}
*** 2176,2189 ****
* 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, <tt>(-(<i>insertion point</i>) - 1)</tt>. The
* <i>insertion point</i> 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 <tt>a.length</tt> 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) {
--- 2176,2189 ----
* 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, <code>(-(<i>insertion point</i>) - 1)</code>. The
* <i>insertion point</i> 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) {
*** 2207,2221 ****
* 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, <tt>(-(<i>insertion point</i>) - 1)</tt>. The
* <i>insertion point</i> 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 <tt>toIndex</tt> 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}
--- 2207,2221 ----
* 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, <code>(-(<i>insertion point</i>) - 1)</code>. The
* <i>insertion point</i> 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}
*** 2267,2280 ****
* 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, <tt>(-(<i>insertion point</i>) - 1)</tt>. The
* <i>insertion point</i> 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 <tt>a.length</tt> 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) {
--- 2267,2280 ----
* 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, <code>(-(<i>insertion point</i>) - 1)</code>. The
* <i>insertion point</i> 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) {
*** 2298,2312 ****
* 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, <tt>(-(<i>insertion point</i>) - 1)</tt>. The
* <i>insertion point</i> 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 <tt>toIndex</tt> 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}
--- 2298,2312 ----
* 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, <code>(-(<i>insertion point</i>) - 1)</code>. The
* <i>insertion point</i> 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}
*** 2364,2377 ****
* 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, <tt>(-(<i>insertion point</i>) - 1)</tt>. The
* <i>insertion point</i> 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 <tt>a.length</tt> 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.
--- 2364,2377 ----
* 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, <code>(-(<i>insertion point</i>) - 1)</code>. The
* <i>insertion point</i> 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.
*** 2402,2416 ****
* 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, <tt>(-(<i>insertion point</i>) - 1)</tt>. The
* <i>insertion point</i> 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 <tt>toIndex</tt> 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.
--- 2402,2416 ----
* 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, <code>(-(<i>insertion point</i>) - 1)</code>. The
* <i>insertion point</i> 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.
*** 2462,2478 ****
*
* @param <T> 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
! * <tt>null</tt> 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, <tt>(-(<i>insertion point</i>) - 1)</tt>. The
* <i>insertion point</i> 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 <tt>a.length</tt> 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
* <i>mutually comparable</i> using the specified comparator,
--- 2462,2478 ----
*
* @param <T> 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, <code>(-(<i>insertion point</i>) - 1)</code>. The
* <i>insertion point</i> 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
* <i>mutually comparable</i> using the specified comparator,
*** 2501,2519 ****
* @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
! * <tt>null</tt> 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, <tt>(-(<i>insertion point</i>) - 1)</tt>. The
* <i>insertion point</i> 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 <tt>toIndex</tt> 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
* <i>mutually comparable</i> using the specified comparator,
--- 2501,2519 ----
* @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, <code>(-(<i>insertion point</i>) - 1)</code>. The
* <i>insertion point</i> 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
* <i>mutually comparable</i> using the specified comparator,
*** 2555,2574 ****
}
// Equality Testing
/**
! * Returns <tt>true</tt> if the two specified arrays of longs are
* <i>equal</i> 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 <tt>null</tt>.
*
* @param a one array to be tested for equality
* @param a2 the other array to be tested for equality
! * @return <tt>true</tt> if the two arrays are equal
*/
public static boolean equals(long[] a, long[] a2) {
if (a==a2)
return true;
if (a==null || a2==null)
--- 2555,2574 ----
}
// Equality Testing
/**
! * Returns {@code true} if the two specified arrays of longs are
* <i>equal</i> 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)
*** 2584,2603 ****
return true;
}
/**
! * Returns <tt>true</tt> if the two specified arrays of ints are
* <i>equal</i> 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 <tt>null</tt>.
*
* @param a one array to be tested for equality
* @param a2 the other array to be tested for equality
! * @return <tt>true</tt> if the two arrays are equal
*/
public static boolean equals(int[] a, int[] a2) {
if (a==a2)
return true;
if (a==null || a2==null)
--- 2584,2603 ----
return true;
}
/**
! * Returns {@code true} if the two specified arrays of ints are
* <i>equal</i> 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)
*** 2613,2632 ****
return true;
}
/**
! * Returns <tt>true</tt> if the two specified arrays of shorts are
* <i>equal</i> 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 <tt>null</tt>.
*
* @param a one array to be tested for equality
* @param a2 the other array to be tested for equality
! * @return <tt>true</tt> if the two arrays are equal
*/
public static boolean equals(short[] a, short a2[]) {
if (a==a2)
return true;
if (a==null || a2==null)
--- 2613,2632 ----
return true;
}
/**
! * Returns {@code true} if the two specified arrays of shorts are
* <i>equal</i> 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)
*** 2642,2661 ****
return true;
}
/**
! * Returns <tt>true</tt> if the two specified arrays of chars are
* <i>equal</i> 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 <tt>null</tt>.
*
* @param a one array to be tested for equality
* @param a2 the other array to be tested for equality
! * @return <tt>true</tt> if the two arrays are equal
*/
@HotSpotIntrinsicCandidate
public static boolean equals(char[] a, char[] a2) {
if (a==a2)
return true;
--- 2642,2661 ----
return true;
}
/**
! * Returns {@code true} if the two specified arrays of chars are
* <i>equal</i> 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;
*** 2672,2691 ****
return true;
}
/**
! * Returns <tt>true</tt> if the two specified arrays of bytes are
* <i>equal</i> 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 <tt>null</tt>.
*
* @param a one array to be tested for equality
* @param a2 the other array to be tested for equality
! * @return <tt>true</tt> if the two arrays are equal
*/
public static boolean equals(byte[] a, byte[] a2) {
if (a==a2)
return true;
if (a==null || a2==null)
--- 2672,2691 ----
return true;
}
/**
! * Returns {@code true} if the two specified arrays of bytes are
* <i>equal</i> 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(byte[] a, byte[] a2) {
if (a==a2)
return true;
if (a==null || a2==null)
*** 2701,2720 ****
return true;
}
/**
! * Returns <tt>true</tt> if the two specified arrays of booleans are
* <i>equal</i> 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 <tt>null</tt>.
*
* @param a one array to be tested for equality
* @param a2 the other array to be tested for equality
! * @return <tt>true</tt> if the two arrays are equal
*/
public static boolean equals(boolean[] a, boolean[] a2) {
if (a==a2)
return true;
if (a==null || a2==null)
--- 2701,2720 ----
return true;
}
/**
! * Returns {@code true} if the two specified arrays of booleans are
* <i>equal</i> 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)
*** 2730,2754 ****
return true;
}
/**
! * Returns <tt>true</tt> if the two specified arrays of doubles are
* <i>equal</i> 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 <tt>null</tt>.
*
! * Two doubles <tt>d1</tt> and <tt>d2</tt> are considered equal if:
! * <pre> <tt>new Double(d1).equals(new Double(d2))</tt></pre>
! * (Unlike the <tt>==</tt> operator, this method considers
! * <tt>NaN</tt> 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 <tt>true</tt> if the two arrays are equal
* @see Double#equals(Object)
*/
public static boolean equals(double[] a, double[] a2) {
if (a==a2)
return true;
--- 2730,2754 ----
return true;
}
/**
! * Returns {@code true} if the two specified arrays of doubles are
* <i>equal</i> 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:
! * <pre> {@code new Double(d1).equals(new Double(d2))}</pre>
! * (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;
*** 2765,2789 ****
return true;
}
/**
! * Returns <tt>true</tt> if the two specified arrays of floats are
* <i>equal</i> 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 <tt>null</tt>.
*
! * Two floats <tt>f1</tt> and <tt>f2</tt> are considered equal if:
! * <pre> <tt>new Float(f1).equals(new Float(f2))</tt></pre>
! * (Unlike the <tt>==</tt> operator, this method considers
! * <tt>NaN</tt> 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 <tt>true</tt> if the two arrays are equal
* @see Float#equals(Object)
*/
public static boolean equals(float[] a, float[] a2) {
if (a==a2)
return true;
--- 2765,2789 ----
return true;
}
/**
! * Returns {@code true} if the two specified arrays of floats are
* <i>equal</i> 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:
! * <pre> {@code new Float(f1).equals(new Float(f2))}</pre>
! * (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;
*** 2800,2821 ****
return true;
}
/**
! * Returns <tt>true</tt> if the two specified arrays of Objects are
* <i>equal</i> 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 <tt>e1</tt>
! * and <tt>e2</tt> are considered <i>equal</i> if <tt>(e1==null ? e2==null
! * : e1.equals(e2))</tt>. 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 <tt>null</tt>.
*
* @param a one array to be tested for equality
* @param a2 the other array to be tested for equality
! * @return <tt>true</tt> if the two arrays are equal
*/
public static boolean equals(Object[] a, Object[] a2) {
if (a==a2)
return true;
if (a==null || a2==null)
--- 2800,2821 ----
return true;
}
/**
! * Returns {@code true} if the two specified arrays of Objects are
* <i>equal</i> 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 <i>equal</i> if {@code (e1==null ? e2==null
! * : e1.equals(e2))}. In other words, the two arrays are equal if
* they contain the same elements in the same order. Also, two array
! * references are considered equal if both are {@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)
*** 2850,2872 ****
}
/**
* 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 <tt>fromIndex</tt>, inclusive, to index
! * <tt>toIndex</tt>, exclusive. (If <tt>fromIndex==toIndex</tt>, 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 <tt>fromIndex > toIndex</tt>
! * @throws ArrayIndexOutOfBoundsException if <tt>fromIndex < 0</tt> or
! * <tt>toIndex > a.length</tt>
*/
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;
--- 2850,2872 ----
}
/**
* 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;
*** 2885,2907 ****
}
/**
* 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 <tt>fromIndex</tt>, inclusive, to index
! * <tt>toIndex</tt>, exclusive. (If <tt>fromIndex==toIndex</tt>, 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 <tt>fromIndex > toIndex</tt>
! * @throws ArrayIndexOutOfBoundsException if <tt>fromIndex < 0</tt> or
! * <tt>toIndex > a.length</tt>
*/
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;
--- 2885,2907 ----
}
/**
* 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;
*** 2920,2942 ****
}
/**
* 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 <tt>fromIndex</tt>, inclusive, to index
! * <tt>toIndex</tt>, exclusive. (If <tt>fromIndex==toIndex</tt>, 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 <tt>fromIndex > toIndex</tt>
! * @throws ArrayIndexOutOfBoundsException if <tt>fromIndex < 0</tt> or
! * <tt>toIndex > a.length</tt>
*/
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;
--- 2920,2942 ----
}
/**
* 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;
*** 2955,2977 ****
}
/**
* 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 <tt>fromIndex</tt>, inclusive, to index
! * <tt>toIndex</tt>, exclusive. (If <tt>fromIndex==toIndex</tt>, 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 <tt>fromIndex > toIndex</tt>
! * @throws ArrayIndexOutOfBoundsException if <tt>fromIndex < 0</tt> or
! * <tt>toIndex > a.length</tt>
*/
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;
--- 2955,2977 ----
}
/**
* 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;
*** 2990,3012 ****
}
/**
* 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 <tt>fromIndex</tt>, inclusive, to index
! * <tt>toIndex</tt>, exclusive. (If <tt>fromIndex==toIndex</tt>, 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 <tt>fromIndex > toIndex</tt>
! * @throws ArrayIndexOutOfBoundsException if <tt>fromIndex < 0</tt> or
! * <tt>toIndex > a.length</tt>
*/
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;
--- 2990,3012 ----
}
/**
* 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;
*** 3025,3047 ****
}
/**
* 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 <tt>fromIndex</tt>, inclusive, to index
! * <tt>toIndex</tt>, exclusive. (If <tt>fromIndex==toIndex</tt>, 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 <tt>fromIndex > toIndex</tt>
! * @throws ArrayIndexOutOfBoundsException if <tt>fromIndex < 0</tt> or
! * <tt>toIndex > a.length</tt>
*/
public static void fill(boolean[] a, int fromIndex, int toIndex,
boolean val) {
rangeCheck(a.length, fromIndex, toIndex);
for (int i = fromIndex; i < toIndex; i++)
--- 3025,3047 ----
}
/**
* 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++)
*** 3061,3083 ****
}
/**
* 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 <tt>fromIndex</tt>, inclusive, to index
! * <tt>toIndex</tt>, exclusive. (If <tt>fromIndex==toIndex</tt>, 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 <tt>fromIndex > toIndex</tt>
! * @throws ArrayIndexOutOfBoundsException if <tt>fromIndex < 0</tt> or
! * <tt>toIndex > a.length</tt>
*/
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;
--- 3061,3083 ----
}
/**
* 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;
*** 3096,3118 ****
}
/**
* 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 <tt>fromIndex</tt>, inclusive, to index
! * <tt>toIndex</tt>, exclusive. (If <tt>fromIndex==toIndex</tt>, 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 <tt>fromIndex > toIndex</tt>
! * @throws ArrayIndexOutOfBoundsException if <tt>fromIndex < 0</tt> or
! * <tt>toIndex > a.length</tt>
*/
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;
--- 3096,3118 ----
}
/**
* 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;
*** 3133,3155 ****
}
/**
* 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 <tt>fromIndex</tt>, inclusive, to index
! * <tt>toIndex</tt>, exclusive. (If <tt>fromIndex==toIndex</tt>, 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 <tt>fromIndex > toIndex</tt>
! * @throws ArrayIndexOutOfBoundsException if <tt>fromIndex < 0</tt> or
! * <tt>toIndex > a.length</tt>
* @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);
--- 3133,3155 ----
}
/**
* 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);
*** 3162,3183 ****
/**
* 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 <tt>null</tt>.
* 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 <T> 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 <tt>newLength</tt> is negative
! * @throws NullPointerException if <tt>original</tt> is null
* @since 1.6
*/
@SuppressWarnings("unchecked")
public static <T> T[] copyOf(T[] original, int newLength) {
return (T[]) copyOf(original, newLength, original.getClass());
--- 3162,3183 ----
/**
* 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 <T> 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> T[] copyOf(T[] original, int newLength) {
return (T[]) copyOf(original, newLength, original.getClass());
*** 3186,3212 ****
/**
* 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 <tt>null</tt>.
* 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 <tt>newType</tt>.
*
* @param <U> the class of the objects in the original array
* @param <T> 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 <tt>newLength</tt> is negative
! * @throws NullPointerException if <tt>original</tt> is null
* @throws ArrayStoreException if an element copied from
! * <tt>original</tt> is not of a runtime type that can be stored in
! * an array of class <tt>newType</tt>
* @since 1.6
*/
@HotSpotIntrinsicCandidate
public static <T,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
@SuppressWarnings("unchecked")
--- 3186,3212 ----
/**
* 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 <U> the class of the objects in the original array
* @param <T> 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,U> T[] copyOf(U[] original, int newLength, Class<? extends T[]> newType) {
@SuppressWarnings("unchecked")
*** 3221,3240 ****
/**
* 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 <tt>(byte)0</tt>.
* 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 <tt>newLength</tt> is negative
! * @throws NullPointerException if <tt>original</tt> is null
* @since 1.6
*/
public static byte[] copyOf(byte[] original, int newLength) {
byte[] copy = new byte[newLength];
System.arraycopy(original, 0, copy, 0,
--- 3221,3240 ----
/**
* 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,
*** 3245,3264 ****
/**
* 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 <tt>(short)0</tt>.
* 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 <tt>newLength</tt> is negative
! * @throws NullPointerException if <tt>original</tt> is null
* @since 1.6
*/
public static short[] copyOf(short[] original, int newLength) {
short[] copy = new short[newLength];
System.arraycopy(original, 0, copy, 0,
--- 3245,3264 ----
/**
* 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,
*** 3269,3288 ****
/**
* 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 <tt>0</tt>.
* 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 <tt>newLength</tt> is negative
! * @throws NullPointerException if <tt>original</tt> is null
* @since 1.6
*/
public static int[] copyOf(int[] original, int newLength) {
int[] copy = new int[newLength];
System.arraycopy(original, 0, copy, 0,
--- 3269,3288 ----
/**
* 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,
*** 3293,3312 ****
/**
* 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 <tt>0L</tt>.
* 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 <tt>newLength</tt> is negative
! * @throws NullPointerException if <tt>original</tt> is null
* @since 1.6
*/
public static long[] copyOf(long[] original, int newLength) {
long[] copy = new long[newLength];
System.arraycopy(original, 0, copy, 0,
--- 3293,3312 ----
/**
* 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,
*** 3317,3336 ****
/**
* 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 <tt>'\\u000'</tt>. 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 <tt>newLength</tt> is negative
! * @throws NullPointerException if <tt>original</tt> is null
* @since 1.6
*/
public static char[] copyOf(char[] original, int newLength) {
char[] copy = new char[newLength];
System.arraycopy(original, 0, copy, 0,
--- 3317,3336 ----
/**
* 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,
*** 3341,3360 ****
/**
* 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 <tt>0f</tt>.
* 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 <tt>newLength</tt> is negative
! * @throws NullPointerException if <tt>original</tt> is null
* @since 1.6
*/
public static float[] copyOf(float[] original, int newLength) {
float[] copy = new float[newLength];
System.arraycopy(original, 0, copy, 0,
--- 3341,3360 ----
/**
* 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,
*** 3365,3408 ****
/**
* 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 <tt>0d</tt>.
* 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 <tt>newLength</tt> is negative
! * @throws NullPointerException if <tt>original</tt> 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 <tt>false</tt> (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 <tt>false</tt>.
* 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 <tt>newLength</tt> is negative
! * @throws NullPointerException if <tt>original</tt> is null
* @since 1.6
*/
public static boolean[] copyOf(boolean[] original, int newLength) {
boolean[] copy = new boolean[newLength];
System.arraycopy(original, 0, copy, 0,
--- 3365,3408 ----
/**
* 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,
*** 3410,3430 ****
return copy;
}
/**
* Copies the specified range of the specified array into a new array.
! * The initial index of the range (<tt>from</tt>) must lie between zero
! * and <tt>original.length</tt>, inclusive. The value at
! * <tt>original[from]</tt> is placed into the initial element of the copy
! * (unless <tt>from == original.length</tt> or <tt>from == to</tt>).
* Values from subsequent elements in the original array are placed into
* subsequent elements in the copy. The final index of the range
! * (<tt>to</tt>), which must be greater than or equal to <tt>from</tt>,
! * may be greater than <tt>original.length</tt>, in which case
! * <tt>null</tt> is placed in all elements of the copy whose index is
! * greater than or equal to <tt>original.length - from</tt>. The length
! * of the returned array will be <tt>to - from</tt>.
* <p>
* The resulting array is of exactly the same class as the original array.
*
* @param <T> the class of the objects in the array
* @param original the array from which a range is to be copied
--- 3410,3430 ----
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}.
* <p>
* The resulting array is of exactly the same class as the original array.
*
* @param <T> the class of the objects in the array
* @param original the array from which a range is to be copied
*** 3433,3465 ****
* (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 <tt>from > to</tt>
! * @throws NullPointerException if <tt>original</tt> is null
* @since 1.6
*/
@SuppressWarnings("unchecked")
public static <T> T[] copyOfRange(T[] original, int from, int to) {
return copyOfRange(original, from, to, (Class<? extends T[]>) original.getClass());
}
/**
* Copies the specified range of the specified array into a new array.
! * The initial index of the range (<tt>from</tt>) must lie between zero
! * and <tt>original.length</tt>, inclusive. The value at
! * <tt>original[from]</tt> is placed into the initial element of the copy
! * (unless <tt>from == original.length</tt> or <tt>from == to</tt>).
* Values from subsequent elements in the original array are placed into
* subsequent elements in the copy. The final index of the range
! * (<tt>to</tt>), which must be greater than or equal to <tt>from</tt>,
! * may be greater than <tt>original.length</tt>, in which case
! * <tt>null</tt> is placed in all elements of the copy whose index is
! * greater than or equal to <tt>original.length - from</tt>. The length
! * of the returned array will be <tt>to - from</tt>.
! * The resulting array is of the class <tt>newType</tt>.
*
* @param <U> the class of the objects in the original array
* @param <T> 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
--- 3433,3465 ----
* (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> T[] copyOfRange(T[] original, int from, int to) {
return copyOfRange(original, from, to, (Class<? extends T[]>) 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 <U> the class of the objects in the original array
* @param <T> 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
*** 3468,3482 ****
* @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 <tt>from > to</tt>
! * @throws NullPointerException if <tt>original</tt> is null
* @throws ArrayStoreException if an element copied from
! * <tt>original</tt> is not of a runtime type that can be stored in
! * an array of class <tt>newType</tt>.
* @since 1.6
*/
@HotSpotIntrinsicCandidate
public static <T,U> T[] copyOfRange(U[] original, int from, int to, Class<? extends T[]> newType) {
int newLength = to - from;
--- 3468,3482 ----
* @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,U> T[] copyOfRange(U[] original, int from, int to, Class<? extends T[]> newType) {
int newLength = to - from;
*** 3491,3522 ****
return copy;
}
/**
* Copies the specified range of the specified array into a new array.
! * The initial index of the range (<tt>from</tt>) must lie between zero
! * and <tt>original.length</tt>, inclusive. The value at
! * <tt>original[from]</tt> is placed into the initial element of the copy
! * (unless <tt>from == original.length</tt> or <tt>from == to</tt>).
* Values from subsequent elements in the original array are placed into
* subsequent elements in the copy. The final index of the range
! * (<tt>to</tt>), which must be greater than or equal to <tt>from</tt>,
! * may be greater than <tt>original.length</tt>, in which case
! * <tt>(byte)0</tt> is placed in all elements of the copy whose index is
! * greater than or equal to <tt>original.length - from</tt>. The length
! * of the returned array will be <tt>to - from</tt>.
*
* @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 <tt>from > to</tt>
! * @throws NullPointerException if <tt>original</tt> is null
* @since 1.6
*/
public static byte[] copyOfRange(byte[] original, int from, int to) {
int newLength = to - from;
if (newLength < 0)
--- 3491,3522 ----
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)
*** 3527,3558 ****
return copy;
}
/**
* Copies the specified range of the specified array into a new array.
! * The initial index of the range (<tt>from</tt>) must lie between zero
! * and <tt>original.length</tt>, inclusive. The value at
! * <tt>original[from]</tt> is placed into the initial element of the copy
! * (unless <tt>from == original.length</tt> or <tt>from == to</tt>).
* Values from subsequent elements in the original array are placed into
* subsequent elements in the copy. The final index of the range
! * (<tt>to</tt>), which must be greater than or equal to <tt>from</tt>,
! * may be greater than <tt>original.length</tt>, in which case
! * <tt>(short)0</tt> is placed in all elements of the copy whose index is
! * greater than or equal to <tt>original.length - from</tt>. The length
! * of the returned array will be <tt>to - from</tt>.
*
* @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 <tt>from > to</tt>
! * @throws NullPointerException if <tt>original</tt> is null
* @since 1.6
*/
public static short[] copyOfRange(short[] original, int from, int to) {
int newLength = to - from;
if (newLength < 0)
--- 3527,3558 ----
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)
*** 3563,3594 ****
return copy;
}
/**
* Copies the specified range of the specified array into a new array.
! * The initial index of the range (<tt>from</tt>) must lie between zero
! * and <tt>original.length</tt>, inclusive. The value at
! * <tt>original[from]</tt> is placed into the initial element of the copy
! * (unless <tt>from == original.length</tt> or <tt>from == to</tt>).
* Values from subsequent elements in the original array are placed into
* subsequent elements in the copy. The final index of the range
! * (<tt>to</tt>), which must be greater than or equal to <tt>from</tt>,
! * may be greater than <tt>original.length</tt>, in which case
! * <tt>0</tt> is placed in all elements of the copy whose index is
! * greater than or equal to <tt>original.length - from</tt>. The length
! * of the returned array will be <tt>to - from</tt>.
*
* @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 <tt>from > to</tt>
! * @throws NullPointerException if <tt>original</tt> is null
* @since 1.6
*/
public static int[] copyOfRange(int[] original, int from, int to) {
int newLength = to - from;
if (newLength < 0)
--- 3563,3594 ----
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)
*** 3599,3630 ****
return copy;
}
/**
* Copies the specified range of the specified array into a new array.
! * The initial index of the range (<tt>from</tt>) must lie between zero
! * and <tt>original.length</tt>, inclusive. The value at
! * <tt>original[from]</tt> is placed into the initial element of the copy
! * (unless <tt>from == original.length</tt> or <tt>from == to</tt>).
* Values from subsequent elements in the original array are placed into
* subsequent elements in the copy. The final index of the range
! * (<tt>to</tt>), which must be greater than or equal to <tt>from</tt>,
! * may be greater than <tt>original.length</tt>, in which case
! * <tt>0L</tt> is placed in all elements of the copy whose index is
! * greater than or equal to <tt>original.length - from</tt>. The length
! * of the returned array will be <tt>to - from</tt>.
*
* @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 <tt>from > to</tt>
! * @throws NullPointerException if <tt>original</tt> is null
* @since 1.6
*/
public static long[] copyOfRange(long[] original, int from, int to) {
int newLength = to - from;
if (newLength < 0)
--- 3599,3630 ----
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)
*** 3635,3666 ****
return copy;
}
/**
* Copies the specified range of the specified array into a new array.
! * The initial index of the range (<tt>from</tt>) must lie between zero
! * and <tt>original.length</tt>, inclusive. The value at
! * <tt>original[from]</tt> is placed into the initial element of the copy
! * (unless <tt>from == original.length</tt> or <tt>from == to</tt>).
* Values from subsequent elements in the original array are placed into
* subsequent elements in the copy. The final index of the range
! * (<tt>to</tt>), which must be greater than or equal to <tt>from</tt>,
! * may be greater than <tt>original.length</tt>, in which case
! * <tt>'\\u000'</tt> is placed in all elements of the copy whose index is
! * greater than or equal to <tt>original.length - from</tt>. The length
! * of the returned array will be <tt>to - from</tt>.
*
* @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 <tt>from > to</tt>
! * @throws NullPointerException if <tt>original</tt> is null
* @since 1.6
*/
public static char[] copyOfRange(char[] original, int from, int to) {
int newLength = to - from;
if (newLength < 0)
--- 3635,3666 ----
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)
*** 3671,3702 ****
return copy;
}
/**
* Copies the specified range of the specified array into a new array.
! * The initial index of the range (<tt>from</tt>) must lie between zero
! * and <tt>original.length</tt>, inclusive. The value at
! * <tt>original[from]</tt> is placed into the initial element of the copy
! * (unless <tt>from == original.length</tt> or <tt>from == to</tt>).
* Values from subsequent elements in the original array are placed into
* subsequent elements in the copy. The final index of the range
! * (<tt>to</tt>), which must be greater than or equal to <tt>from</tt>,
! * may be greater than <tt>original.length</tt>, in which case
! * <tt>0f</tt> is placed in all elements of the copy whose index is
! * greater than or equal to <tt>original.length - from</tt>. The length
! * of the returned array will be <tt>to - from</tt>.
*
* @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 <tt>from > to</tt>
! * @throws NullPointerException if <tt>original</tt> is null
* @since 1.6
*/
public static float[] copyOfRange(float[] original, int from, int to) {
int newLength = to - from;
if (newLength < 0)
--- 3671,3702 ----
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)
*** 3707,3738 ****
return copy;
}
/**
* Copies the specified range of the specified array into a new array.
! * The initial index of the range (<tt>from</tt>) must lie between zero
! * and <tt>original.length</tt>, inclusive. The value at
! * <tt>original[from]</tt> is placed into the initial element of the copy
! * (unless <tt>from == original.length</tt> or <tt>from == to</tt>).
* Values from subsequent elements in the original array are placed into
* subsequent elements in the copy. The final index of the range
! * (<tt>to</tt>), which must be greater than or equal to <tt>from</tt>,
! * may be greater than <tt>original.length</tt>, in which case
! * <tt>0d</tt> is placed in all elements of the copy whose index is
! * greater than or equal to <tt>original.length - from</tt>. The length
! * of the returned array will be <tt>to - from</tt>.
*
* @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 <tt>from > to</tt>
! * @throws NullPointerException if <tt>original</tt> is null
* @since 1.6
*/
public static double[] copyOfRange(double[] original, int from, int to) {
int newLength = to - from;
if (newLength < 0)
--- 3707,3738 ----
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)
*** 3743,3774 ****
return copy;
}
/**
* Copies the specified range of the specified array into a new array.
! * The initial index of the range (<tt>from</tt>) must lie between zero
! * and <tt>original.length</tt>, inclusive. The value at
! * <tt>original[from]</tt> is placed into the initial element of the copy
! * (unless <tt>from == original.length</tt> or <tt>from == to</tt>).
* Values from subsequent elements in the original array are placed into
* subsequent elements in the copy. The final index of the range
! * (<tt>to</tt>), which must be greater than or equal to <tt>from</tt>,
! * may be greater than <tt>original.length</tt>, in which case
! * <tt>false</tt> is placed in all elements of the copy whose index is
! * greater than or equal to <tt>original.length - from</tt>. The length
! * of the returned array will be <tt>to - from</tt>.
*
* @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 <tt>from > to</tt>
! * @throws NullPointerException if <tt>original</tt> is null
* @since 1.6
*/
public static boolean[] copyOfRange(boolean[] original, int from, int to) {
int newLength = to - from;
if (newLength < 0)
--- 3743,3774 ----
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)
*** 3900,3921 ****
}
}
/**
* Returns a hash code based on the contents of the specified array.
! * For any two <tt>long</tt> arrays <tt>a</tt> and <tt>b</tt>
! * such that <tt>Arrays.equals(a, b)</tt>, it is also the case that
! * <tt>Arrays.hashCode(a) == Arrays.hashCode(b)</tt>.
*
* <p>The value returned by this method is the same value that would be
! * obtained by invoking the {@link List#hashCode() <tt>hashCode</tt>}
* method on a {@link List} containing a sequence of {@link Long}
! * instances representing the elements of <tt>a</tt> in the same order.
! * If <tt>a</tt> is <tt>null</tt>, this method returns 0.
*
* @param a the array whose hash value to compute
! * @return a content-based hash code for <tt>a</tt>
* @since 1.5
*/
public static int hashCode(long a[]) {
if (a == null)
return 0;
--- 3900,3921 ----
}
}
/**
* 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)}.
*
* <p>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;
*** 3929,3950 ****
return result;
}
/**
* Returns a hash code based on the contents of the specified array.
! * For any two non-null <tt>int</tt> arrays <tt>a</tt> and <tt>b</tt>
! * such that <tt>Arrays.equals(a, b)</tt>, it is also the case that
! * <tt>Arrays.hashCode(a) == Arrays.hashCode(b)</tt>.
*
* <p>The value returned by this method is the same value that would be
! * obtained by invoking the {@link List#hashCode() <tt>hashCode</tt>}
* method on a {@link List} containing a sequence of {@link Integer}
! * instances representing the elements of <tt>a</tt> in the same order.
! * If <tt>a</tt> is <tt>null</tt>, this method returns 0.
*
* @param a the array whose hash value to compute
! * @return a content-based hash code for <tt>a</tt>
* @since 1.5
*/
public static int hashCode(int a[]) {
if (a == null)
return 0;
--- 3929,3950 ----
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)}.
*
* <p>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;
*** 3956,3977 ****
return result;
}
/**
* Returns a hash code based on the contents of the specified array.
! * For any two <tt>short</tt> arrays <tt>a</tt> and <tt>b</tt>
! * such that <tt>Arrays.equals(a, b)</tt>, it is also the case that
! * <tt>Arrays.hashCode(a) == Arrays.hashCode(b)</tt>.
*
* <p>The value returned by this method is the same value that would be
! * obtained by invoking the {@link List#hashCode() <tt>hashCode</tt>}
* method on a {@link List} containing a sequence of {@link Short}
! * instances representing the elements of <tt>a</tt> in the same order.
! * If <tt>a</tt> is <tt>null</tt>, this method returns 0.
*
* @param a the array whose hash value to compute
! * @return a content-based hash code for <tt>a</tt>
* @since 1.5
*/
public static int hashCode(short a[]) {
if (a == null)
return 0;
--- 3956,3977 ----
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)}.
*
* <p>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;
*** 3983,4004 ****
return result;
}
/**
* Returns a hash code based on the contents of the specified array.
! * For any two <tt>char</tt> arrays <tt>a</tt> and <tt>b</tt>
! * such that <tt>Arrays.equals(a, b)</tt>, it is also the case that
! * <tt>Arrays.hashCode(a) == Arrays.hashCode(b)</tt>.
*
* <p>The value returned by this method is the same value that would be
! * obtained by invoking the {@link List#hashCode() <tt>hashCode</tt>}
* method on a {@link List} containing a sequence of {@link Character}
! * instances representing the elements of <tt>a</tt> in the same order.
! * If <tt>a</tt> is <tt>null</tt>, this method returns 0.
*
* @param a the array whose hash value to compute
! * @return a content-based hash code for <tt>a</tt>
* @since 1.5
*/
public static int hashCode(char a[]) {
if (a == null)
return 0;
--- 3983,4004 ----
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)}.
*
* <p>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;
*** 4010,4031 ****
return result;
}
/**
* Returns a hash code based on the contents of the specified array.
! * For any two <tt>byte</tt> arrays <tt>a</tt> and <tt>b</tt>
! * such that <tt>Arrays.equals(a, b)</tt>, it is also the case that
! * <tt>Arrays.hashCode(a) == Arrays.hashCode(b)</tt>.
*
* <p>The value returned by this method is the same value that would be
! * obtained by invoking the {@link List#hashCode() <tt>hashCode</tt>}
* method on a {@link List} containing a sequence of {@link Byte}
! * instances representing the elements of <tt>a</tt> in the same order.
! * If <tt>a</tt> is <tt>null</tt>, this method returns 0.
*
* @param a the array whose hash value to compute
! * @return a content-based hash code for <tt>a</tt>
* @since 1.5
*/
public static int hashCode(byte a[]) {
if (a == null)
return 0;
--- 4010,4031 ----
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)}.
*
* <p>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;
*** 4037,4058 ****
return result;
}
/**
* Returns a hash code based on the contents of the specified array.
! * For any two <tt>boolean</tt> arrays <tt>a</tt> and <tt>b</tt>
! * such that <tt>Arrays.equals(a, b)</tt>, it is also the case that
! * <tt>Arrays.hashCode(a) == Arrays.hashCode(b)</tt>.
*
* <p>The value returned by this method is the same value that would be
! * obtained by invoking the {@link List#hashCode() <tt>hashCode</tt>}
* method on a {@link List} containing a sequence of {@link Boolean}
! * instances representing the elements of <tt>a</tt> in the same order.
! * If <tt>a</tt> is <tt>null</tt>, this method returns 0.
*
* @param a the array whose hash value to compute
! * @return a content-based hash code for <tt>a</tt>
* @since 1.5
*/
public static int hashCode(boolean a[]) {
if (a == null)
return 0;
--- 4037,4058 ----
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)}.
*
* <p>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;
*** 4064,4085 ****
return result;
}
/**
* Returns a hash code based on the contents of the specified array.
! * For any two <tt>float</tt> arrays <tt>a</tt> and <tt>b</tt>
! * such that <tt>Arrays.equals(a, b)</tt>, it is also the case that
! * <tt>Arrays.hashCode(a) == Arrays.hashCode(b)</tt>.
*
* <p>The value returned by this method is the same value that would be
! * obtained by invoking the {@link List#hashCode() <tt>hashCode</tt>}
* method on a {@link List} containing a sequence of {@link Float}
! * instances representing the elements of <tt>a</tt> in the same order.
! * If <tt>a</tt> is <tt>null</tt>, this method returns 0.
*
* @param a the array whose hash value to compute
! * @return a content-based hash code for <tt>a</tt>
* @since 1.5
*/
public static int hashCode(float a[]) {
if (a == null)
return 0;
--- 4064,4085 ----
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)}.
*
* <p>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;
*** 4091,4112 ****
return result;
}
/**
* Returns a hash code based on the contents of the specified array.
! * For any two <tt>double</tt> arrays <tt>a</tt> and <tt>b</tt>
! * such that <tt>Arrays.equals(a, b)</tt>, it is also the case that
! * <tt>Arrays.hashCode(a) == Arrays.hashCode(b)</tt>.
*
* <p>The value returned by this method is the same value that would be
! * obtained by invoking the {@link List#hashCode() <tt>hashCode</tt>}
* method on a {@link List} containing a sequence of {@link Double}
! * instances representing the elements of <tt>a</tt> in the same order.
! * If <tt>a</tt> is <tt>null</tt>, this method returns 0.
*
* @param a the array whose hash value to compute
! * @return a content-based hash code for <tt>a</tt>
* @since 1.5
*/
public static int hashCode(double a[]) {
if (a == null)
return 0;
--- 4091,4112 ----
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)}.
*
* <p>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;
*** 4125,4144 ****
* 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.
*
! * <p>For any two arrays <tt>a</tt> and <tt>b</tt> such that
! * <tt>Arrays.equals(a, b)</tt>, it is also the case that
! * <tt>Arrays.hashCode(a) == Arrays.hashCode(b)</tt>.
*
* <p>The value returned by this method is equal to the value that would
! * be returned by <tt>Arrays.asList(a).hashCode()</tt>, unless <tt>a</tt>
! * is <tt>null</tt>, in which case <tt>0</tt> is returned.
*
* @param a the array whose content-based hash code to compute
! * @return a content-based hash code for <tt>a</tt>
* @see #deepHashCode(Object[])
* @since 1.5
*/
public static int hashCode(Object a[]) {
if (a == null)
--- 4125,4144 ----
* 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.
*
! * <p>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)}.
*
* <p>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)
*** 4159,4185 ****
* 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.
*
! * <p>For any two arrays <tt>a</tt> and <tt>b</tt> such that
! * <tt>Arrays.deepEquals(a, b)</tt>, it is also the case that
! * <tt>Arrays.deepHashCode(a) == Arrays.deepHashCode(b)</tt>.
*
* <p>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 <tt>a</tt> in the same order, with one
! * difference: If an element <tt>e</tt> of <tt>a</tt> is itself an array,
! * its hash code is computed not by calling <tt>e.hashCode()</tt>, but as
! * by calling the appropriate overloading of <tt>Arrays.hashCode(e)</tt>
! * if <tt>e</tt> is an array of a primitive type, or as by calling
! * <tt>Arrays.deepHashCode(e)</tt> recursively if <tt>e</tt> is an array
! * of a reference type. If <tt>a</tt> is <tt>null</tt>, this method
* returns 0.
*
* @param a the array whose deep-content-based hash code to compute
! * @return a deep-content-based hash code for <tt>a</tt>
* @see #hashCode(Object[])
* @since 1.5
*/
public static int deepHashCode(Object a[]) {
if (a == null)
--- 4159,4185 ----
* 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.
*
! * <p>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)}.
*
* <p>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)
*** 4215,4254 ****
return result;
}
/**
! * Returns <tt>true</tt> if the two specified arrays are <i>deeply
* equal</i> to one another. Unlike the {@link #equals(Object[],Object[])}
* method, this method is appropriate for use with nested arrays of
* arbitrary depth.
*
* <p>Two array references are considered deeply equal if both
! * are <tt>null</tt>, 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.
*
! * <p>Two possibly <tt>null</tt> elements <tt>e1</tt> and <tt>e2</tt> are
* deeply equal if any of the following conditions hold:
* <ul>
! * <li> <tt>e1</tt> and <tt>e2</tt> are both arrays of object reference
! * types, and <tt>Arrays.deepEquals(e1, e2) would return true</tt>
! * <li> <tt>e1</tt> and <tt>e2</tt> are arrays of the same primitive
* type, and the appropriate overloading of
! * <tt>Arrays.equals(e1, e2)</tt> would return true.
! * <li> <tt>e1 == e2</tt>
! * <li> <tt>e1.equals(e2)</tt> would return true.
* </ul>
! * Note that this definition permits <tt>null</tt> elements at any depth.
*
* <p>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 <tt>true</tt> 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) {
--- 4215,4254 ----
return result;
}
/**
! * Returns {@code true} if the two specified arrays are <i>deeply
* equal</i> to one another. Unlike the {@link #equals(Object[],Object[])}
* method, this method is appropriate for use with nested arrays of
* arbitrary depth.
*
* <p>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.
*
! * <p>Two possibly {@code null} elements {@code e1} and {@code e2} are
* deeply equal if any of the following conditions hold:
* <ul>
! * <li> {@code e1} and {@code e2} are both arrays of object reference
! * types, and {@code Arrays.deepEquals(e1, e2) would return true}
! * <li> {@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.
! * <li> {@code e1 == e2}
! * <li> {@code e1.equals(e2)} would return true.
* </ul>
! * Note that this definition permits {@code null} elements at any depth.
*
* <p>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) {
*** 4305,4322 ****
}
/**
* 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 (<tt>"[]"</tt>). Adjacent elements are
! * separated by the characters <tt>", "</tt> (a comma followed by a
* space). Elements are converted to strings as by
! * <tt>String.valueOf(long)</tt>. Returns <tt>"null"</tt> if <tt>a</tt>
! * is <tt>null</tt>.
*
* @param a the array whose string representation to return
! * @return a string representation of <tt>a</tt>
* @since 1.5
*/
public static String toString(long[] a) {
if (a == null)
return "null";
--- 4305,4322 ----
}
/**
* 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";
*** 4335,4352 ****
}
/**
* 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 (<tt>"[]"</tt>). Adjacent elements are
! * separated by the characters <tt>", "</tt> (a comma followed by a
* space). Elements are converted to strings as by
! * <tt>String.valueOf(int)</tt>. Returns <tt>"null"</tt> if <tt>a</tt> is
! * <tt>null</tt>.
*
* @param a the array whose string representation to return
! * @return a string representation of <tt>a</tt>
* @since 1.5
*/
public static String toString(int[] a) {
if (a == null)
return "null";
--- 4335,4352 ----
}
/**
* 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";
*** 4365,4382 ****
}
/**
* 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 (<tt>"[]"</tt>). Adjacent elements are
! * separated by the characters <tt>", "</tt> (a comma followed by a
* space). Elements are converted to strings as by
! * <tt>String.valueOf(short)</tt>. Returns <tt>"null"</tt> if <tt>a</tt>
! * is <tt>null</tt>.
*
* @param a the array whose string representation to return
! * @return a string representation of <tt>a</tt>
* @since 1.5
*/
public static String toString(short[] a) {
if (a == null)
return "null";
--- 4365,4382 ----
}
/**
* 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";
*** 4395,4412 ****
}
/**
* 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 (<tt>"[]"</tt>). Adjacent elements are
! * separated by the characters <tt>", "</tt> (a comma followed by a
* space). Elements are converted to strings as by
! * <tt>String.valueOf(char)</tt>. Returns <tt>"null"</tt> if <tt>a</tt>
! * is <tt>null</tt>.
*
* @param a the array whose string representation to return
! * @return a string representation of <tt>a</tt>
* @since 1.5
*/
public static String toString(char[] a) {
if (a == null)
return "null";
--- 4395,4412 ----
}
/**
* 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";
*** 4425,4442 ****
}
/**
* 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 (<tt>"[]"</tt>). Adjacent elements
! * are separated by the characters <tt>", "</tt> (a comma followed
* by a space). Elements are converted to strings as by
! * <tt>String.valueOf(byte)</tt>. Returns <tt>"null"</tt> if
! * <tt>a</tt> is <tt>null</tt>.
*
* @param a the array whose string representation to return
! * @return a string representation of <tt>a</tt>
* @since 1.5
*/
public static String toString(byte[] a) {
if (a == null)
return "null";
--- 4425,4442 ----
}
/**
* 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";
*** 4455,4472 ****
}
/**
* 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 (<tt>"[]"</tt>). Adjacent elements are
! * separated by the characters <tt>", "</tt> (a comma followed by a
* space). Elements are converted to strings as by
! * <tt>String.valueOf(boolean)</tt>. Returns <tt>"null"</tt> if
! * <tt>a</tt> is <tt>null</tt>.
*
* @param a the array whose string representation to return
! * @return a string representation of <tt>a</tt>
* @since 1.5
*/
public static String toString(boolean[] a) {
if (a == null)
return "null";
--- 4455,4472 ----
}
/**
* 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";
*** 4485,4502 ****
}
/**
* 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 (<tt>"[]"</tt>). Adjacent elements are
! * separated by the characters <tt>", "</tt> (a comma followed by a
* space). Elements are converted to strings as by
! * <tt>String.valueOf(float)</tt>. Returns <tt>"null"</tt> if <tt>a</tt>
! * is <tt>null</tt>.
*
* @param a the array whose string representation to return
! * @return a string representation of <tt>a</tt>
* @since 1.5
*/
public static String toString(float[] a) {
if (a == null)
return "null";
--- 4485,4502 ----
}
/**
* 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";
*** 4516,4533 ****
}
/**
* 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 (<tt>"[]"</tt>). Adjacent elements are
! * separated by the characters <tt>", "</tt> (a comma followed by a
* space). Elements are converted to strings as by
! * <tt>String.valueOf(double)</tt>. Returns <tt>"null"</tt> if <tt>a</tt>
! * is <tt>null</tt>.
*
* @param a the array whose string representation to return
! * @return a string representation of <tt>a</tt>
* @since 1.5
*/
public static String toString(double[] a) {
if (a == null)
return "null";
--- 4516,4533 ----
}
/**
* 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";
*** 4547,4565 ****
/**
* 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
! * <tt>Object</tt>, which describes their <i>identities</i> rather than
* their contents.
*
* <p>The value returned by this method is equal to the value that would
! * be returned by <tt>Arrays.asList(a).toString()</tt>, unless <tt>a</tt>
! * is <tt>null</tt>, in which case <tt>"null"</tt> is returned.
*
* @param a the array whose string representation to return
! * @return a string representation of <tt>a</tt>
* @see #deepToString(Object[])
* @since 1.5
*/
public static String toString(Object[] a) {
if (a == null)
--- 4547,4565 ----
/**
* 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 <i>identities</i> rather than
* their contents.
*
* <p>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)
*** 4584,4616 ****
* 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.
*
* <p>The string representation consists of a list of the array's
! * elements, enclosed in square brackets (<tt>"[]"</tt>). Adjacent
! * elements are separated by the characters <tt>", "</tt> (a comma
* followed by a space). Elements are converted to strings as by
! * <tt>String.valueOf(Object)</tt>, unless they are themselves
* arrays.
*
! * <p>If an element <tt>e</tt> is an array of a primitive type, it is
* converted to a string as by invoking the appropriate overloading of
! * <tt>Arrays.toString(e)</tt>. If an element <tt>e</tt> is an array of a
* reference type, it is converted to a string as by invoking
* this method recursively.
*
* <p>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
! * <tt>"[...]"</tt>. For example, an array containing only a reference
! * to itself would be rendered as <tt>"[[...]]"</tt>.
*
! * <p>This method returns <tt>"null"</tt> if the specified array
! * is <tt>null</tt>.
*
* @param a the array whose string representation to return
! * @return a string representation of <tt>a</tt>
* @see #toString(Object[])
* @since 1.5
*/
public static String deepToString(Object[] a) {
if (a == null)
--- 4584,4616 ----
* 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.
*
* <p>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.
*
! * <p>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.
*
* <p>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 "[[...]]"}.
*
! * <p>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)
< prev index next >