commons-commits mailing list archives

Site index · List index
Message view « Date » · « Thread »
Top « Date » · « Thread »
From scolebou...@apache.org
Subject svn commit: r1078032 [2/5] - in /commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3: ./ builder/
Date Fri, 04 Mar 2011 16:07:14 GMT
Modified: commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/ArrayUtils.java
URL: http://svn.apache.org/viewvc/commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/ArrayUtils.java?rev=1078032&r1=1078031&r2=1078032&view=diff
==============================================================================
--- commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/ArrayUtils.java (original)
+++ commons/proper/lang/trunk/src/main/java/org/apache/commons/lang3/ArrayUtils.java Fri Mar  4 16:07:14 2011
@@ -26,12 +26,12 @@ import org.apache.commons.lang3.builder.
 import org.apache.commons.lang3.builder.ToStringStyle;
 
 /**
- * <p>Operations on arrays, primitive arrays (like <code>int[]</code>) and
- * primitive wrapper arrays (like <code>Integer[]</code>).</p>
+ * <p>Operations on arrays, primitive arrays (like {@code int[]}) and
+ * primitive wrapper arrays (like {@code Integer[]}).</p>
  *
- * <p>This class tries to handle <code>null</code> input gracefully.
- * An exception will not be thrown for a <code>null</code>
- * array input. However, an Object array that contains a <code>null</code>
+ * <p>This class tries to handle {@code null} input gracefully.
+ * An exception will not be thrown for a {@code null}
+ * array input. However, an Object array that contains a {@code null}
  * element may throw an exception. Each method documents its behaviour.</p>
  *
  * <p>#ThreadSafe#</p>
@@ -52,84 +52,84 @@ import org.apache.commons.lang3.builder.
 public class ArrayUtils {
 
     /**
-     * An empty immutable <code>Object</code> array.
+     * An empty immutable {@code Object} array.
      */
     public static final Object[] EMPTY_OBJECT_ARRAY = new Object[0];
     /**
-     * An empty immutable <code>Class</code> array.
+     * An empty immutable {@code Class} array.
      */
     public static final Class<?>[] EMPTY_CLASS_ARRAY = new Class[0];
     /**
-     * An empty immutable <code>String</code> array.
+     * An empty immutable {@code String} array.
      */
     public static final String[] EMPTY_STRING_ARRAY = new String[0];
     /**
-     * An empty immutable <code>long</code> array.
+     * An empty immutable {@code long} array.
      */
     public static final long[] EMPTY_LONG_ARRAY = new long[0];
     /**
-     * An empty immutable <code>Long</code> array.
+     * An empty immutable {@code Long} array.
      */
     public static final Long[] EMPTY_LONG_OBJECT_ARRAY = new Long[0];
     /**
-     * An empty immutable <code>int</code> array.
+     * An empty immutable {@code int} array.
      */
     public static final int[] EMPTY_INT_ARRAY = new int[0];
     /**
-     * An empty immutable <code>Integer</code> array.
+     * An empty immutable {@code Integer} array.
      */
     public static final Integer[] EMPTY_INTEGER_OBJECT_ARRAY = new Integer[0];
     /**
-     * An empty immutable <code>short</code> array.
+     * An empty immutable {@code short} array.
      */
     public static final short[] EMPTY_SHORT_ARRAY = new short[0];
     /**
-     * An empty immutable <code>Short</code> array.
+     * An empty immutable {@code Short} array.
      */
     public static final Short[] EMPTY_SHORT_OBJECT_ARRAY = new Short[0];
     /**
-     * An empty immutable <code>byte</code> array.
+     * An empty immutable {@code byte} array.
      */
     public static final byte[] EMPTY_BYTE_ARRAY = new byte[0];
     /**
-     * An empty immutable <code>Byte</code> array.
+     * An empty immutable {@code Byte} array.
      */
     public static final Byte[] EMPTY_BYTE_OBJECT_ARRAY = new Byte[0];
     /**
-     * An empty immutable <code>double</code> array.
+     * An empty immutable {@code double} array.
      */
     public static final double[] EMPTY_DOUBLE_ARRAY = new double[0];
     /**
-     * An empty immutable <code>Double</code> array.
+     * An empty immutable {@code Double} array.
      */
     public static final Double[] EMPTY_DOUBLE_OBJECT_ARRAY = new Double[0];
     /**
-     * An empty immutable <code>float</code> array.
+     * An empty immutable {@code float} array.
      */
     public static final float[] EMPTY_FLOAT_ARRAY = new float[0];
     /**
-     * An empty immutable <code>Float</code> array.
+     * An empty immutable {@code Float} array.
      */
     public static final Float[] EMPTY_FLOAT_OBJECT_ARRAY = new Float[0];
     /**
-     * An empty immutable <code>boolean</code> array.
+     * An empty immutable {@code boolean} array.
      */
     public static final boolean[] EMPTY_BOOLEAN_ARRAY = new boolean[0];
     /**
-     * An empty immutable <code>Boolean</code> array.
+     * An empty immutable {@code Boolean} array.
      */
     public static final Boolean[] EMPTY_BOOLEAN_OBJECT_ARRAY = new Boolean[0];
     /**
-     * An empty immutable <code>char</code> array.
+     * An empty immutable {@code char} array.
      */
     public static final char[] EMPTY_CHAR_ARRAY = new char[0];
     /**
-     * An empty immutable <code>Character</code> array.
+     * An empty immutable {@code Character} array.
      */
     public static final Character[] EMPTY_CHARACTER_OBJECT_ARRAY = new Character[0];
 
     /**
-     * The index value when an element is not found in a list or array: <code>-1</code>.
+     * The index value when an element is not found in a list or array: {@code -1}.
      * This value is returned by methods in this class and can also be used in comparisons with values returned by
      * various method from {@link java.util.List}.
      */
@@ -137,7 +137,7 @@ public class ArrayUtils {
 
     /**
      * <p>ArrayUtils instances should NOT be constructed in standard programming.
-     * Instead, the class should be used as <code>ArrayUtils.clone(new int[] {2})</code>.</p>
+     * Instead, the class should be used as {@code ArrayUtils.clone(new int[] {2})}.</p>
      *
      * <p>This constructor is public to permit tools that require a JavaBean instance
      * to operate.</p>
@@ -149,14 +149,14 @@ public class ArrayUtils {
     // Basic methods handling multi-dimensional arrays
     //-----------------------------------------------------------------------
     /**
-     * <p>Outputs an array as a String, treating <code>null</code> as an empty array.</p>
+     * <p>Outputs an array as a String, treating {@code null} as an empty array.</p>
      *
      * <p>Multi-dimensional arrays are handled correctly, including
      * multi-dimensional primitive arrays.</p>
      *
-     * <p>The format is that of Java source code, for example <code>{a,b}</code>.</p>
+     * <p>The format is that of Java source code, for example {@code {a,b}}.</p>
      *
-     * @param array  the array to get a toString for, may be <code>null</code>
+     * @param array  the array to get a toString for, may be {@code null}
      * @return a String representation of the array, '{}' if null array input
      */
     public static String toString(Object array) {
@@ -164,15 +164,15 @@ public class ArrayUtils {
     }
 
     /**
-     * <p>Outputs an array as a String handling <code>null</code>s.</p>
+     * <p>Outputs an array as a String handling {@code null}s.</p>
      *
      * <p>Multi-dimensional arrays are handled correctly, including
      * multi-dimensional primitive arrays.</p>
      *
-     * <p>The format is that of Java source code, for example <code>{a,b}</code>.</p>
+     * <p>The format is that of Java source code, for example {@code {a,b}}.</p>
      *
-     * @param array  the array to get a toString for, may be <code>null</code>
-     * @param stringIfNull  the String to return if the array is <code>null</code>
+     * @param array  the array to get a toString for, may be {@code null}
+     * @param stringIfNull  the String to return if the array is {@code null}
      * @return a String representation of the array
      */
     public static String toString(Object array, String stringIfNull) {
@@ -187,7 +187,7 @@ public class ArrayUtils {
      *
      * <p>Multi-dimensional primitive arrays are also handled correctly by this method.</p>
      *
-     * @param array  the array to get a hash code for, <code>null</code> returns zero
+     * @param array  the array to get a hash code for, {@code null} returns zero
      * @return a hash code for the array
      */
     public static int hashCode(Object array) {
@@ -200,9 +200,9 @@ public class ArrayUtils {
      *
      * <p>Multi-dimensional primitive arrays are also handled correctly by this method.</p>
      *
-     * @param array1  the left hand array to compare, may be <code>null</code>
-     * @param array2  the right hand array to compare, may be <code>null</code>
-     * @return <code>true</code> if the arrays are equal
+     * @param array1  the left hand array to compare, may be {@code null}
+     * @param array2  the right hand array to compare, may be {@code null}
+     * @return {@code true} if the arrays are equal
      */
     public static boolean isEquals(Object array1, Object array2) {
         return new EqualsBuilder().append(array1, array2).isEquals();
@@ -225,11 +225,11 @@ public class ArrayUtils {
      *     {"BLUE", "#0000FF"}});
      * </pre>
      *
-     * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
+     * <p>This method returns {@code null} for a {@code null} input array.</p>
      *
      * @param array  an array whose elements are either a {@link java.util.Map.Entry} or
-     *  an Array containing at least two elements, may be <code>null</code>
-     * @return a <code>Map</code> that was created from the array
+     *  an Array containing at least two elements, may be {@code null}
+     * @return a {@code Map} that was created from the array
      * @throws IllegalArgumentException  if one element of this Array is
      *  itself an Array containing less then two elements
      * @throws IllegalArgumentException  if the array contains elements other
@@ -294,7 +294,7 @@ public class ArrayUtils {
      * type explicitly like in
      * <code>Number[] array = ArrayUtils.&lt;Number&gt;toArray(new Integer(42), new Double(Math.PI))</code>,
      * there is no real advantage when compared to
-     * <code>new Number[] {new Integer(42), new Double(Math.PI)}</code>.</p>
+     * {@code new Number[] {new Integer(42), new Double(Math.PI)}}.</p>
      *
      * @param  <T>   the array's element type
      * @param  items  the varargs array items, null allowed
@@ -309,15 +309,15 @@ public class ArrayUtils {
     //-----------------------------------------------------------------------
     /**
      * <p>Shallow clones an array returning a typecast result and handling
-     * <code>null</code>.</p>
+     * {@code null}.</p>
      *
      * <p>The objects in the array are not cloned, thus there is no special
      * handling for multi-dimensional arrays.</p>
      *
-     * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
+     * <p>This method returns {@code null} for a {@code null} input array.</p>
      *
-     * @param array  the array to shallow clone, may be <code>null</code>
-     * @return the cloned array, <code>null</code> if <code>null</code> input
+     * @param array  the array to shallow clone, may be {@code null}
+     * @return the cloned array, {@code null} if {@code null} input
      */
     public static <T> T[] clone(T[] array) {
         if (array == null) {
@@ -328,12 +328,12 @@ public class ArrayUtils {
 
     /**
      * <p>Clones an array returning a typecast result and handling
-     * <code>null</code>.</p>
+     * {@code null}.</p>
      *
-     * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
+     * <p>This method returns {@code null} for a {@code null} input array.</p>
      *
-     * @param array  the array to clone, may be <code>null</code>
-     * @return the cloned array, <code>null</code> if <code>null</code> input
+     * @param array  the array to clone, may be {@code null}
+     * @return the cloned array, {@code null} if {@code null} input
      */
     public static long[] clone(long[] array) {
         if (array == null) {
@@ -344,12 +344,12 @@ public class ArrayUtils {
 
     /**
      * <p>Clones an array returning a typecast result and handling
-     * <code>null</code>.</p>
+     * {@code null}.</p>
      *
-     * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
+     * <p>This method returns {@code null} for a {@code null} input array.</p>
      *
-     * @param array  the array to clone, may be <code>null</code>
-     * @return the cloned array, <code>null</code> if <code>null</code> input
+     * @param array  the array to clone, may be {@code null}
+     * @return the cloned array, {@code null} if {@code null} input
      */
     public static int[] clone(int[] array) {
         if (array == null) {
@@ -360,12 +360,12 @@ public class ArrayUtils {
 
     /**
      * <p>Clones an array returning a typecast result and handling
-     * <code>null</code>.</p>
+     * {@code null}.</p>
      *
-     * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
+     * <p>This method returns {@code null} for a {@code null} input array.</p>
      *
-     * @param array  the array to clone, may be <code>null</code>
-     * @return the cloned array, <code>null</code> if <code>null</code> input
+     * @param array  the array to clone, may be {@code null}
+     * @return the cloned array, {@code null} if {@code null} input
      */
     public static short[] clone(short[] array) {
         if (array == null) {
@@ -376,12 +376,12 @@ public class ArrayUtils {
 
     /**
      * <p>Clones an array returning a typecast result and handling
-     * <code>null</code>.</p>
+     * {@code null}.</p>
      *
-     * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
+     * <p>This method returns {@code null} for a {@code null} input array.</p>
      *
-     * @param array  the array to clone, may be <code>null</code>
-     * @return the cloned array, <code>null</code> if <code>null</code> input
+     * @param array  the array to clone, may be {@code null}
+     * @return the cloned array, {@code null} if {@code null} input
      */
     public static char[] clone(char[] array) {
         if (array == null) {
@@ -392,12 +392,12 @@ public class ArrayUtils {
 
     /**
      * <p>Clones an array returning a typecast result and handling
-     * <code>null</code>.</p>
+     * {@code null}.</p>
      *
-     * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
+     * <p>This method returns {@code null} for a {@code null} input array.</p>
      *
-     * @param array  the array to clone, may be <code>null</code>
-     * @return the cloned array, <code>null</code> if <code>null</code> input
+     * @param array  the array to clone, may be {@code null}
+     * @return the cloned array, {@code null} if {@code null} input
      */
     public static byte[] clone(byte[] array) {
         if (array == null) {
@@ -408,12 +408,12 @@ public class ArrayUtils {
 
     /**
      * <p>Clones an array returning a typecast result and handling
-     * <code>null</code>.</p>
+     * {@code null}.</p>
      *
-     * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
+     * <p>This method returns {@code null} for a {@code null} input array.</p>
      *
-     * @param array  the array to clone, may be <code>null</code>
-     * @return the cloned array, <code>null</code> if <code>null</code> input
+     * @param array  the array to clone, may be {@code null}
+     * @return the cloned array, {@code null} if {@code null} input
      */
     public static double[] clone(double[] array) {
         if (array == null) {
@@ -424,12 +424,12 @@ public class ArrayUtils {
 
     /**
      * <p>Clones an array returning a typecast result and handling
-     * <code>null</code>.</p>
+     * {@code null}.</p>
      *
-     * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
+     * <p>This method returns {@code null} for a {@code null} input array.</p>
      *
-     * @param array  the array to clone, may be <code>null</code>
-     * @return the cloned array, <code>null</code> if <code>null</code> input
+     * @param array  the array to clone, may be {@code null}
+     * @return the cloned array, {@code null} if {@code null} input
      */
     public static float[] clone(float[] array) {
         if (array == null) {
@@ -440,12 +440,12 @@ public class ArrayUtils {
 
     /**
      * <p>Clones an array returning a typecast result and handling
-     * <code>null</code>.</p>
+     * {@code null}.</p>
      *
-     * <p>This method returns <code>null</code> for a <code>null</code> input array.</p>
+     * <p>This method returns {@code null} for a {@code null} input array.</p>
      *
-     * @param array  the array to clone, may be <code>null</code>
-     * @return the cloned array, <code>null</code> if <code>null</code> input
+     * @param array  the array to clone, may be {@code null}
+     * @return the cloned array, {@code null} if {@code null} input
      */
     public static boolean[] clone(boolean[] array) {
         if (array == null) {
@@ -457,16 +457,16 @@ public class ArrayUtils {
     // nullToEmpty
     //-----------------------------------------------------------------------
     /**
-     * <p>Defensive programming technique to change a <code>null</code>
+     * <p>Defensive programming technique to change a {@code null}
      * reference to an empty one.</p>
      *
-     * <p>This method returns an empty array for a <code>null</code> input array.</p>
+     * <p>This method returns an empty array for a {@code null} input array.</p>
      * 
      * <p>As a memory optimizing technique an empty array passed in will be overridden with 
-     * the empty <code>public static</code> references in this class.</p>
+     * the empty {@code public static} references in this class.</p>
      *
-     * @param array  the array to check for <code>null</code> or empty
-     * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input
+     * @param array  the array to check for {@code null} or empty
+     * @return the same array, {@code public static} empty array if {@code null} or empty input
      * @since 2.5
      */
     public static Object[] nullToEmpty(Object[] array) {
@@ -477,16 +477,16 @@ public class ArrayUtils {
     }
 
     /**
-     * <p>Defensive programming technique to change a <code>null</code>
+     * <p>Defensive programming technique to change a {@code null}
      * reference to an empty one.</p>
      *
-     * <p>This method returns an empty array for a <code>null</code> input array.</p>
+     * <p>This method returns an empty array for a {@code null} input array.</p>
      * 
      * <p>As a memory optimizing technique an empty array passed in will be overridden with 
-     * the empty <code>public static</code> references in this class.</p>
+     * the empty {@code public static} references in this class.</p>
      *
-     * @param array  the array to check for <code>null</code> or empty
-     * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input
+     * @param array  the array to check for {@code null} or empty
+     * @return the same array, {@code public static} empty array if {@code null} or empty input
      * @since 2.5
      */
     public static String[] nullToEmpty(String[] array) {
@@ -497,16 +497,16 @@ public class ArrayUtils {
     }
 
     /**
-     * <p>Defensive programming technique to change a <code>null</code>
+     * <p>Defensive programming technique to change a {@code null}
      * reference to an empty one.</p>
      *
-     * <p>This method returns an empty array for a <code>null</code> input array.</p>
+     * <p>This method returns an empty array for a {@code null} input array.</p>
      * 
      * <p>As a memory optimizing technique an empty array passed in will be overridden with 
-     * the empty <code>public static</code> references in this class.</p>
+     * the empty {@code public static} references in this class.</p>
      *
-     * @param array  the array to check for <code>null</code> or empty
-     * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input
+     * @param array  the array to check for {@code null} or empty
+     * @return the same array, {@code public static} empty array if {@code null} or empty input
      * @since 2.5
      */
     public static long[] nullToEmpty(long[] array) {
@@ -517,16 +517,16 @@ public class ArrayUtils {
     }
 
     /**
-     * <p>Defensive programming technique to change a <code>null</code>
+     * <p>Defensive programming technique to change a {@code null}
      * reference to an empty one.</p>
      *
-     * <p>This method returns an empty array for a <code>null</code> input array.</p>
+     * <p>This method returns an empty array for a {@code null} input array.</p>
      * 
      * <p>As a memory optimizing technique an empty array passed in will be overridden with 
-     * the empty <code>public static</code> references in this class.</p>
+     * the empty {@code public static} references in this class.</p>
      *
-     * @param array  the array to check for <code>null</code> or empty
-     * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input
+     * @param array  the array to check for {@code null} or empty
+     * @return the same array, {@code public static} empty array if {@code null} or empty input
      * @since 2.5
      */
     public static int[] nullToEmpty(int[] array) {
@@ -537,16 +537,16 @@ public class ArrayUtils {
     }
 
     /**
-     * <p>Defensive programming technique to change a <code>null</code>
+     * <p>Defensive programming technique to change a {@code null}
      * reference to an empty one.</p>
      *
-     * <p>This method returns an empty array for a <code>null</code> input array.</p>
+     * <p>This method returns an empty array for a {@code null} input array.</p>
      * 
      * <p>As a memory optimizing technique an empty array passed in will be overridden with 
-     * the empty <code>public static</code> references in this class.</p>
+     * the empty {@code public static} references in this class.</p>
      *
-     * @param array  the array to check for <code>null</code> or empty
-     * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input
+     * @param array  the array to check for {@code null} or empty
+     * @return the same array, {@code public static} empty array if {@code null} or empty input
      * @since 2.5
      */
     public static short[] nullToEmpty(short[] array) {
@@ -557,16 +557,16 @@ public class ArrayUtils {
     }
 
     /**
-     * <p>Defensive programming technique to change a <code>null</code>
+     * <p>Defensive programming technique to change a {@code null}
      * reference to an empty one.</p>
      *
-     * <p>This method returns an empty array for a <code>null</code> input array.</p>
+     * <p>This method returns an empty array for a {@code null} input array.</p>
      * 
      * <p>As a memory optimizing technique an empty array passed in will be overridden with 
-     * the empty <code>public static</code> references in this class.</p>
+     * the empty {@code public static} references in this class.</p>
      *
-     * @param array  the array to check for <code>null</code> or empty
-     * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input
+     * @param array  the array to check for {@code null} or empty
+     * @return the same array, {@code public static} empty array if {@code null} or empty input
      * @since 2.5
      */
     public static char[] nullToEmpty(char[] array) {
@@ -577,16 +577,16 @@ public class ArrayUtils {
     }
 
     /**
-     * <p>Defensive programming technique to change a <code>null</code>
+     * <p>Defensive programming technique to change a {@code null}
      * reference to an empty one.</p>
      *
-     * <p>This method returns an empty array for a <code>null</code> input array.</p>
+     * <p>This method returns an empty array for a {@code null} input array.</p>
      * 
      * <p>As a memory optimizing technique an empty array passed in will be overridden with 
-     * the empty <code>public static</code> references in this class.</p>
+     * the empty {@code public static} references in this class.</p>
      *
-     * @param array  the array to check for <code>null</code> or empty
-     * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input
+     * @param array  the array to check for {@code null} or empty
+     * @return the same array, {@code public static} empty array if {@code null} or empty input
      * @since 2.5
      */
     public static byte[] nullToEmpty(byte[] array) {
@@ -597,16 +597,16 @@ public class ArrayUtils {
     }
 
     /**
-     * <p>Defensive programming technique to change a <code>null</code>
+     * <p>Defensive programming technique to change a {@code null}
      * reference to an empty one.</p>
      *
-     * <p>This method returns an empty array for a <code>null</code> input array.</p>
+     * <p>This method returns an empty array for a {@code null} input array.</p>
      * 
      * <p>As a memory optimizing technique an empty array passed in will be overridden with 
-     * the empty <code>public static</code> references in this class.</p>
+     * the empty {@code public static} references in this class.</p>
      *
-     * @param array  the array to check for <code>null</code> or empty
-     * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input
+     * @param array  the array to check for {@code null} or empty
+     * @return the same array, {@code public static} empty array if {@code null} or empty input
      * @since 2.5
      */
     public static double[] nullToEmpty(double[] array) {
@@ -617,16 +617,16 @@ public class ArrayUtils {
     }
 
     /**
-     * <p>Defensive programming technique to change a <code>null</code>
+     * <p>Defensive programming technique to change a {@code null}
      * reference to an empty one.</p>
      *
-     * <p>This method returns an empty array for a <code>null</code> input array.</p>
+     * <p>This method returns an empty array for a {@code null} input array.</p>
      * 
      * <p>As a memory optimizing technique an empty array passed in will be overridden with 
-     * the empty <code>public static</code> references in this class.</p>
+     * the empty {@code public static} references in this class.</p>
      *
-     * @param array  the array to check for <code>null</code> or empty
-     * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input
+     * @param array  the array to check for {@code null} or empty
+     * @return the same array, {@code public static} empty array if {@code null} or empty input
      * @since 2.5
      */
     public static float[] nullToEmpty(float[] array) {
@@ -637,16 +637,16 @@ public class ArrayUtils {
     }
 
     /**
-     * <p>Defensive programming technique to change a <code>null</code>
+     * <p>Defensive programming technique to change a {@code null}
      * reference to an empty one.</p>
      *
-     * <p>This method returns an empty array for a <code>null</code> input array.</p>
+     * <p>This method returns an empty array for a {@code null} input array.</p>
      * 
      * <p>As a memory optimizing technique an empty array passed in will be overridden with 
-     * the empty <code>public static</code> references in this class.</p>
+     * the empty {@code public static} references in this class.</p>
      *
-     * @param array  the array to check for <code>null</code> or empty
-     * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input
+     * @param array  the array to check for {@code null} or empty
+     * @return the same array, {@code public static} empty array if {@code null} or empty input
      * @since 2.5
      */
     public static boolean[] nullToEmpty(boolean[] array) {
@@ -657,16 +657,16 @@ public class ArrayUtils {
     }
 
     /**
-     * <p>Defensive programming technique to change a <code>null</code>
+     * <p>Defensive programming technique to change a {@code null}
      * reference to an empty one.</p>
      *
-     * <p>This method returns an empty array for a <code>null</code> input array.</p>
+     * <p>This method returns an empty array for a {@code null} input array.</p>
      * 
      * <p>As a memory optimizing technique an empty array passed in will be overridden with 
-     * the empty <code>public static</code> references in this class.</p>
+     * the empty {@code public static} references in this class.</p>
      *
-     * @param array  the array to check for <code>null</code> or empty
-     * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input
+     * @param array  the array to check for {@code null} or empty
+     * @return the same array, {@code public static} empty array if {@code null} or empty input
      * @since 2.5
      */
     public static Long[] nullToEmpty(Long[] array) {
@@ -677,16 +677,16 @@ public class ArrayUtils {
     }
 
     /**
-     * <p>Defensive programming technique to change a <code>null</code>
+     * <p>Defensive programming technique to change a {@code null}
      * reference to an empty one.</p>
      *
-     * <p>This method returns an empty array for a <code>null</code> input array.</p>
+     * <p>This method returns an empty array for a {@code null} input array.</p>
      * 
      * <p>As a memory optimizing technique an empty array passed in will be overridden with 
-     * the empty <code>public static</code> references in this class.</p>
+     * the empty {@code public static} references in this class.</p>
      *
-     * @param array  the array to check for <code>null</code> or empty
-     * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input
+     * @param array  the array to check for {@code null} or empty
+     * @return the same array, {@code public static} empty array if {@code null} or empty input
      * @since 2.5
      */
     public static Integer[] nullToEmpty(Integer[] array) {
@@ -697,16 +697,16 @@ public class ArrayUtils {
     }
 
     /**
-     * <p>Defensive programming technique to change a <code>null</code>
+     * <p>Defensive programming technique to change a {@code null}
      * reference to an empty one.</p>
      *
-     * <p>This method returns an empty array for a <code>null</code> input array.</p>
+     * <p>This method returns an empty array for a {@code null} input array.</p>
      * 
      * <p>As a memory optimizing technique an empty array passed in will be overridden with 
-     * the empty <code>public static</code> references in this class.</p>
+     * the empty {@code public static} references in this class.</p>
      *
-     * @param array  the array to check for <code>null</code> or empty
-     * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input
+     * @param array  the array to check for {@code null} or empty
+     * @return the same array, {@code public static} empty array if {@code null} or empty input
      * @since 2.5
      */
     public static Short[] nullToEmpty(Short[] array) {
@@ -717,16 +717,16 @@ public class ArrayUtils {
     }
 
     /**
-     * <p>Defensive programming technique to change a <code>null</code>
+     * <p>Defensive programming technique to change a {@code null}
      * reference to an empty one.</p>
      *
-     * <p>This method returns an empty array for a <code>null</code> input array.</p>
+     * <p>This method returns an empty array for a {@code null} input array.</p>
      * 
      * <p>As a memory optimizing technique an empty array passed in will be overridden with 
-     * the empty <code>public static</code> references in this class.</p>
+     * the empty {@code public static} references in this class.</p>
      *
-     * @param array  the array to check for <code>null</code> or empty
-     * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input
+     * @param array  the array to check for {@code null} or empty
+     * @return the same array, {@code public static} empty array if {@code null} or empty input
      * @since 2.5
      */
     public static Character[] nullToEmpty(Character[] array) {
@@ -737,16 +737,16 @@ public class ArrayUtils {
     }
 
     /**
-     * <p>Defensive programming technique to change a <code>null</code>
+     * <p>Defensive programming technique to change a {@code null}
      * reference to an empty one.</p>
      *
-     * <p>This method returns an empty array for a <code>null</code> input array.</p>
+     * <p>This method returns an empty array for a {@code null} input array.</p>
      * 
      * <p>As a memory optimizing technique an empty array passed in will be overridden with 
-     * the empty <code>public static</code> references in this class.</p>
+     * the empty {@code public static} references in this class.</p>
      *
-     * @param array  the array to check for <code>null</code> or empty
-     * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input
+     * @param array  the array to check for {@code null} or empty
+     * @return the same array, {@code public static} empty array if {@code null} or empty input
      * @since 2.5
      */
     public static Byte[] nullToEmpty(Byte[] array) {
@@ -757,16 +757,16 @@ public class ArrayUtils {
     }
 
     /**
-     * <p>Defensive programming technique to change a <code>null</code>
+     * <p>Defensive programming technique to change a {@code null}
      * reference to an empty one.</p>
      *
-     * <p>This method returns an empty array for a <code>null</code> input array.</p>
+     * <p>This method returns an empty array for a {@code null} input array.</p>
      * 
      * <p>As a memory optimizing technique an empty array passed in will be overridden with 
-     * the empty <code>public static</code> references in this class.</p>
+     * the empty {@code public static} references in this class.</p>
      *
-     * @param array  the array to check for <code>null</code> or empty
-     * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input
+     * @param array  the array to check for {@code null} or empty
+     * @return the same array, {@code public static} empty array if {@code null} or empty input
      * @since 2.5
      */
     public static Double[] nullToEmpty(Double[] array) {
@@ -777,16 +777,16 @@ public class ArrayUtils {
     }
 
     /**
-     * <p>Defensive programming technique to change a <code>null</code>
+     * <p>Defensive programming technique to change a {@code null}
      * reference to an empty one.</p>
      *
-     * <p>This method returns an empty array for a <code>null</code> input array.</p>
+     * <p>This method returns an empty array for a {@code null} input array.</p>
      * 
      * <p>As a memory optimizing technique an empty array passed in will be overridden with 
-     * the empty <code>public static</code> references in this class.</p>
+     * the empty {@code public static} references in this class.</p>
      *
-     * @param array  the array to check for <code>null</code> or empty
-     * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input
+     * @param array  the array to check for {@code null} or empty
+     * @return the same array, {@code public static} empty array if {@code null} or empty input
      * @since 2.5
      */
     public static Float[] nullToEmpty(Float[] array) {
@@ -797,16 +797,16 @@ public class ArrayUtils {
     }
 
     /**
-     * <p>Defensive programming technique to change a <code>null</code>
+     * <p>Defensive programming technique to change a {@code null}
      * reference to an empty one.</p>
      *
-     * <p>This method returns an empty array for a <code>null</code> input array.</p>
+     * <p>This method returns an empty array for a {@code null} input array.</p>
      * 
      * <p>As a memory optimizing technique an empty array passed in will be overridden with 
-     * the empty <code>public static</code> references in this class.</p>
+     * the empty {@code public static} references in this class.</p>
      *
-     * @param array  the array to check for <code>null</code> or empty
-     * @return the same array, <code>public static</code> empty array if <code>null</code> or empty input
+     * @param array  the array to check for {@code null} or empty
+     * @return the same array, {@code public static} empty array if {@code null} or empty input
      * @since 2.5
      */
     public static Boolean[] nullToEmpty(Boolean[] array) {
@@ -827,7 +827,7 @@ public class ArrayUtils {
      *
      * <p>The component type of the subarray is always the same as
      * that of the input array. Thus, if the input is an array of type
-     * <code>Date</code>, the following usage is envisaged:</p>
+     * {@code Date}, the following usage is envisaged:</p>
      *
      * <pre>
      * Date[] someDates = (Date[])ArrayUtils.subarray(allDates, 2, 5);
@@ -869,7 +869,7 @@ public class ArrayUtils {
     }
 
     /**
-     * <p>Produces a new <code>long</code> array containing the elements
+     * <p>Produces a new {@code long} array containing the elements
      * between the start and end indices.</p>
      *
      * <p>The start index is inclusive, the end index exclusive.
@@ -908,7 +908,7 @@ public class ArrayUtils {
     }
 
     /**
-     * <p>Produces a new <code>int</code> array containing the elements
+     * <p>Produces a new {@code int} array containing the elements
      * between the start and end indices.</p>
      *
      * <p>The start index is inclusive, the end index exclusive.
@@ -947,7 +947,7 @@ public class ArrayUtils {
     }
 
     /**
-     * <p>Produces a new <code>short</code> array containing the elements
+     * <p>Produces a new {@code short} array containing the elements
      * between the start and end indices.</p>
      *
      * <p>The start index is inclusive, the end index exclusive.
@@ -986,7 +986,7 @@ public class ArrayUtils {
     }
 
     /**
-     * <p>Produces a new <code>char</code> array containing the elements
+     * <p>Produces a new {@code char} array containing the elements
      * between the start and end indices.</p>
      *
      * <p>The start index is inclusive, the end index exclusive.
@@ -1025,7 +1025,7 @@ public class ArrayUtils {
     }
 
     /**
-     * <p>Produces a new <code>byte</code> array containing the elements
+     * <p>Produces a new {@code byte} array containing the elements
      * between the start and end indices.</p>
      *
      * <p>The start index is inclusive, the end index exclusive.
@@ -1064,7 +1064,7 @@ public class ArrayUtils {
     }
 
     /**
-     * <p>Produces a new <code>double</code> array containing the elements
+     * <p>Produces a new {@code double} array containing the elements
      * between the start and end indices.</p>
      *
      * <p>The start index is inclusive, the end index exclusive.
@@ -1103,7 +1103,7 @@ public class ArrayUtils {
     }
 
     /**
-     * <p>Produces a new <code>float</code> array containing the elements
+     * <p>Produces a new {@code float} array containing the elements
      * between the start and end indices.</p>
      *
      * <p>The start index is inclusive, the end index exclusive.
@@ -1142,7 +1142,7 @@ public class ArrayUtils {
     }
 
     /**
-     * <p>Produces a new <code>boolean</code> array containing the elements
+     * <p>Produces a new {@code boolean} array containing the elements
      * between the start and end indices.</p>
      *
      * <p>The start index is inclusive, the end index exclusive.
@@ -1184,14 +1184,14 @@ public class ArrayUtils {
     //-----------------------------------------------------------------------
     /**
      * <p>Checks whether two arrays are the same length, treating
-     * <code>null</code> arrays as length <code>0</code>.
+     * {@code null} arrays as length {@code 0}.
      *
      * <p>Any multi-dimensional aspects of the arrays are ignored.</p>
      *
-     * @param array1 the first array, may be <code>null</code>
-     * @param array2 the second array, may be <code>null</code>
-     * @return <code>true</code> if length of arrays matches, treating
-     *  <code>null</code> as an empty array
+     * @param array1 the first array, may be {@code null}
+     * @param array2 the second array, may be {@code null}
+     * @return {@code true} if length of arrays matches, treating
+     *  {@code null} as an empty array
      */
     public static boolean isSameLength(Object[] array1, Object[] array2) {
         if ((array1 == null && array2 != null && array2.length > 0) ||
@@ -1204,12 +1204,12 @@ public class ArrayUtils {
 
     /**
      * <p>Checks whether two arrays are the same length, treating
-     * <code>null</code> arrays as length <code>0</code>.</p>
+     * {@code null} arrays as length {@code 0}.</p>
      *
-     * @param array1 the first array, may be <code>null</code>
-     * @param array2 the second array, may be <code>null</code>
-     * @return <code>true</code> if length of arrays matches, treating
-     *  <code>null</code> as an empty array
+     * @param array1 the first array, may be {@code null}
+     * @param array2 the second array, may be {@code null}
+     * @return {@code true} if length of arrays matches, treating
+     *  {@code null} as an empty array
      */
     public static boolean isSameLength(long[] array1, long[] array2) {
         if ((array1 == null && array2 != null && array2.length > 0) ||
@@ -1222,12 +1222,12 @@ public class ArrayUtils {
 
     /**
      * <p>Checks whether two arrays are the same length, treating
-     * <code>null</code> arrays as length <code>0</code>.</p>
+     * {@code null} arrays as length {@code 0}.</p>
      *
-     * @param array1 the first array, may be <code>null</code>
-     * @param array2 the second array, may be <code>null</code>
-     * @return <code>true</code> if length of arrays matches, treating
-     *  <code>null</code> as an empty array
+     * @param array1 the first array, may be {@code null}
+     * @param array2 the second array, may be {@code null}
+     * @return {@code true} if length of arrays matches, treating
+     *  {@code null} as an empty array
      */
     public static boolean isSameLength(int[] array1, int[] array2) {
         if ((array1 == null && array2 != null && array2.length > 0) ||
@@ -1240,12 +1240,12 @@ public class ArrayUtils {
 
     /**
      * <p>Checks whether two arrays are the same length, treating
-     * <code>null</code> arrays as length <code>0</code>.</p>
+     * {@code null} arrays as length {@code 0}.</p>
      *
-     * @param array1 the first array, may be <code>null</code>
-     * @param array2 the second array, may be <code>null</code>
-     * @return <code>true</code> if length of arrays matches, treating
-     *  <code>null</code> as an empty array
+     * @param array1 the first array, may be {@code null}
+     * @param array2 the second array, may be {@code null}
+     * @return {@code true} if length of arrays matches, treating
+     *  {@code null} as an empty array
      */
     public static boolean isSameLength(short[] array1, short[] array2) {
         if ((array1 == null && array2 != null && array2.length > 0) ||
@@ -1258,12 +1258,12 @@ public class ArrayUtils {
 
     /**
      * <p>Checks whether two arrays are the same length, treating
-     * <code>null</code> arrays as length <code>0</code>.</p>
+     * {@code null} arrays as length {@code 0}.</p>
      *
-     * @param array1 the first array, may be <code>null</code>
-     * @param array2 the second array, may be <code>null</code>
-     * @return <code>true</code> if length of arrays matches, treating
-     *  <code>null</code> as an empty array
+     * @param array1 the first array, may be {@code null}
+     * @param array2 the second array, may be {@code null}
+     * @return {@code true} if length of arrays matches, treating
+     *  {@code null} as an empty array
      */
     public static boolean isSameLength(char[] array1, char[] array2) {
         if ((array1 == null && array2 != null && array2.length > 0) ||
@@ -1276,12 +1276,12 @@ public class ArrayUtils {
 
     /**
      * <p>Checks whether two arrays are the same length, treating
-     * <code>null</code> arrays as length <code>0</code>.</p>
+     * {@code null} arrays as length {@code 0}.</p>
      *
-     * @param array1 the first array, may be <code>null</code>
-     * @param array2 the second array, may be <code>null</code>
-     * @return <code>true</code> if length of arrays matches, treating
-     *  <code>null</code> as an empty array
+     * @param array1 the first array, may be {@code null}
+     * @param array2 the second array, may be {@code null}
+     * @return {@code true} if length of arrays matches, treating
+     *  {@code null} as an empty array
      */
     public static boolean isSameLength(byte[] array1, byte[] array2) {
         if ((array1 == null && array2 != null && array2.length > 0) ||
@@ -1294,12 +1294,12 @@ public class ArrayUtils {
 
     /**
      * <p>Checks whether two arrays are the same length, treating
-     * <code>null</code> arrays as length <code>0</code>.</p>
+     * {@code null} arrays as length {@code 0}.</p>
      *
-     * @param array1 the first array, may be <code>null</code>
-     * @param array2 the second array, may be <code>null</code>
-     * @return <code>true</code> if length of arrays matches, treating
-     *  <code>null</code> as an empty array
+     * @param array1 the first array, may be {@code null}
+     * @param array2 the second array, may be {@code null}
+     * @return {@code true} if length of arrays matches, treating
+     *  {@code null} as an empty array
      */
     public static boolean isSameLength(double[] array1, double[] array2) {
         if ((array1 == null && array2 != null && array2.length > 0) ||
@@ -1312,12 +1312,12 @@ public class ArrayUtils {
 
     /**
      * <p>Checks whether two arrays are the same length, treating
-     * <code>null</code> arrays as length <code>0</code>.</p>
+     * {@code null} arrays as length {@code 0}.</p>
      *
-     * @param array1 the first array, may be <code>null</code>
-     * @param array2 the second array, may be <code>null</code>
-     * @return <code>true</code> if length of arrays matches, treating
-     *  <code>null</code> as an empty array
+     * @param array1 the first array, may be {@code null}
+     * @param array2 the second array, may be {@code null}
+     * @return {@code true} if length of arrays matches, treating
+     *  {@code null} as an empty array
      */
     public static boolean isSameLength(float[] array1, float[] array2) {
         if ((array1 == null && array2 != null && array2.length > 0) ||
@@ -1330,12 +1330,12 @@ public class ArrayUtils {
 
     /**
      * <p>Checks whether two arrays are the same length, treating
-     * <code>null</code> arrays as length <code>0</code>.</p>
+     * {@code null} arrays as length {@code 0}.</p>
      *
-     * @param array1 the first array, may be <code>null</code>
-     * @param array2 the second array, may be <code>null</code>
-     * @return <code>true</code> if length of arrays matches, treating
-     *  <code>null</code> as an empty array
+     * @param array1 the first array, may be {@code null}
+     * @param array2 the second array, may be {@code null}
+     * @return {@code true} if length of arrays matches, treating
+     *  {@code null} as an empty array
      */
     public static boolean isSameLength(boolean[] array1, boolean[] array2) {
         if ((array1 == null && array2 != null && array2.length > 0) ||
@@ -1349,9 +1349,9 @@ public class ArrayUtils {
     //-----------------------------------------------------------------------
     /**
      * <p>Returns the length of the specified array.
-     * This method can deal with <code>Object</code> arrays and with primitive arrays.</p>
+     * This method can deal with {@code Object} arrays and with primitive arrays.</p>
      *
-     * <p>If the input array is <code>null</code>, <code>0</code> is returned.</p>
+     * <p>If the input array is {@code null}, {@code 0} is returned.</p>
      *
      * <pre>
      * ArrayUtils.getLength(null)            = 0
@@ -1363,7 +1363,7 @@ public class ArrayUtils {
      * </pre>
      *
      * @param array  the array to retrieve the length from, may be null
-     * @return The length of the array, or <code>0</code> if the array is <code>null</code>
+     * @return The length of the array, or {@code 0} if the array is {@code null}
      * @throws IllegalArgumentException if the object arguement is not an array.
      * @since 2.1
      */
@@ -1378,10 +1378,10 @@ public class ArrayUtils {
      * <p>Checks whether two arrays are the same type taking into account
      * multi-dimensional arrays.</p>
      *
-     * @param array1 the first array, must not be <code>null</code>
-     * @param array2 the second array, must not be <code>null</code>
-     * @return <code>true</code> if type of arrays matches
-     * @throws IllegalArgumentException if either array is <code>null</code>
+     * @param array1 the first array, must not be {@code null}
+     * @param array2 the second array, must not be {@code null}
+     * @return {@code true} if type of arrays matches
+     * @throws IllegalArgumentException if either array is {@code null}
      */
     public static boolean isSameType(Object array1, Object array2) {
         if (array1 == null || array2 == null) {
@@ -1397,9 +1397,9 @@ public class ArrayUtils {
      *
      * <p>There is no special handling for multi-dimensional arrays.</p>
      *
-     * <p>This method does nothing for a <code>null</code> input array.</p>
+     * <p>This method does nothing for a {@code null} input array.</p>
      *
-     * @param array  the array to reverse, may be <code>null</code>
+     * @param array  the array to reverse, may be {@code null}
      */
     public static void reverse(Object[] array) {
         if (array == null) {
@@ -1420,9 +1420,9 @@ public class ArrayUtils {
     /**
      * <p>Reverses the order of the given array.</p>
      *
-     * <p>This method does nothing for a <code>null</code> input array.</p>
+     * <p>This method does nothing for a {@code null} input array.</p>
      *
-     * @param array  the array to reverse, may be <code>null</code>
+     * @param array  the array to reverse, may be {@code null}
      */
     public static void reverse(long[] array) {
         if (array == null) {
@@ -1443,9 +1443,9 @@ public class ArrayUtils {
     /**
      * <p>Reverses the order of the given array.</p>
      *
-     * <p>This method does nothing for a <code>null</code> input array.</p>
+     * <p>This method does nothing for a {@code null} input array.</p>
      *
-     * @param array  the array to reverse, may be <code>null</code>
+     * @param array  the array to reverse, may be {@code null}
      */
     public static void reverse(int[] array) {
         if (array == null) {
@@ -1466,9 +1466,9 @@ public class ArrayUtils {
     /**
      * <p>Reverses the order of the given array.</p>
      *
-     * <p>This method does nothing for a <code>null</code> input array.</p>
+     * <p>This method does nothing for a {@code null} input array.</p>
      *
-     * @param array  the array to reverse, may be <code>null</code>
+     * @param array  the array to reverse, may be {@code null}
      */
     public static void reverse(short[] array) {
         if (array == null) {
@@ -1489,9 +1489,9 @@ public class ArrayUtils {
     /**
      * <p>Reverses the order of the given array.</p>
      *
-     * <p>This method does nothing for a <code>null</code> input array.</p>
+     * <p>This method does nothing for a {@code null} input array.</p>
      *
-     * @param array  the array to reverse, may be <code>null</code>
+     * @param array  the array to reverse, may be {@code null}
      */
     public static void reverse(char[] array) {
         if (array == null) {
@@ -1512,9 +1512,9 @@ public class ArrayUtils {
     /**
      * <p>Reverses the order of the given array.</p>
      *
-     * <p>This method does nothing for a <code>null</code> input array.</p>
+     * <p>This method does nothing for a {@code null} input array.</p>
      *
-     * @param array  the array to reverse, may be <code>null</code>
+     * @param array  the array to reverse, may be {@code null}
      */
     public static void reverse(byte[] array) {
         if (array == null) {
@@ -1535,9 +1535,9 @@ public class ArrayUtils {
     /**
      * <p>Reverses the order of the given array.</p>
      *
-     * <p>This method does nothing for a <code>null</code> input array.</p>
+     * <p>This method does nothing for a {@code null} input array.</p>
      *
-     * @param array  the array to reverse, may be <code>null</code>
+     * @param array  the array to reverse, may be {@code null}
      */
     public static void reverse(double[] array) {
         if (array == null) {
@@ -1558,9 +1558,9 @@ public class ArrayUtils {
     /**
      * <p>Reverses the order of the given array.</p>
      *
-     * <p>This method does nothing for a <code>null</code> input array.</p>
+     * <p>This method does nothing for a {@code null} input array.</p>
      *
-     * @param array  the array to reverse, may be <code>null</code>
+     * @param array  the array to reverse, may be {@code null}
      */
     public static void reverse(float[] array) {
         if (array == null) {
@@ -1581,9 +1581,9 @@ public class ArrayUtils {
     /**
      * <p>Reverses the order of the given array.</p>
      *
-     * <p>This method does nothing for a <code>null</code> input array.</p>
+     * <p>This method does nothing for a {@code null} input array.</p>
      *
-     * @param array  the array to reverse, may be <code>null</code>
+     * @param array  the array to reverse, may be {@code null}
      */
     public static void reverse(boolean[] array) {
         if (array == null) {
@@ -1609,12 +1609,12 @@ public class ArrayUtils {
     /**
      * <p>Finds the index of the given object in the array.</p>
      *
-     * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
+     * <p>This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.</p>
      *
-     * @param array  the array to search through for the object, may be <code>null</code>
-     * @param objectToFind  the object to find, may be <code>null</code>
+     * @param array  the array to search through for the object, may be {@code null}
+     * @param objectToFind  the object to find, may be {@code null}
      * @return the index of the object within the array,
-     *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
+     *  {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input
      */
     public static int indexOf(Object[] array, Object objectToFind) {
         return indexOf(array, objectToFind, 0);
@@ -1623,16 +1623,16 @@ public class ArrayUtils {
     /**
      * <p>Finds the index of the given object in the array starting at the given index.</p>
      *
-     * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
+     * <p>This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.</p>
      *
      * <p>A negative startIndex is treated as zero. A startIndex larger than the array
-     * length will return {@link #INDEX_NOT_FOUND} (<code>-1</code>).</p>
+     * length will return {@link #INDEX_NOT_FOUND} ({@code -1}).</p>
      *
-     * @param array  the array to search through for the object, may be <code>null</code>
-     * @param objectToFind  the object to find, may be <code>null</code>
+     * @param array  the array to search through for the object, may be {@code null}
+     * @param objectToFind  the object to find, may be {@code null}
      * @param startIndex  the index to start searching at
      * @return the index of the object within the array starting at the index,
-     *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
+     *  {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input
      */
     public static int indexOf(Object[] array, Object objectToFind, int startIndex) {
         if (array == null) {
@@ -1660,12 +1660,12 @@ public class ArrayUtils {
     /**
      * <p>Finds the last index of the given object within the array.</p>
      *
-     * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
+     * <p>This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.</p>
      *
-     * @param array  the array to travers backwords looking for the object, may be <code>null</code>
-     * @param objectToFind  the object to find, may be <code>null</code>
+     * @param array  the array to travers backwords looking for the object, may be {@code null}
+     * @param objectToFind  the object to find, may be {@code null}
      * @return the last index of the object within the array,
-     *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
+     *  {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input
      */
     public static int lastIndexOf(Object[] array, Object objectToFind) {
         return lastIndexOf(array, objectToFind, Integer.MAX_VALUE);
@@ -1674,16 +1674,16 @@ public class ArrayUtils {
     /**
      * <p>Finds the last index of the given object in the array starting at the given index.</p>
      *
-     * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
+     * <p>This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.</p>
      *
-     * <p>A negative startIndex will return {@link #INDEX_NOT_FOUND} (<code>-1</code>). A startIndex larger than
+     * <p>A negative startIndex will return {@link #INDEX_NOT_FOUND} ({@code -1}). A startIndex larger than
      * the array length will search from the end of the array.</p>
      *
-     * @param array  the array to traverse for looking for the object, may be <code>null</code>
-     * @param objectToFind  the object to find, may be <code>null</code>
+     * @param array  the array to traverse for looking for the object, may be {@code null}
+     * @param objectToFind  the object to find, may be {@code null}
      * @param startIndex  the start index to travers backwards from
      * @return the last index of the object within the array,
-     *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
+     *  {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input
      */
     public static int lastIndexOf(Object[] array, Object objectToFind, int startIndex) {
         if (array == null) {
@@ -1713,11 +1713,11 @@ public class ArrayUtils {
     /**
      * <p>Checks if the object is in the given array.</p>
      *
-     * <p>The method returns <code>false</code> if a <code>null</code> array is passed in.</p>
+     * <p>The method returns {@code false} if a {@code null} array is passed in.</p>
      *
      * @param array  the array to search through
      * @param objectToFind  the object to find
-     * @return <code>true</code> if the array contains the object
+     * @return {@code true} if the array contains the object
      */
     public static boolean contains(Object[] array, Object objectToFind) {
         return indexOf(array, objectToFind) != INDEX_NOT_FOUND;
@@ -1728,12 +1728,12 @@ public class ArrayUtils {
     /**
      * <p>Finds the index of the given value in the array.</p>
      *
-     * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
+     * <p>This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.</p>
      *
-     * @param array  the array to search through for the object, may be <code>null</code>
+     * @param array  the array to search through for the object, may be {@code null}
      * @param valueToFind  the value to find
      * @return the index of the value within the array,
-     *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
+     *  {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input
      */
     public static int indexOf(long[] array, long valueToFind) {
         return indexOf(array, valueToFind, 0);
@@ -1742,16 +1742,16 @@ public class ArrayUtils {
     /**
      * <p>Finds the index of the given value in the array starting at the given index.</p>
      *
-     * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
+     * <p>This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.</p>
      *
      * <p>A negative startIndex is treated as zero. A startIndex larger than the array
-     * length will return {@link #INDEX_NOT_FOUND} (<code>-1</code>).</p>
+     * length will return {@link #INDEX_NOT_FOUND} ({@code -1}).</p>
      *
-     * @param array  the array to search through for the object, may be <code>null</code>
+     * @param array  the array to search through for the object, may be {@code null}
      * @param valueToFind  the value to find
      * @param startIndex  the index to start searching at
      * @return the index of the value within the array,
-     *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
+     *  {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input
      */
     public static int indexOf(long[] array, long valueToFind, int startIndex) {
         if (array == null) {
@@ -1771,12 +1771,12 @@ public class ArrayUtils {
     /**
      * <p>Finds the last index of the given value within the array.</p>
      *
-     * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
+     * <p>This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.</p>
      *
-     * @param array  the array to travers backwords looking for the object, may be <code>null</code>
+     * @param array  the array to travers backwords looking for the object, may be {@code null}
      * @param valueToFind  the object to find
      * @return the last index of the value within the array,
-     *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
+     *  {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input
      */
     public static int lastIndexOf(long[] array, long valueToFind) {
         return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
@@ -1785,16 +1785,16 @@ public class ArrayUtils {
     /**
      * <p>Finds the last index of the given value in the array starting at the given index.</p>
      *
-     * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
+     * <p>This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.</p>
      *
-     * <p>A negative startIndex will return {@link #INDEX_NOT_FOUND} (<code>-1</code>). A startIndex larger than the
+     * <p>A negative startIndex will return {@link #INDEX_NOT_FOUND} ({@code -1}). A startIndex larger than the
      * array length will search from the end of the array.</p>
      *
-     * @param array  the array to traverse for looking for the object, may be <code>null</code>
+     * @param array  the array to traverse for looking for the object, may be {@code null}
      * @param valueToFind  the value to find
      * @param startIndex  the start index to travers backwards from
      * @return the last index of the value within the array,
-     *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
+     *  {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input
      */
     public static int lastIndexOf(long[] array, long valueToFind, int startIndex) {
         if (array == null) {
@@ -1816,11 +1816,11 @@ public class ArrayUtils {
     /**
      * <p>Checks if the value is in the given array.</p>
      *
-     * <p>The method returns <code>false</code> if a <code>null</code> array is passed in.</p>
+     * <p>The method returns {@code false} if a {@code null} array is passed in.</p>
      *
      * @param array  the array to search through
      * @param valueToFind  the value to find
-     * @return <code>true</code> if the array contains the object
+     * @return {@code true} if the array contains the object
      */
     public static boolean contains(long[] array, long valueToFind) {
         return indexOf(array, valueToFind) != INDEX_NOT_FOUND;
@@ -1831,12 +1831,12 @@ public class ArrayUtils {
     /**
      * <p>Finds the index of the given value in the array.</p>
      *
-     * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
+     * <p>This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.</p>
      *
-     * @param array  the array to search through for the object, may be <code>null</code>
+     * @param array  the array to search through for the object, may be {@code null}
      * @param valueToFind  the value to find
      * @return the index of the value within the array,
-     *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
+     *  {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input
      */
     public static int indexOf(int[] array, int valueToFind) {
         return indexOf(array, valueToFind, 0);
@@ -1845,16 +1845,16 @@ public class ArrayUtils {
     /**
      * <p>Finds the index of the given value in the array starting at the given index.</p>
      *
-     * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
+     * <p>This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.</p>
      *
      * <p>A negative startIndex is treated as zero. A startIndex larger than the array
-     * length will return {@link #INDEX_NOT_FOUND} (<code>-1</code>).</p>
+     * length will return {@link #INDEX_NOT_FOUND} ({@code -1}).</p>
      *
-     * @param array  the array to search through for the object, may be <code>null</code>
+     * @param array  the array to search through for the object, may be {@code null}
      * @param valueToFind  the value to find
      * @param startIndex  the index to start searching at
      * @return the index of the value within the array,
-     *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
+     *  {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input
      */
     public static int indexOf(int[] array, int valueToFind, int startIndex) {
         if (array == null) {
@@ -1874,12 +1874,12 @@ public class ArrayUtils {
     /**
      * <p>Finds the last index of the given value within the array.</p>
      *
-     * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
+     * <p>This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.</p>
      *
-     * @param array  the array to travers backwords looking for the object, may be <code>null</code>
+     * @param array  the array to travers backwords looking for the object, may be {@code null}
      * @param valueToFind  the object to find
      * @return the last index of the value within the array,
-     *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
+     *  {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input
      */
     public static int lastIndexOf(int[] array, int valueToFind) {
         return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
@@ -1888,16 +1888,16 @@ public class ArrayUtils {
     /**
      * <p>Finds the last index of the given value in the array starting at the given index.</p>
      *
-     * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
+     * <p>This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.</p>
      *
-     * <p>A negative startIndex will return {@link #INDEX_NOT_FOUND} (<code>-1</code>). A startIndex larger than the
+     * <p>A negative startIndex will return {@link #INDEX_NOT_FOUND} ({@code -1}). A startIndex larger than the
      * array length will search from the end of the array.</p>
      *
-     * @param array  the array to traverse for looking for the object, may be <code>null</code>
+     * @param array  the array to traverse for looking for the object, may be {@code null}
      * @param valueToFind  the value to find
      * @param startIndex  the start index to travers backwards from
      * @return the last index of the value within the array,
-     *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
+     *  {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input
      */
     public static int lastIndexOf(int[] array, int valueToFind, int startIndex) {
         if (array == null) {
@@ -1919,11 +1919,11 @@ public class ArrayUtils {
     /**
      * <p>Checks if the value is in the given array.</p>
      *
-     * <p>The method returns <code>false</code> if a <code>null</code> array is passed in.</p>
+     * <p>The method returns {@code false} if a {@code null} array is passed in.</p>
      *
      * @param array  the array to search through
      * @param valueToFind  the value to find
-     * @return <code>true</code> if the array contains the object
+     * @return {@code true} if the array contains the object
      */
     public static boolean contains(int[] array, int valueToFind) {
         return indexOf(array, valueToFind) != INDEX_NOT_FOUND;
@@ -1934,12 +1934,12 @@ public class ArrayUtils {
     /**
      * <p>Finds the index of the given value in the array.</p>
      *
-     * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
+     * <p>This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.</p>
      *
-     * @param array  the array to search through for the object, may be <code>null</code>
+     * @param array  the array to search through for the object, may be {@code null}
      * @param valueToFind  the value to find
      * @return the index of the value within the array,
-     *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
+     *  {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input
      */
     public static int indexOf(short[] array, short valueToFind) {
         return indexOf(array, valueToFind, 0);
@@ -1948,16 +1948,16 @@ public class ArrayUtils {
     /**
      * <p>Finds the index of the given value in the array starting at the given index.</p>
      *
-     * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
+     * <p>This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.</p>
      *
      * <p>A negative startIndex is treated as zero. A startIndex larger than the array
-     * length will return {@link #INDEX_NOT_FOUND} (<code>-1</code>).</p>
+     * length will return {@link #INDEX_NOT_FOUND} ({@code -1}).</p>
      *
-     * @param array  the array to search through for the object, may be <code>null</code>
+     * @param array  the array to search through for the object, may be {@code null}
      * @param valueToFind  the value to find
      * @param startIndex  the index to start searching at
      * @return the index of the value within the array,
-     *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
+     *  {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input
      */
     public static int indexOf(short[] array, short valueToFind, int startIndex) {
         if (array == null) {
@@ -1977,12 +1977,12 @@ public class ArrayUtils {
     /**
      * <p>Finds the last index of the given value within the array.</p>
      *
-     * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
+     * <p>This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.</p>
      *
-     * @param array  the array to travers backwords looking for the object, may be <code>null</code>
+     * @param array  the array to travers backwords looking for the object, may be {@code null}
      * @param valueToFind  the object to find
      * @return the last index of the value within the array,
-     *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
+     *  {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input
      */
     public static int lastIndexOf(short[] array, short valueToFind) {
         return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
@@ -1991,16 +1991,16 @@ public class ArrayUtils {
     /**
      * <p>Finds the last index of the given value in the array starting at the given index.</p>
      *
-     * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
+     * <p>This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.</p>
      *
-     * <p>A negative startIndex will return {@link #INDEX_NOT_FOUND} (<code>-1</code>). A startIndex larger than the
+     * <p>A negative startIndex will return {@link #INDEX_NOT_FOUND} ({@code -1}). A startIndex larger than the
      * array length will search from the end of the array.</p>
      *
-     * @param array  the array to traverse for looking for the object, may be <code>null</code>
+     * @param array  the array to traverse for looking for the object, may be {@code null}
      * @param valueToFind  the value to find
      * @param startIndex  the start index to travers backwards from
      * @return the last index of the value within the array,
-     *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
+     *  {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input
      */
     public static int lastIndexOf(short[] array, short valueToFind, int startIndex) {
         if (array == null) {
@@ -2022,11 +2022,11 @@ public class ArrayUtils {
     /**
      * <p>Checks if the value is in the given array.</p>
      *
-     * <p>The method returns <code>false</code> if a <code>null</code> array is passed in.</p>
+     * <p>The method returns {@code false} if a {@code null} array is passed in.</p>
      *
      * @param array  the array to search through
      * @param valueToFind  the value to find
-     * @return <code>true</code> if the array contains the object
+     * @return {@code true} if the array contains the object
      */
     public static boolean contains(short[] array, short valueToFind) {
         return indexOf(array, valueToFind) != INDEX_NOT_FOUND;
@@ -2037,12 +2037,12 @@ public class ArrayUtils {
     /**
      * <p>Finds the index of the given value in the array.</p>
      *
-     * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
+     * <p>This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.</p>
      *
-     * @param array  the array to search through for the object, may be <code>null</code>
+     * @param array  the array to search through for the object, may be {@code null}
      * @param valueToFind  the value to find
      * @return the index of the value within the array,
-     *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
+     *  {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input
      * @since 2.1
      */
     public static int indexOf(char[] array, char valueToFind) {
@@ -2052,16 +2052,16 @@ public class ArrayUtils {
     /**
      * <p>Finds the index of the given value in the array starting at the given index.</p>
      *
-     * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
+     * <p>This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.</p>
      *
      * <p>A negative startIndex is treated as zero. A startIndex larger than the array
-     * length will return {@link #INDEX_NOT_FOUND} (<code>-1</code>).</p>
+     * length will return {@link #INDEX_NOT_FOUND} ({@code -1}).</p>
      *
-     * @param array  the array to search through for the object, may be <code>null</code>
+     * @param array  the array to search through for the object, may be {@code null}
      * @param valueToFind  the value to find
      * @param startIndex  the index to start searching at
      * @return the index of the value within the array,
-     *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
+     *  {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input
      * @since 2.1
      */
     public static int indexOf(char[] array, char valueToFind, int startIndex) {
@@ -2082,12 +2082,12 @@ public class ArrayUtils {
     /**
      * <p>Finds the last index of the given value within the array.</p>
      *
-     * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
+     * <p>This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.</p>
      *
-     * @param array  the array to travers backwords looking for the object, may be <code>null</code>
+     * @param array  the array to travers backwords looking for the object, may be {@code null}
      * @param valueToFind  the object to find
      * @return the last index of the value within the array,
-     *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
+     *  {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input
      * @since 2.1
      */
     public static int lastIndexOf(char[] array, char valueToFind) {
@@ -2097,16 +2097,16 @@ public class ArrayUtils {
     /**
      * <p>Finds the last index of the given value in the array starting at the given index.</p>
      *
-     * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
+     * <p>This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.</p>
      *
-     * <p>A negative startIndex will return {@link #INDEX_NOT_FOUND} (<code>-1</code>). A startIndex larger than the
+     * <p>A negative startIndex will return {@link #INDEX_NOT_FOUND} ({@code -1}). A startIndex larger than the
      * array length will search from the end of the array.</p>
      *
-     * @param array  the array to traverse for looking for the object, may be <code>null</code>
+     * @param array  the array to traverse for looking for the object, may be {@code null}
      * @param valueToFind  the value to find
      * @param startIndex  the start index to travers backwards from
      * @return the last index of the value within the array,
-     *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
+     *  {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input
      * @since 2.1
      */
     public static int lastIndexOf(char[] array, char valueToFind, int startIndex) {
@@ -2129,11 +2129,11 @@ public class ArrayUtils {
     /**
      * <p>Checks if the value is in the given array.</p>
      *
-     * <p>The method returns <code>false</code> if a <code>null</code> array is passed in.</p>
+     * <p>The method returns {@code false} if a {@code null} array is passed in.</p>
      *
      * @param array  the array to search through
      * @param valueToFind  the value to find
-     * @return <code>true</code> if the array contains the object
+     * @return {@code true} if the array contains the object
      * @since 2.1
      */
     public static boolean contains(char[] array, char valueToFind) {
@@ -2145,12 +2145,12 @@ public class ArrayUtils {
     /**
      * <p>Finds the index of the given value in the array.</p>
      *
-     * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
+     * <p>This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.</p>
      *
-     * @param array  the array to search through for the object, may be <code>null</code>
+     * @param array  the array to search through for the object, may be {@code null}
      * @param valueToFind  the value to find
      * @return the index of the value within the array,
-     *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
+     *  {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input
      */
     public static int indexOf(byte[] array, byte valueToFind) {
         return indexOf(array, valueToFind, 0);
@@ -2159,16 +2159,16 @@ public class ArrayUtils {
     /**
      * <p>Finds the index of the given value in the array starting at the given index.</p>
      *
-     * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
+     * <p>This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.</p>
      *
      * <p>A negative startIndex is treated as zero. A startIndex larger than the array
-     * length will return {@link #INDEX_NOT_FOUND} (<code>-1</code>).</p>
+     * length will return {@link #INDEX_NOT_FOUND} ({@code -1}).</p>
      *
-     * @param array  the array to search through for the object, may be <code>null</code>
+     * @param array  the array to search through for the object, may be {@code null}
      * @param valueToFind  the value to find
      * @param startIndex  the index to start searching at
      * @return the index of the value within the array,
-     *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
+     *  {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input
      */
     public static int indexOf(byte[] array, byte valueToFind, int startIndex) {
         if (array == null) {
@@ -2188,12 +2188,12 @@ public class ArrayUtils {
     /**
      * <p>Finds the last index of the given value within the array.</p>
      *
-     * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
+     * <p>This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.</p>
      *
-     * @param array  the array to travers backwords looking for the object, may be <code>null</code>
+     * @param array  the array to travers backwords looking for the object, may be {@code null}
      * @param valueToFind  the object to find
      * @return the last index of the value within the array,
-     *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
+     *  {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input
      */
     public static int lastIndexOf(byte[] array, byte valueToFind) {
         return lastIndexOf(array, valueToFind, Integer.MAX_VALUE);
@@ -2202,16 +2202,16 @@ public class ArrayUtils {
     /**
      * <p>Finds the last index of the given value in the array starting at the given index.</p>
      *
-     * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
+     * <p>This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.</p>
      *
-     * <p>A negative startIndex will return {@link #INDEX_NOT_FOUND} (<code>-1</code>). A startIndex larger than the
+     * <p>A negative startIndex will return {@link #INDEX_NOT_FOUND} ({@code -1}). A startIndex larger than the
      * array length will search from the end of the array.</p>
      *
-     * @param array  the array to traverse for looking for the object, may be <code>null</code>
+     * @param array  the array to traverse for looking for the object, may be {@code null}
      * @param valueToFind  the value to find
      * @param startIndex  the start index to travers backwards from
      * @return the last index of the value within the array,
-     *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
+     *  {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input
      */
     public static int lastIndexOf(byte[] array, byte valueToFind, int startIndex) {
         if (array == null) {
@@ -2233,11 +2233,11 @@ public class ArrayUtils {
     /**
      * <p>Checks if the value is in the given array.</p>
      *
-     * <p>The method returns <code>false</code> if a <code>null</code> array is passed in.</p>
+     * <p>The method returns {@code false} if a {@code null} array is passed in.</p>
      *
      * @param array  the array to search through
      * @param valueToFind  the value to find
-     * @return <code>true</code> if the array contains the object
+     * @return {@code true} if the array contains the object
      */
     public static boolean contains(byte[] array, byte valueToFind) {
         return indexOf(array, valueToFind) != INDEX_NOT_FOUND;
@@ -2248,12 +2248,12 @@ public class ArrayUtils {
     /**
      * <p>Finds the index of the given value in the array.</p>
      *
-     * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
+     * <p>This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.</p>
      *
-     * @param array  the array to search through for the object, may be <code>null</code>
+     * @param array  the array to search through for the object, may be {@code null}
      * @param valueToFind  the value to find
      * @return the index of the value within the array,
-     *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
+     *  {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input
      */
     public static int indexOf(double[] array, double valueToFind) {
         return indexOf(array, valueToFind, 0);
@@ -2264,13 +2264,13 @@ public class ArrayUtils {
      * This method will return the index of the first value which falls between the region
      * defined by valueToFind - tolerance and valueToFind + tolerance.</p>
      *
-     * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
+     * <p>This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.</p>
      *
-     * @param array  the array to search through for the object, may be <code>null</code>
+     * @param array  the array to search through for the object, may be {@code null}
      * @param valueToFind  the value to find
      * @param tolerance tolerance of the search
      * @return the index of the value within the array,
-     *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
+     *  {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input
      */
     public static int indexOf(double[] array, double valueToFind, double tolerance) {
         return indexOf(array, valueToFind, 0, tolerance);
@@ -2279,16 +2279,16 @@ public class ArrayUtils {
     /**
      * <p>Finds the index of the given value in the array starting at the given index.</p>
      *
-     * <p>This method returns {@link #INDEX_NOT_FOUND} (<code>-1</code>) for a <code>null</code> input array.</p>
+     * <p>This method returns {@link #INDEX_NOT_FOUND} ({@code -1}) for a {@code null} input array.</p>
      *
      * <p>A negative startIndex is treated as zero. A startIndex larger than the array
-     * length will return {@link #INDEX_NOT_FOUND} (<code>-1</code>).</p>
+     * length will return {@link #INDEX_NOT_FOUND} ({@code -1}).</p>
      *
-     * @param array  the array to search through for the object, may be <code>null</code>
+     * @param array  the array to search through for the object, may be {@code null}
      * @param valueToFind  the value to find
      * @param startIndex  the index to start searching at
      * @return the index of the value within the array,
-     *  {@link #INDEX_NOT_FOUND} (<code>-1</code>) if not found or <code>null</code> array input
+     *  {@link #INDEX_NOT_FOUND} ({@code -1}) if not found or {@code null} array input
      */

[... 1702 lines stripped ...]


Mime
View raw message