--- old/src/java.base/share/classes/java/util/Arrays.java 2015-08-07 21:14:54.026585145 +0400 +++ new/src/java.base/share/classes/java/util/Arrays.java 2015-08-07 21:14:53.818585154 +0400 @@ -1772,10 +1772,10 @@ * @param a the array to be searched * @param key the value to be searched for * @return index of the search key, if it is contained in the array; - * otherwise, (-(insertion point) - 1). The + * otherwise, (-(insertion point) - 1). The * insertion point is defined as the point at which the * key would be inserted into the array: the index of the first - * element greater than the key, or a.length if all + * 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. @@ -1802,11 +1802,11 @@ * @param key the value to be searched for * @return index of the search key, if it is contained in the array * within the specified range; - * otherwise, (-(insertion point) - 1). The + * otherwise, (-(insertion point) - 1). The * insertion point is defined as the point at which the * key would be inserted into the array: the index of the first * element in the range greater than the key, - * or toIndex if all + * 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. @@ -1853,10 +1853,10 @@ * @param a the array to be searched * @param key the value to be searched for * @return index of the search key, if it is contained in the array; - * otherwise, (-(insertion point) - 1). The + * otherwise, (-(insertion point) - 1). The * insertion point is defined as the point at which the * key would be inserted into the array: the index of the first - * element greater than the key, or a.length if all + * 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. @@ -1883,11 +1883,11 @@ * @param key the value to be searched for * @return index of the search key, if it is contained in the array * within the specified range; - * otherwise, (-(insertion point) - 1). The + * otherwise, (-(insertion point) - 1). The * insertion point is defined as the point at which the * key would be inserted into the array: the index of the first * element in the range greater than the key, - * or toIndex if all + * 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. @@ -1934,10 +1934,10 @@ * @param a the array to be searched * @param key the value to be searched for * @return index of the search key, if it is contained in the array; - * otherwise, (-(insertion point) - 1). The + * otherwise, (-(insertion point) - 1). The * insertion point is defined as the point at which the * key would be inserted into the array: the index of the first - * element greater than the key, or a.length if all + * 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. @@ -1964,11 +1964,11 @@ * @param key the value to be searched for * @return index of the search key, if it is contained in the array * within the specified range; - * otherwise, (-(insertion point) - 1). The + * otherwise, (-(insertion point) - 1). The * insertion point is defined as the point at which the * key would be inserted into the array: the index of the first * element in the range greater than the key, - * or toIndex if all + * 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. @@ -2015,10 +2015,10 @@ * @param a the array to be searched * @param key the value to be searched for * @return index of the search key, if it is contained in the array; - * otherwise, (-(insertion point) - 1). The + * otherwise, (-(insertion point) - 1). The * insertion point is defined as the point at which the * key would be inserted into the array: the index of the first - * element greater than the key, or a.length if all + * 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. @@ -2045,11 +2045,11 @@ * @param key the value to be searched for * @return index of the search key, if it is contained in the array * within the specified range; - * otherwise, (-(insertion point) - 1). The + * otherwise, (-(insertion point) - 1). The * insertion point is defined as the point at which the * key would be inserted into the array: the index of the first * element in the range greater than the key, - * or toIndex if all + * 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. @@ -2096,10 +2096,10 @@ * @param a the array to be searched * @param key the value to be searched for * @return index of the search key, if it is contained in the array; - * otherwise, (-(insertion point) - 1). The + * otherwise, (-(insertion point) - 1). The * insertion point is defined as the point at which the * key would be inserted into the array: the index of the first - * element greater than the key, or a.length if all + * 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. @@ -2126,11 +2126,11 @@ * @param key the value to be searched for * @return index of the search key, if it is contained in the array * within the specified range; - * otherwise, (-(insertion point) - 1). The + * otherwise, (-(insertion point) - 1). The * insertion point is defined as the point at which the * key would be inserted into the array: the index of the first * element in the range greater than the key, - * or toIndex if all + * 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. @@ -2178,10 +2178,10 @@ * @param a the array to be searched * @param key the value to be searched for * @return index of the search key, if it is contained in the array; - * otherwise, (-(insertion point) - 1). The + * otherwise, (-(insertion point) - 1). The * insertion point is defined as the point at which the * key would be inserted into the array: the index of the first - * element greater than the key, or a.length if all + * 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. @@ -2209,11 +2209,11 @@ * @param key the value to be searched for * @return index of the search key, if it is contained in the array * within the specified range; - * otherwise, (-(insertion point) - 1). The + * otherwise, (-(insertion point) - 1). The * insertion point is defined as the point at which the * key would be inserted into the array: the index of the first * element in the range greater than the key, - * or toIndex if all + * 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. @@ -2269,10 +2269,10 @@ * @param a the array to be searched * @param key the value to be searched for * @return index of the search key, if it is contained in the array; - * otherwise, (-(insertion point) - 1). The + * otherwise, (-(insertion point) - 1). The * insertion point is defined as the point at which the * key would be inserted into the array: the index of the first - * element greater than the key, or a.length if all + * 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. @@ -2300,11 +2300,11 @@ * @param key the value to be searched for * @return index of the search key, if it is contained in the array * within the specified range; - * otherwise, (-(insertion point) - 1). The + * otherwise, (-(insertion point) - 1). The * insertion point is defined as the point at which the * key would be inserted into the array: the index of the first * element in the range greater than the key, - * or toIndex if all + * 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. @@ -2366,10 +2366,10 @@ * @param a the array to be searched * @param key the value to be searched for * @return index of the search key, if it is contained in the array; - * otherwise, (-(insertion point) - 1). The + * otherwise, (-(insertion point) - 1). The * insertion point is defined as the point at which the * key would be inserted into the array: the index of the first - * element greater than the key, or a.length if all + * 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. @@ -2404,11 +2404,11 @@ * @param key the value to be searched for * @return index of the search key, if it is contained in the array * within the specified range; - * otherwise, (-(insertion point) - 1). The + * otherwise, (-(insertion point) - 1). The * insertion point is defined as the point at which the * key would be inserted into the array: the index of the first * element in the range greater than the key, - * or toIndex if all + * 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. @@ -2464,13 +2464,13 @@ * @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 - * null value indicates that the elements' + * {@code null} value indicates that the elements' * {@linkplain Comparable natural ordering} should be used. * @return index of the search key, if it is contained in the array; - * otherwise, (-(insertion point) - 1). The + * otherwise, (-(insertion point) - 1). The * insertion point is defined as the point at which the * key would be inserted into the array: the index of the first - * element greater than the key, or a.length if all + * 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. @@ -2503,15 +2503,15 @@ * @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 - * null value indicates that the elements' + * {@code null} value indicates that the elements' * {@linkplain Comparable natural ordering} should be used. * @return index of the search key, if it is contained in the array * within the specified range; - * otherwise, (-(insertion point) - 1). The + * otherwise, (-(insertion point) - 1). The * insertion point is defined as the point at which the * key would be inserted into the array: the index of the first * element in the range greater than the key, - * or toIndex if all + * 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. @@ -2557,16 +2557,16 @@ // Equality Testing /** - * Returns true if the two specified arrays of longs are + * Returns {@code true} if the two specified arrays of longs are * equal to one another. Two arrays are considered equal if both * arrays contain the same number of elements, and all corresponding pairs * of elements in the two arrays are equal. In other words, two arrays * are equal if they contain the same elements in the same order. Also, - * two array references are considered equal if both are null. + * 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 true if the two arrays are equal + * @return {@code true} if the two arrays are equal */ public static boolean equals(long[] a, long[] a2) { if (a==a2) @@ -2586,16 +2586,16 @@ } /** - * Returns true if the two specified arrays of ints are + * Returns {@code true} if the two specified arrays of ints are * equal to one another. Two arrays are considered equal if both * arrays contain the same number of elements, and all corresponding pairs * of elements in the two arrays are equal. In other words, two arrays * are equal if they contain the same elements in the same order. Also, - * two array references are considered equal if both are null. + * 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 true if the two arrays are equal + * @return {@code true} if the two arrays are equal */ public static boolean equals(int[] a, int[] a2) { if (a==a2) @@ -2615,16 +2615,16 @@ } /** - * Returns true if the two specified arrays of shorts are + * Returns {@code true} if the two specified arrays of shorts are * equal to one another. Two arrays are considered equal if both * arrays contain the same number of elements, and all corresponding pairs * of elements in the two arrays are equal. In other words, two arrays * are equal if they contain the same elements in the same order. Also, - * two array references are considered equal if both are null. + * 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 true if the two arrays are equal + * @return {@code true} if the two arrays are equal */ public static boolean equals(short[] a, short a2[]) { if (a==a2) @@ -2644,16 +2644,16 @@ } /** - * Returns true if the two specified arrays of chars are + * Returns {@code true} if the two specified arrays of chars are * equal to one another. Two arrays are considered equal if both * arrays contain the same number of elements, and all corresponding pairs * of elements in the two arrays are equal. In other words, two arrays * are equal if they contain the same elements in the same order. Also, - * two array references are considered equal if both are null. + * 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 true if the two arrays are equal + * @return {@code true} if the two arrays are equal */ @HotSpotIntrinsicCandidate public static boolean equals(char[] a, char[] a2) { @@ -2674,16 +2674,16 @@ } /** - * Returns true if the two specified arrays of bytes are + * Returns {@code true} if the two specified arrays of bytes are * equal to one another. Two arrays are considered equal if both * arrays contain the same number of elements, and all corresponding pairs * of elements in the two arrays are equal. In other words, two arrays * are equal if they contain the same elements in the same order. Also, - * two array references are considered equal if both are null. + * 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 true if the two arrays are equal + * @return {@code true} if the two arrays are equal */ public static boolean equals(byte[] a, byte[] a2) { if (a==a2) @@ -2703,16 +2703,16 @@ } /** - * Returns true if the two specified arrays of booleans are + * Returns {@code true} if the two specified arrays of booleans are * equal to one another. Two arrays are considered equal if both * arrays contain the same number of elements, and all corresponding pairs * of elements in the two arrays are equal. In other words, two arrays * are equal if they contain the same elements in the same order. Also, - * two array references are considered equal if both are null. + * 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 true if the two arrays are equal + * @return {@code true} if the two arrays are equal */ public static boolean equals(boolean[] a, boolean[] a2) { if (a==a2) @@ -2732,21 +2732,21 @@ } /** - * Returns true if the two specified arrays of doubles are + * Returns {@code true} if the two specified arrays of doubles are * equal to one another. Two arrays are considered equal if both * arrays contain the same number of elements, and all corresponding pairs * of elements in the two arrays are equal. In other words, two arrays * are equal if they contain the same elements in the same order. Also, - * two array references are considered equal if both are null. + * two array references are considered equal if both are {@code null}. * - * Two doubles d1 and d2 are considered equal if: - * 
    new Double(d1).equals(new Double(d2))
- * (Unlike the == operator, this method considers - * NaN equals to itself, and 0.0d unequal to -0.0d.) + * Two doubles {@code d1} and {@code d2} are considered equal if: + * 
    {@code new Double(d1).equals(new Double(d2))}
+ * (Unlike the {@code ==} operator, this method considers + * {@code NaN} equals to itself, and 0.0d unequal to -0.0d.) * * @param a one array to be tested for equality * @param a2 the other array to be tested for equality - * @return true if the two arrays are equal + * @return {@code true} if the two arrays are equal * @see Double#equals(Object) */ public static boolean equals(double[] a, double[] a2) { @@ -2767,21 +2767,21 @@ } /** - * Returns true if the two specified arrays of floats are + * Returns {@code true} if the two specified arrays of floats are * equal to one another. Two arrays are considered equal if both * arrays contain the same number of elements, and all corresponding pairs * of elements in the two arrays are equal. In other words, two arrays * are equal if they contain the same elements in the same order. Also, - * two array references are considered equal if both are null. + * two array references are considered equal if both are {@code null}. * - * Two floats f1 and f2 are considered equal if: - * 
    new Float(f1).equals(new Float(f2))
- * (Unlike the == operator, this method considers - * NaN equals to itself, and 0.0f unequal to -0.0f.) + * Two floats {@code f1} and {@code f2} are considered equal if: + * 
    {@code new Float(f1).equals(new Float(f2))}
+ * (Unlike the {@code ==} operator, this method considers + * {@code NaN} equals to itself, and 0.0f unequal to -0.0f.) * * @param a one array to be tested for equality * @param a2 the other array to be tested for equality - * @return true if the two arrays are equal + * @return {@code true} if the two arrays are equal * @see Float#equals(Object) */ public static boolean equals(float[] a, float[] a2) { @@ -2802,18 +2802,18 @@ } /** - * Returns true if the two specified arrays of Objects are + * Returns {@code true} if the two specified arrays of Objects are * equal to one another. The two arrays are considered equal if * both arrays contain the same number of elements, and all corresponding - * pairs of elements in the two arrays are equal. Two objects e1 - * and e2 are considered equal if (e1==null ? e2==null - * : e1.equals(e2)). In other words, the two arrays are equal if + * pairs of elements in the two arrays are equal. Two objects {@code e1} + * and {@code e2} are considered equal 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 null. + * 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 true if the two arrays are equal + * @return {@code true} if the two arrays are equal */ public static boolean equals(Object[] a, Object[] a2) { if (a==a2) @@ -2852,8 +2852,8 @@ /** * Assigns the specified long value to each element of the specified * range of the specified array of longs. The range to be filled - * extends from index fromIndex, inclusive, to index - * toIndex, exclusive. (If fromIndex==toIndex, the + * 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 @@ -2862,9 +2862,9 @@ * @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 fromIndex > toIndex - * @throws ArrayIndexOutOfBoundsException if fromIndex < 0 or - * toIndex > a.length + * @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); @@ -2887,8 +2887,8 @@ /** * Assigns the specified int value to each element of the specified * range of the specified array of ints. The range to be filled - * extends from index fromIndex, inclusive, to index - * toIndex, exclusive. (If fromIndex==toIndex, the + * 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 @@ -2897,9 +2897,9 @@ * @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 fromIndex > toIndex - * @throws ArrayIndexOutOfBoundsException if fromIndex < 0 or - * toIndex > a.length + * @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); @@ -2922,8 +2922,8 @@ /** * 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 fromIndex, inclusive, to index - * toIndex, exclusive. (If fromIndex==toIndex, the + * 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 @@ -2932,9 +2932,9 @@ * @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 fromIndex > toIndex - * @throws ArrayIndexOutOfBoundsException if fromIndex < 0 or - * toIndex > a.length + * @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); @@ -2957,8 +2957,8 @@ /** * 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 fromIndex, inclusive, to index - * toIndex, exclusive. (If fromIndex==toIndex, the + * 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 @@ -2967,9 +2967,9 @@ * @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 fromIndex > toIndex - * @throws ArrayIndexOutOfBoundsException if fromIndex < 0 or - * toIndex > a.length + * @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); @@ -2992,8 +2992,8 @@ /** * 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 fromIndex, inclusive, to index - * toIndex, exclusive. (If fromIndex==toIndex, the + * 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 @@ -3002,9 +3002,9 @@ * @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 fromIndex > toIndex - * @throws ArrayIndexOutOfBoundsException if fromIndex < 0 or - * toIndex > a.length + * @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); @@ -3027,8 +3027,8 @@ /** * 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 fromIndex, inclusive, to index - * toIndex, exclusive. (If fromIndex==toIndex, the + * 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 @@ -3037,9 +3037,9 @@ * @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 fromIndex > toIndex - * @throws ArrayIndexOutOfBoundsException if fromIndex < 0 or - * toIndex > a.length + * @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) { @@ -3063,8 +3063,8 @@ /** * 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 fromIndex, inclusive, to index - * toIndex, exclusive. (If fromIndex==toIndex, the + * 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 @@ -3073,9 +3073,9 @@ * @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 fromIndex > toIndex - * @throws ArrayIndexOutOfBoundsException if fromIndex < 0 or - * toIndex > a.length + * @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); @@ -3098,8 +3098,8 @@ /** * 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 fromIndex, inclusive, to index - * toIndex, exclusive. (If fromIndex==toIndex, the + * 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 @@ -3108,9 +3108,9 @@ * @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 fromIndex > toIndex - * @throws ArrayIndexOutOfBoundsException if fromIndex < 0 or - * toIndex > a.length + * @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); @@ -3135,8 +3135,8 @@ /** * 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 fromIndex, inclusive, to index - * toIndex, exclusive. (If fromIndex==toIndex, the + * 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 @@ -3145,9 +3145,9 @@ * @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 fromIndex > toIndex - * @throws ArrayIndexOutOfBoundsException if fromIndex < 0 or - * toIndex > a.length + * @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 */ @@ -3164,7 +3164,7 @@ * so the copy has the specified length. For all indices that are * valid in both the original array and the copy, the two arrays will * contain identical values. For any indices that are valid in the - * copy but not the original, the copy will contain null. + * 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. @@ -3174,8 +3174,8 @@ * @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 newLength is negative - * @throws NullPointerException if original is null + * @throws NegativeArraySizeException if {@code newLength} is negative + * @throws NullPointerException if {@code original} is null * @since 1.6 */ @SuppressWarnings("unchecked") @@ -3188,10 +3188,10 @@ * so the copy has the specified length. For all indices that are * valid in both the original array and the copy, the two arrays will * contain identical values. For any indices that are valid in the - * copy but not the original, the copy will contain null. + * 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 newType. + * The resulting array is of the class {@code newType}. * * @param the class of the objects in the original array * @param the class of the objects in the returned array @@ -3200,11 +3200,11 @@ * @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 newLength is negative - * @throws NullPointerException if original is null + * @throws NegativeArraySizeException if {@code newLength} is negative + * @throws NullPointerException if {@code original} is null * @throws ArrayStoreException if an element copied from - * original is not of a runtime type that can be stored in - * an array of class newType + * {@code original} is not of a runtime type that can be stored in + * an array of class {@code newType} * @since 1.6 */ @HotSpotIntrinsicCandidate @@ -3223,7 +3223,7 @@ * so the copy has the specified length. For all indices that are * valid in both the original array and the copy, the two arrays will * contain identical values. For any indices that are valid in the - * copy but not the original, the copy will contain (byte)0. + * 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. * @@ -3231,8 +3231,8 @@ * @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 newLength is negative - * @throws NullPointerException if original is null + * @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) { @@ -3247,7 +3247,7 @@ * so the copy has the specified length. For all indices that are * valid in both the original array and the copy, the two arrays will * contain identical values. For any indices that are valid in the - * copy but not the original, the copy will contain (short)0. + * 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. * @@ -3255,8 +3255,8 @@ * @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 newLength is negative - * @throws NullPointerException if original is null + * @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) { @@ -3271,7 +3271,7 @@ * so the copy has the specified length. For all indices that are * valid in both the original array and the copy, the two arrays will * contain identical values. For any indices that are valid in the - * copy but not the original, the copy will contain 0. + * 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. * @@ -3279,8 +3279,8 @@ * @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 newLength is negative - * @throws NullPointerException if original is null + * @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) { @@ -3295,7 +3295,7 @@ * so the copy has the specified length. For all indices that are * valid in both the original array and the copy, the two arrays will * contain identical values. For any indices that are valid in the - * copy but not the original, the copy will contain 0L. + * 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. * @@ -3303,8 +3303,8 @@ * @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 newLength is negative - * @throws NullPointerException if original is null + * @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) { @@ -3319,7 +3319,7 @@ * so the copy has the specified length. For all indices that are valid * in both the original array and the copy, the two arrays will contain * identical values. For any indices that are valid in the copy but not - * the original, the copy will contain '\\u000'. Such indices + * 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. * @@ -3327,8 +3327,8 @@ * @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 newLength is negative - * @throws NullPointerException if original is null + * @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) { @@ -3343,7 +3343,7 @@ * so the copy has the specified length. For all indices that are * valid in both the original array and the copy, the two arrays will * contain identical values. For any indices that are valid in the - * copy but not the original, the copy will contain 0f. + * 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. * @@ -3351,8 +3351,8 @@ * @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 newLength is negative - * @throws NullPointerException if original is null + * @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) { @@ -3367,7 +3367,7 @@ * so the copy has the specified length. For all indices that are * valid in both the original array and the copy, the two arrays will * contain identical values. For any indices that are valid in the - * copy but not the original, the copy will contain 0d. + * 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. * @@ -3375,8 +3375,8 @@ * @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 newLength is negative - * @throws NullPointerException if original is null + * @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) { @@ -3387,11 +3387,11 @@ } /** - * Copies the specified array, truncating or padding with false (if necessary) + * 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 false. + * 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. * @@ -3399,8 +3399,8 @@ * @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 newLength is negative - * @throws NullPointerException if original is null + * @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) { @@ -3412,17 +3412,17 @@ /** * Copies the specified range of the specified array into a new array. - * The initial index of the range (from) must lie between zero - * and original.length, inclusive. The value at - * original[from] is placed into the initial element of the copy - * (unless from == original.length or from == to). + * 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 - * (to), which must be greater than or equal to from, - * may be greater than original.length, in which case - * null is placed in all elements of the copy whose index is - * greater than or equal to original.length - from. The length - * of the returned array will be to - from. + * ({@code to}), which must be greater than or equal to {@code from}, + * may be greater than {@code original.length}, in which case + * {@code null} is placed in all elements of the copy whose index is + * greater than or equal to {@code original.length - from}. The length + * of the returned array will be {@code to - from}. *

* The resulting array is of exactly the same class as the original array. * @@ -3435,8 +3435,8 @@ * truncated or padded with nulls to obtain the required length * @throws ArrayIndexOutOfBoundsException if {@code from < 0} * or {@code from > original.length} - * @throws IllegalArgumentException if from > to - * @throws NullPointerException if original is null + * @throws IllegalArgumentException if {@code from > to} + * @throws NullPointerException if {@code original} is null * @since 1.6 */ @SuppressWarnings("unchecked") @@ -3446,18 +3446,18 @@ /** * Copies the specified range of the specified array into a new array. - * The initial index of the range (from) must lie between zero - * and original.length, inclusive. The value at - * original[from] is placed into the initial element of the copy - * (unless from == original.length or from == to). + * 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 - * (to), which must be greater than or equal to from, - * may be greater than original.length, in which case - * null is placed in all elements of the copy whose index is - * greater than or equal to original.length - from. The length - * of the returned array will be to - from. - * The resulting array is of the class newType. + * ({@code to}), which must be greater than or equal to {@code from}, + * may be greater than {@code original.length}, in which case + * {@code null} is placed in all elements of the copy whose index is + * greater than or equal to {@code original.length - from}. The length + * of the returned array will be {@code to - from}. + * The resulting array is of the class {@code newType}. * * @param the class of the objects in the original array * @param the class of the objects in the returned array @@ -3470,11 +3470,11 @@ * truncated or padded with nulls to obtain the required length * @throws ArrayIndexOutOfBoundsException if {@code from < 0} * or {@code from > original.length} - * @throws IllegalArgumentException if from > to - * @throws NullPointerException if original is null + * @throws IllegalArgumentException if {@code from > to} + * @throws NullPointerException if {@code original} is null * @throws ArrayStoreException if an element copied from - * original is not of a runtime type that can be stored in - * an array of class newType. + * {@code original} is not of a runtime type that can be stored in + * an array of class {@code newType}. * @since 1.6 */ @HotSpotIntrinsicCandidate @@ -3493,17 +3493,17 @@ /** * Copies the specified range of the specified array into a new array. - * The initial index of the range (from) must lie between zero - * and original.length, inclusive. The value at - * original[from] is placed into the initial element of the copy - * (unless from == original.length or from == to). + * 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 - * (to), which must be greater than or equal to from, - * may be greater than original.length, in which case - * (byte)0 is placed in all elements of the copy whose index is - * greater than or equal to original.length - from. The length - * of the returned array will be to - from. + * ({@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 @@ -3513,8 +3513,8 @@ * truncated or padded with zeros to obtain the required length * @throws ArrayIndexOutOfBoundsException if {@code from < 0} * or {@code from > original.length} - * @throws IllegalArgumentException if from > to - * @throws NullPointerException if original is null + * @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) { @@ -3529,17 +3529,17 @@ /** * Copies the specified range of the specified array into a new array. - * The initial index of the range (from) must lie between zero - * and original.length, inclusive. The value at - * original[from] is placed into the initial element of the copy - * (unless from == original.length or from == to). + * 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 - * (to), which must be greater than or equal to from, - * may be greater than original.length, in which case - * (short)0 is placed in all elements of the copy whose index is - * greater than or equal to original.length - from. The length - * of the returned array will be to - from. + * ({@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 @@ -3549,8 +3549,8 @@ * truncated or padded with zeros to obtain the required length * @throws ArrayIndexOutOfBoundsException if {@code from < 0} * or {@code from > original.length} - * @throws IllegalArgumentException if from > to - * @throws NullPointerException if original is null + * @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) { @@ -3565,17 +3565,17 @@ /** * Copies the specified range of the specified array into a new array. - * The initial index of the range (from) must lie between zero - * and original.length, inclusive. The value at - * original[from] is placed into the initial element of the copy - * (unless from == original.length or from == to). + * 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 - * (to), which must be greater than or equal to from, - * may be greater than original.length, in which case - * 0 is placed in all elements of the copy whose index is - * greater than or equal to original.length - from. The length - * of the returned array will be to - from. + * ({@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 @@ -3585,8 +3585,8 @@ * truncated or padded with zeros to obtain the required length * @throws ArrayIndexOutOfBoundsException if {@code from < 0} * or {@code from > original.length} - * @throws IllegalArgumentException if from > to - * @throws NullPointerException if original is null + * @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) { @@ -3601,17 +3601,17 @@ /** * Copies the specified range of the specified array into a new array. - * The initial index of the range (from) must lie between zero - * and original.length, inclusive. The value at - * original[from] is placed into the initial element of the copy - * (unless from == original.length or from == to). + * 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 - * (to), which must be greater than or equal to from, - * may be greater than original.length, in which case - * 0L is placed in all elements of the copy whose index is - * greater than or equal to original.length - from. The length - * of the returned array will be to - from. + * ({@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 @@ -3621,8 +3621,8 @@ * truncated or padded with zeros to obtain the required length * @throws ArrayIndexOutOfBoundsException if {@code from < 0} * or {@code from > original.length} - * @throws IllegalArgumentException if from > to - * @throws NullPointerException if original is null + * @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) { @@ -3637,17 +3637,17 @@ /** * Copies the specified range of the specified array into a new array. - * The initial index of the range (from) must lie between zero - * and original.length, inclusive. The value at - * original[from] is placed into the initial element of the copy - * (unless from == original.length or from == to). + * 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 - * (to), which must be greater than or equal to from, - * may be greater than original.length, in which case - * '\\u000' is placed in all elements of the copy whose index is - * greater than or equal to original.length - from. The length - * of the returned array will be to - from. + * ({@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 @@ -3657,8 +3657,8 @@ * 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 from > to - * @throws NullPointerException if original is null + * @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) { @@ -3673,17 +3673,17 @@ /** * Copies the specified range of the specified array into a new array. - * The initial index of the range (from) must lie between zero - * and original.length, inclusive. The value at - * original[from] is placed into the initial element of the copy - * (unless from == original.length or from == to). + * 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 - * (to), which must be greater than or equal to from, - * may be greater than original.length, in which case - * 0f is placed in all elements of the copy whose index is - * greater than or equal to original.length - from. The length - * of the returned array will be to - from. + * ({@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 @@ -3693,8 +3693,8 @@ * truncated or padded with zeros to obtain the required length * @throws ArrayIndexOutOfBoundsException if {@code from < 0} * or {@code from > original.length} - * @throws IllegalArgumentException if from > to - * @throws NullPointerException if original is null + * @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) { @@ -3709,17 +3709,17 @@ /** * Copies the specified range of the specified array into a new array. - * The initial index of the range (from) must lie between zero - * and original.length, inclusive. The value at - * original[from] is placed into the initial element of the copy - * (unless from == original.length or from == to). + * 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 - * (to), which must be greater than or equal to from, - * may be greater than original.length, in which case - * 0d is placed in all elements of the copy whose index is - * greater than or equal to original.length - from. The length - * of the returned array will be to - from. + * ({@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 @@ -3729,8 +3729,8 @@ * truncated or padded with zeros to obtain the required length * @throws ArrayIndexOutOfBoundsException if {@code from < 0} * or {@code from > original.length} - * @throws IllegalArgumentException if from > to - * @throws NullPointerException if original is null + * @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) { @@ -3745,17 +3745,17 @@ /** * Copies the specified range of the specified array into a new array. - * The initial index of the range (from) must lie between zero - * and original.length, inclusive. The value at - * original[from] is placed into the initial element of the copy - * (unless from == original.length or from == to). + * 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 - * (to), which must be greater than or equal to from, - * may be greater than original.length, in which case - * false is placed in all elements of the copy whose index is - * greater than or equal to original.length - from. The length - * of the returned array will be to - from. + * ({@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 @@ -3765,8 +3765,8 @@ * 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 from > to - * @throws NullPointerException if original is null + * @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) { @@ -3902,18 +3902,18 @@ /** * Returns a hash code based on the contents of the specified array. - * For any two long arrays a and b - * such that Arrays.equals(a, b), it is also the case that - * Arrays.hashCode(a) == Arrays.hashCode(b). + * For any two {@code long} arrays {@code a} and {@code b} + * such that {@code Arrays.equals(a, b)}, it is also the case that + * {@code Arrays.hashCode(a) == Arrays.hashCode(b)}. * *

The value returned by this method is the same value that would be - * obtained by invoking the {@link List#hashCode() hashCode} + * obtained by invoking the {@link List#hashCode() hashCode} * method on a {@link List} containing a sequence of {@link Long} - * instances representing the elements of a in the same order. - * If a is null, this method returns 0. + * 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 a + * @return a content-based hash code for {@code a} * @since 1.5 */ public static int hashCode(long a[]) { @@ -3931,18 +3931,18 @@ /** * Returns a hash code based on the contents of the specified array. - * For any two non-null int arrays a and b - * such that Arrays.equals(a, b), it is also the case that - * Arrays.hashCode(a) == Arrays.hashCode(b). + * For any two non-null {@code int} arrays {@code a} and {@code b} + * such that {@code Arrays.equals(a, b)}, it is also the case that + * {@code Arrays.hashCode(a) == Arrays.hashCode(b)}. * *

The value returned by this method is the same value that would be - * obtained by invoking the {@link List#hashCode() hashCode} + * obtained by invoking the {@link List#hashCode() hashCode} * method on a {@link List} containing a sequence of {@link Integer} - * instances representing the elements of a in the same order. - * If a is null, this method returns 0. + * 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 a + * @return a content-based hash code for {@code a} * @since 1.5 */ public static int hashCode(int a[]) { @@ -3958,18 +3958,18 @@ /** * Returns a hash code based on the contents of the specified array. - * For any two short arrays a and b - * such that Arrays.equals(a, b), it is also the case that - * Arrays.hashCode(a) == Arrays.hashCode(b). + * For any two {@code short} arrays {@code a} and {@code b} + * such that {@code Arrays.equals(a, b)}, it is also the case that + * {@code Arrays.hashCode(a) == Arrays.hashCode(b)}. * *

The value returned by this method is the same value that would be - * obtained by invoking the {@link List#hashCode() hashCode} + * obtained by invoking the {@link List#hashCode() hashCode} * method on a {@link List} containing a sequence of {@link Short} - * instances representing the elements of a in the same order. - * If a is null, this method returns 0. + * 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 a + * @return a content-based hash code for {@code a} * @since 1.5 */ public static int hashCode(short a[]) { @@ -3985,18 +3985,18 @@ /** * Returns a hash code based on the contents of the specified array. - * For any two char arrays a and b - * such that Arrays.equals(a, b), it is also the case that - * Arrays.hashCode(a) == Arrays.hashCode(b). + * For any two {@code char} arrays {@code a} and {@code b} + * such that {@code Arrays.equals(a, b)}, it is also the case that + * {@code Arrays.hashCode(a) == Arrays.hashCode(b)}. * *

The value returned by this method is the same value that would be - * obtained by invoking the {@link List#hashCode() hashCode} + * obtained by invoking the {@link List#hashCode() hashCode} * method on a {@link List} containing a sequence of {@link Character} - * instances representing the elements of a in the same order. - * If a is null, this method returns 0. + * 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 a + * @return a content-based hash code for {@code a} * @since 1.5 */ public static int hashCode(char a[]) { @@ -4012,18 +4012,18 @@ /** * Returns a hash code based on the contents of the specified array. - * For any two byte arrays a and b - * such that Arrays.equals(a, b), it is also the case that - * Arrays.hashCode(a) == Arrays.hashCode(b). + * For any two {@code byte} arrays {@code a} and {@code b} + * such that {@code Arrays.equals(a, b)}, it is also the case that + * {@code Arrays.hashCode(a) == Arrays.hashCode(b)}. * *

The value returned by this method is the same value that would be - * obtained by invoking the {@link List#hashCode() hashCode} + * obtained by invoking the {@link List#hashCode() hashCode} * method on a {@link List} containing a sequence of {@link Byte} - * instances representing the elements of a in the same order. - * If a is null, this method returns 0. + * 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 a + * @return a content-based hash code for {@code a} * @since 1.5 */ public static int hashCode(byte a[]) { @@ -4039,18 +4039,18 @@ /** * Returns a hash code based on the contents of the specified array. - * For any two boolean arrays a and b - * such that Arrays.equals(a, b), it is also the case that - * Arrays.hashCode(a) == Arrays.hashCode(b). + * For any two {@code boolean} arrays {@code a} and {@code b} + * such that {@code Arrays.equals(a, b)}, it is also the case that + * {@code Arrays.hashCode(a) == Arrays.hashCode(b)}. * *

The value returned by this method is the same value that would be - * obtained by invoking the {@link List#hashCode() hashCode} + * obtained by invoking the {@link List#hashCode() hashCode} * method on a {@link List} containing a sequence of {@link Boolean} - * instances representing the elements of a in the same order. - * If a is null, this method returns 0. + * 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 a + * @return a content-based hash code for {@code a} * @since 1.5 */ public static int hashCode(boolean a[]) { @@ -4066,18 +4066,18 @@ /** * Returns a hash code based on the contents of the specified array. - * For any two float arrays a and b - * such that Arrays.equals(a, b), it is also the case that - * Arrays.hashCode(a) == Arrays.hashCode(b). + * For any two {@code float} arrays {@code a} and {@code b} + * such that {@code Arrays.equals(a, b)}, it is also the case that + * {@code Arrays.hashCode(a) == Arrays.hashCode(b)}. * *

The value returned by this method is the same value that would be - * obtained by invoking the {@link List#hashCode() hashCode} + * obtained by invoking the {@link List#hashCode() hashCode} * method on a {@link List} containing a sequence of {@link Float} - * instances representing the elements of a in the same order. - * If a is null, this method returns 0. + * 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 a + * @return a content-based hash code for {@code a} * @since 1.5 */ public static int hashCode(float a[]) { @@ -4093,18 +4093,18 @@ /** * Returns a hash code based on the contents of the specified array. - * For any two double arrays a and b - * such that Arrays.equals(a, b), it is also the case that - * Arrays.hashCode(a) == Arrays.hashCode(b). + * For any two {@code double} arrays {@code a} and {@code b} + * such that {@code Arrays.equals(a, b)}, it is also the case that + * {@code Arrays.hashCode(a) == Arrays.hashCode(b)}. * *

The value returned by this method is the same value that would be - * obtained by invoking the {@link List#hashCode() hashCode} + * obtained by invoking the {@link List#hashCode() hashCode} * method on a {@link List} containing a sequence of {@link Double} - * instances representing the elements of a in the same order. - * If a is null, this method returns 0. + * 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 a + * @return a content-based hash code for {@code a} * @since 1.5 */ public static int hashCode(double a[]) { @@ -4127,16 +4127,16 @@ * element, either directly or indirectly through one or more levels of * arrays. * - *

For any two arrays a and b such that - * Arrays.equals(a, b), it is also the case that - * Arrays.hashCode(a) == Arrays.hashCode(b). + *

For any two arrays {@code a} and {@code b} such that + * {@code Arrays.equals(a, b)}, it is also the case that + * {@code Arrays.hashCode(a) == Arrays.hashCode(b)}. * *

The value returned by this method is equal to the value that would - * be returned by Arrays.asList(a).hashCode(), unless a - * is null, in which case 0 is returned. + * 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 a + * @return a content-based hash code for {@code a} * @see #deepHashCode(Object[]) * @since 1.5 */ @@ -4161,23 +4161,23 @@ * one or more levels of arrays. The behavior of such an invocation is * undefined. * - *

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

For any two arrays {@code a} and {@code b} such that + * {@code Arrays.deepEquals(a, b)}, it is also the case that + * {@code Arrays.deepHashCode(a) == Arrays.deepHashCode(b)}. * *

The computation of the value returned by this method is similar to * that of the value returned by {@link List#hashCode()} on a list - * containing the same elements as a in the same order, with one - * difference: If an element e of a is itself an array, - * its hash code is computed not by calling e.hashCode(), but as - * by calling the appropriate overloading of Arrays.hashCode(e) - * if e is an array of a primitive type, or as by calling - * Arrays.deepHashCode(e) recursively if e is an array - * of a reference type. If a is null, this method + * 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 a + * @return a deep-content-based hash code for {@code a} * @see #hashCode(Object[]) * @since 1.5 */ @@ -4217,28 +4217,28 @@ } /** - * Returns true if the two specified arrays are deeply + * Returns {@code true} if the two specified arrays are deeply * equal to one another. Unlike the {@link #equals(Object[],Object[])} * method, this method is appropriate for use with nested arrays of * arbitrary depth. * *

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

Two possibly null elements e1 and e2 are + *

Two possibly {@code null} elements {@code e1} and {@code e2} are * deeply equal if any of the following conditions hold: *

- * Note that this definition permits null elements at any depth. + * Note that this definition permits {@code null} elements at any depth. * *

If either of the specified arrays contain themselves as elements * either directly or indirectly through one or more levels of arrays, @@ -4246,7 +4246,7 @@ * * @param a1 one array to be tested for equality * @param a2 the other array to be tested for equality - * @return true if the two arrays are equal + * @return {@code true} if the two arrays are equal * @see #equals(Object[],Object[]) * @see Objects#deepEquals(Object, Object) * @since 1.5 @@ -4307,14 +4307,14 @@ /** * 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 ("[]"). Adjacent elements are - * separated by the characters ", " (a comma followed by a + * 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 - * String.valueOf(long). Returns "null" if a - * is null. + * {@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 a + * @return a string representation of {@code a} * @since 1.5 */ public static String toString(long[] a) { @@ -4337,14 +4337,14 @@ /** * 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 ("[]"). Adjacent elements are - * separated by the characters ", " (a comma followed by a + * 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 - * String.valueOf(int). Returns "null" if a is - * null. + * {@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 a + * @return a string representation of {@code a} * @since 1.5 */ public static String toString(int[] a) { @@ -4367,14 +4367,14 @@ /** * 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 ("[]"). Adjacent elements are - * separated by the characters ", " (a comma followed by a + * 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 - * String.valueOf(short). Returns "null" if a - * is null. + * {@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 a + * @return a string representation of {@code a} * @since 1.5 */ public static String toString(short[] a) { @@ -4397,14 +4397,14 @@ /** * 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 ("[]"). Adjacent elements are - * separated by the characters ", " (a comma followed by a + * 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 - * String.valueOf(char). Returns "null" if a - * is null. + * {@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 a + * @return a string representation of {@code a} * @since 1.5 */ public static String toString(char[] a) { @@ -4427,14 +4427,14 @@ /** * 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 ("[]"). Adjacent elements - * are separated by the characters ", " (a comma followed + * 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 - * String.valueOf(byte). Returns "null" if - * a is null. + * {@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 a + * @return a string representation of {@code a} * @since 1.5 */ public static String toString(byte[] a) { @@ -4457,14 +4457,14 @@ /** * 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 ("[]"). Adjacent elements are - * separated by the characters ", " (a comma followed by a + * 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 - * String.valueOf(boolean). Returns "null" if - * a is null. + * {@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 a + * @return a string representation of {@code a} * @since 1.5 */ public static String toString(boolean[] a) { @@ -4487,14 +4487,14 @@ /** * 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 ("[]"). Adjacent elements are - * separated by the characters ", " (a comma followed by a + * 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 - * String.valueOf(float). Returns "null" if a - * is null. + * {@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 a + * @return a string representation of {@code a} * @since 1.5 */ public static String toString(float[] a) { @@ -4518,14 +4518,14 @@ /** * 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 ("[]"). Adjacent elements are - * separated by the characters ", " (a comma followed by a + * 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 - * String.valueOf(double). Returns "null" if a - * is null. + * {@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 a + * @return a string representation of {@code a} * @since 1.5 */ public static String toString(double[] a) { @@ -4549,15 +4549,15 @@ * 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 - * Object, which describes their identities rather than + * {@code Object}, which describes their identities rather than * their contents. * *

The value returned by this method is equal to the value that would - * be returned by Arrays.asList(a).toString(), unless a - * is null, in which case "null" is returned. + * 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 a + * @return a string representation of {@code a} * @see #deepToString(Object[]) * @since 1.5 */ @@ -4586,29 +4586,29 @@ * designed for converting multidimensional arrays to strings. * *

The string representation consists of a list of the array's - * elements, enclosed in square brackets ("[]"). Adjacent - * elements are separated by the characters ", " (a comma + * 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 - * String.valueOf(Object), unless they are themselves + * {@code String.valueOf(Object)}, unless they are themselves * arrays. * - *

If an element e is an array of a primitive type, it is + *

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 - * Arrays.toString(e). If an element e is an array of a + * {@code Arrays.toString(e)}. If an element {@code e} is an array of a * reference type, it is converted to a string as by invoking * this method recursively. * *

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

This method returns "null" if the specified array - * is null. + *

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 a + * @return a string representation of {@code a} * @see #toString(Object[]) * @since 1.5 */