ArrayUtils (Lang 2.6)
Date: 2019-09-02

org.apache.commons.lang

## Class ArrayUtils

- java.lang.Object
- - org.apache.commons.lang.ArrayUtils

-     public class ArrayUtils
      extends java.lang.Object

  Operations on arrays, primitive arrays (like `int[]`) and primitive wrapper arrays (like `Integer[]`).

  This class tries to handle `null` input gracefully. An exception will not be thrown for a `null` array input. However, an Object array that contains a `null` element may throw an exception. Each method documents its behaviour.

  #ThreadSafe#

  Since:
    2.0
  Version:
    $Id: ArrayUtils.java 1056988 2011-01-09 17:58:53Z niallp $

- - ### Field Summary

    Fields
    Modifier and Type | Field and Description
    --- | ---
    `static boolean[]` | `EMPTY_BOOLEAN_ARRAY` An empty immutable `boolean` array.
    `static java.lang.Boolean[]` | `EMPTY_BOOLEAN_OBJECT_ARRAY` An empty immutable `Boolean` array.
    `static byte[]` | `EMPTY_BYTE_ARRAY` An empty immutable `byte` array.
    `static java.lang.Byte[]` | `EMPTY_BYTE_OBJECT_ARRAY` An empty immutable `Byte` array.
    `static char[]` | `EMPTY_CHAR_ARRAY` An empty immutable `char` array.
    `static java.lang.Character[]` | `EMPTY_CHARACTER_OBJECT_ARRAY` An empty immutable `Character` array.
    `static java.lang.Class[]` | `EMPTY_CLASS_ARRAY` An empty immutable `Class` array.
    `static double[]` | `EMPTY_DOUBLE_ARRAY` An empty immutable `double` array.
    `static java.lang.Double[]` | `EMPTY_DOUBLE_OBJECT_ARRAY` An empty immutable `Double` array.
    `static float[]` | `EMPTY_FLOAT_ARRAY` An empty immutable `float` array.
    `static java.lang.Float[]` | `EMPTY_FLOAT_OBJECT_ARRAY` An empty immutable `Float` array.
    `static int[]` | `EMPTY_INT_ARRAY` An empty immutable `int` array.
    `static java.lang.Integer[]` | `EMPTY_INTEGER_OBJECT_ARRAY` An empty immutable `Integer` array.
    `static long[]` | `EMPTY_LONG_ARRAY` An empty immutable `long` array.
    `static java.lang.Long[]` | `EMPTY_LONG_OBJECT_ARRAY` An empty immutable `Long` array.
    `static java.lang.Object[]` | `EMPTY_OBJECT_ARRAY` An empty immutable `Object` array.
    `static short[]` | `EMPTY_SHORT_ARRAY` An empty immutable `short` array.
    `static java.lang.Short[]` | `EMPTY_SHORT_OBJECT_ARRAY` An empty immutable `Short` array.
    `static java.lang.String[]` | `EMPTY_STRING_ARRAY` An empty immutable `String` array.
    `static int` | `INDEX_NOT_FOUND` The index value when an element is not found in a list or array: `-1`.

  - ### Constructor Summary

    Constructors
    Constructor and Description
    `ArrayUtils()` ArrayUtils instances should NOT be constructed in standard programming.

  - ### Method Summary

    All Methods Static Methods Concrete Methods
    Modifier and Type | Method and Description
    --- | ---
    `static boolean[]` | `add(boolean[] array, boolean element)` Copies the given array and adds the given element at the end of the new array.
    `static boolean[]` | `add(boolean[] array, int index, boolean element)` Inserts the specified element at the specified position in the array.
    `static byte[]` | `add(byte[] array, byte element)` Copies the given array and adds the given element at the end of the new array.
    `static byte[]` | `add(byte[] array, int index, byte element)` Inserts the specified element at the specified position in the array.
    `static char[]` | `add(char[] array, char element)` Copies the given array and adds the given element at the end of the new array.
    `static char[]` | `add(char[] array, int index, char element)` Inserts the specified element at the specified position in the array.
    `static double[]` | `add(double[] array, double element)` Copies the given array and adds the given element at the end of the new array.
    `static double[]` | `add(double[] array, int index, double element)` Inserts the specified element at the specified position in the array.
    `static float[]` | `add(float[] array, float element)` Copies the given array and adds the given element at the end of the new array.
    `static float[]` | `add(float[] array, int index, float element)` Inserts the specified element at the specified position in the array.
    `static int[]` | `add(int[] array, int element)` Copies the given array and adds the given element at the end of the new array.
    `static int[]` | `add(int[] array, int index, int element)` Inserts the specified element at the specified position in the array.
    `static long[]` | `add(long[] array, int index, long element)` Inserts the specified element at the specified position in the array.
    `static long[]` | `add(long[] array, long element)` Copies the given array and adds the given element at the end of the new array.
    `static java.lang.Object[]` | `add(java.lang.Object[] array, int index, java.lang.Object element)` Inserts the specified element at the specified position in the array.
    `static java.lang.Object[]` | `add(java.lang.Object[] array, java.lang.Object element)` Copies the given array and adds the given element at the end of the new array.
    `static short[]` | `add(short[] array, int index, short element)` Inserts the specified element at the specified position in the array.
    `static short[]` | `add(short[] array, short element)` Copies the given array and adds the given element at the end of the new array.
    `static boolean[]` | `addAll(boolean[] array1, boolean[] array2)` Adds all the elements of the given arrays into a new array.
    `static byte[]` | `addAll(byte[] array1, byte[] array2)` Adds all the elements of the given arrays into a new array.
    `static char[]` | `addAll(char[] array1, char[] array2)` Adds all the elements of the given arrays into a new array.
    `static double[]` | `addAll(double[] array1, double[] array2)` Adds all the elements of the given arrays into a new array.
    `static float[]` | `addAll(float[] array1, float[] array2)` Adds all the elements of the given arrays into a new array.
    `static int[]` | `addAll(int[] array1, int[] array2)` Adds all the elements of the given arrays into a new array.
    `static long[]` | `addAll(long[] array1, long[] array2)` Adds all the elements of the given arrays into a new array.
    `static java.lang.Object[]` | `addAll(java.lang.Object[] array1, java.lang.Object[] array2)` Adds all the elements of the given arrays into a new array.
    `static short[]` | `addAll(short[] array1, short[] array2)` Adds all the elements of the given arrays into a new array.
    `static boolean[]` | `clone(boolean[] array)` Clones an array returning a typecast result and handling `null`.
    `static byte[]` | `clone(byte[] array)` Clones an array returning a typecast result and handling `null`.
    `static char[]` | `clone(char[] array)` Clones an array returning a typecast result and handling `null`.
    `static double[]` | `clone(double[] array)` Clones an array returning a typecast result and handling `null`.
    `static float[]` | `clone(float[] array)` Clones an array returning a typecast result and handling `null`.
    `static int[]` | `clone(int[] array)` Clones an array returning a typecast result and handling `null`.
    `static long[]` | `clone(long[] array)` Clones an array returning a typecast result and handling `null`.
    `static java.lang.Object[]` | `clone(java.lang.Object[] array)` Shallow clones an array returning a typecast result and handling `null`.
    `static short[]` | `clone(short[] array)` Clones an array returning a typecast result and handling `null`.
    `static boolean` | `contains(boolean[] array, boolean valueToFind)` Checks if the value is in the given array.
    `static boolean` | `contains(byte[] array, byte valueToFind)` Checks if the value is in the given array.
    `static boolean` | `contains(char[] array, char valueToFind)` Checks if the value is in the given array.
    `static boolean` | `contains(double[] array, double valueToFind)` Checks if the value is in the given array.
    `static boolean` | `contains(double[] array, double valueToFind, double tolerance)` Checks if a value falling within the given tolerance is in the given array.
    `static boolean` | `contains(float[] array, float valueToFind)` Checks if the value is in the given array.
    `static boolean` | `contains(int[] array, int valueToFind)` Checks if the value is in the given array.
    `static boolean` | `contains(long[] array, long valueToFind)` Checks if the value is in the given array.
    `static boolean` | `contains(java.lang.Object[] array, java.lang.Object objectToFind)` Checks if the object is in the given array.
    `static boolean` | `contains(short[] array, short valueToFind)` Checks if the value is in the given array.
    `static int` | `getLength(java.lang.Object array)` Returns the length of the specified array.
    `static int` | `hashCode(java.lang.Object array)` Get a hashCode for an array handling multi-dimensional arrays correctly.
    `static int` | `indexOf(boolean[] array, boolean valueToFind)` Finds the index of the given value in the array.
    `static int` | `indexOf(boolean[] array, boolean valueToFind, int startIndex)` Finds the index of the given value in the array starting at the given index.
    `static int` | `indexOf(byte[] array, byte valueToFind)` Finds the index of the given value in the array.
    `static int` | `indexOf(byte[] array, byte valueToFind, int startIndex)` Finds the index of the given value in the array starting at the given index.
    `static int` | `indexOf(char[] array, char valueToFind)` Finds the index of the given value in the array.
    `static int` | `indexOf(char[] array, char valueToFind, int startIndex)` Finds the index of the given value in the array starting at the given index.
    `static int` | `indexOf(double[] array, double valueToFind)` Finds the index of the given value in the array.
    `static int` | `indexOf(double[] array, double valueToFind, double tolerance)` Finds the index of the given value within a given tolerance in the array.
    `static int` | `indexOf(double[] array, double valueToFind, int startIndex)` Finds the index of the given value in the array starting at the given index.
    `static int` | `indexOf(double[] array, double valueToFind, int startIndex, double tolerance)` Finds the index of the given value in the array starting at the given index.
    `static int` | `indexOf(float[] array, float valueToFind)` Finds the index of the given value in the array.
    `static int` | `indexOf(float[] array, float valueToFind, int startIndex)` Finds the index of the given value in the array starting at the given index.
    `static int` | `indexOf(int[] array, int valueToFind)` Finds the index of the given value in the array.
    `static int` | `indexOf(int[] array, int valueToFind, int startIndex)` Finds the index of the given value in the array starting at the given index.
    `static int` | `indexOf(long[] array, long valueToFind)` Finds the index of the given value in the array.
    `static int` | `indexOf(long[] array, long valueToFind, int startIndex)` Finds the index of the given value in the array starting at the given index.
    `static int` | `indexOf(java.lang.Object[] array, java.lang.Object objectToFind)` Finds the index of the given object in the array.
    `static int` | `indexOf(java.lang.Object[] array, java.lang.Object objectToFind, int startIndex)` Finds the index of the given object in the array starting at the given index.
    `static int` | `indexOf(short[] array, short valueToFind)` Finds the index of the given value in the array.
    `static int` | `indexOf(short[] array, short valueToFind, int startIndex)` Finds the index of the given value in the array starting at the given index.
    `static boolean` | `isEmpty(boolean[] array)` Checks if an array of primitive booleans is empty or `null`.
    `static boolean` | `isEmpty(byte[] array)` Checks if an array of primitive bytes is empty or `null`.
    `static boolean` | `isEmpty(char[] array)` Checks if an array of primitive chars is empty or `null`.
    `static boolean` | `isEmpty(double[] array)` Checks if an array of primitive doubles is empty or `null`.
    `static boolean` | `isEmpty(float[] array)` Checks if an array of primitive floats is empty or `null`.
    `static boolean` | `isEmpty(int[] array)` Checks if an array of primitive ints is empty or `null`.
    `static boolean` | `isEmpty(long[] array)` Checks if an array of primitive longs is empty or `null`.
    `static boolean` | `isEmpty(java.lang.Object[] array)` Checks if an array of Objects is empty or `null`.
    `static boolean` | `isEmpty(short[] array)` Checks if an array of primitive shorts is empty or `null`.
    `static boolean` | `isEquals(java.lang.Object array1, java.lang.Object array2)` Compares two arrays, using equals(), handling multi-dimensional arrays correctly.
    `static boolean` | `isNotEmpty(boolean[] array)` Checks if an array of primitive booleans is not empty or not `null`.
    `static boolean` | `isNotEmpty(byte[] array)` Checks if an array of primitive bytes is not empty or not `null`.
    `static boolean` | `isNotEmpty(char[] array)` Checks if an array of primitive chars is not empty or not `null`.
    `static boolean` | `isNotEmpty(double[] array)` Checks if an array of primitive doubles is not empty or not `null`.
    `static boolean` | `isNotEmpty(float[] array)` Checks if an array of primitive floats is not empty or not `null`.
    `static boolean` | `isNotEmpty(int[] array)` Checks if an array of primitive ints is not empty or not `null`.
    `static boolean` | `isNotEmpty(long[] array)` Checks if an array of primitive longs is not empty or not `null`.
    `static boolean` | `isNotEmpty(java.lang.Object[] array)` Checks if an array of Objects is not empty or not `null`.
    `static boolean` | `isNotEmpty(short[] array)` Checks if an array of primitive shorts is not empty or not `null`.
    `static boolean` | `isSameLength(boolean[] array1, boolean[] array2)` Checks whether two arrays are the same length, treating `null` arrays as length `0`.
    `static boolean` | `isSameLength(byte[] array1, byte[] array2)` Checks whether two arrays are the same length, treating `null` arrays as length `0`.
    `static boolean` | `isSameLength(char[] array1, char[] array2)` Checks whether two arrays are the same length, treating `null` arrays as length `0`.
    `static boolean` | `isSameLength(double[] array1, double[] array2)` Checks whether two arrays are the same length, treating `null` arrays as length `0`.
    `static boolean` | `isSameLength(float[] array1, float[] array2)` Checks whether two arrays are the same length, treating `null` arrays as length `0`.
    `static boolean` | `isSameLength(int[] array1, int[] array2)` Checks whether two arrays are the same length, treating `null` arrays as length `0`.
    `static boolean` | `isSameLength(long[] array1, long[] array2)` Checks whether two arrays are the same length, treating `null` arrays as length `0`.
    `static boolean` | `isSameLength(java.lang.Object[] array1, java.lang.Object[] array2)` Checks whether two arrays are the same length, treating `null` arrays as length `0`.
    `static boolean` | `isSameLength(short[] array1, short[] array2)` Checks whether two arrays are the same length, treating `null` arrays as length `0`.
    `static boolean` | `isSameType(java.lang.Object array1, java.lang.Object array2)` Checks whether two arrays are the same type taking into account multi-dimensional arrays.
    `static int` | `lastIndexOf(boolean[] array, boolean valueToFind)` Finds the last index of the given value within the array.
    `static int` | `lastIndexOf(boolean[] array, boolean valueToFind, int startIndex)` Finds the last index of the given value in the array starting at the given index.
    `static int` | `lastIndexOf(byte[] array, byte valueToFind)` Finds the last index of the given value within the array.
    `static int` | `lastIndexOf(byte[] array, byte valueToFind, int startIndex)` Finds the last index of the given value in the array starting at the given index.
    `static int` | `lastIndexOf(char[] array, char valueToFind)` Finds the last index of the given value within the array.
    `static int` | `lastIndexOf(char[] array, char valueToFind, int startIndex)` Finds the last index of the given value in the array starting at the given index.
    `static int` | `lastIndexOf(double[] array, double valueToFind)` Finds the last index of the given value within the array.
    `static int` | `lastIndexOf(double[] array, double valueToFind, double tolerance)` Finds the last index of the given value within a given tolerance in the array.
    `static int` | `lastIndexOf(double[] array, double valueToFind, int startIndex)` Finds the last index of the given value in the array starting at the given index.
    `static int` | `lastIndexOf(double[] array, double valueToFind, int startIndex, double tolerance)` Finds the last index of the given value in the array starting at the given index.
    `static int` | `lastIndexOf(float[] array, float valueToFind)` Finds the last index of the given value within the array.
    `static int` | `lastIndexOf(float[] array, float valueToFind, int startIndex)` Finds the last index of the given value in the array starting at the given index.
    `static int` | `lastIndexOf(int[] array, int valueToFind)` Finds the last index of the given value within the array.
    `static int` | `lastIndexOf(int[] array, int valueToFind, int startIndex)` Finds the last index of the given value in the array starting at the given index.
    `static int` | `lastIndexOf(long[] array, long valueToFind)` Finds the last index of the given value within the array.
    `static int` | `lastIndexOf(long[] array, long valueToFind, int startIndex)` Finds the last index of the given value in the array starting at the given index.
    `static int` | `lastIndexOf(java.lang.Object[] array, java.lang.Object objectToFind)` Finds the last index of the given object within the array.
    `static int` | `lastIndexOf(java.lang.Object[] array, java.lang.Object objectToFind, int startIndex)` Finds the last index of the given object in the array starting at the given index.
    `static int` | `lastIndexOf(short[] array, short valueToFind)` Finds the last index of the given value within the array.
    `static int` | `lastIndexOf(short[] array, short valueToFind, int startIndex)` Finds the last index of the given value in the array starting at the given index.
    `static boolean[]` | `nullToEmpty(boolean[] array)` Defensive programming technique to change a `null` reference to an empty one.
    `static java.lang.Boolean[]` | `nullToEmpty(java.lang.Boolean[] array)` Defensive programming technique to change a `null` reference to an empty one.
    `static byte[]` | `nullToEmpty(byte[] array)` Defensive programming technique to change a `null` reference to an empty one.
    `static java.lang.Byte[]` | `nullToEmpty(java.lang.Byte[] array)` Defensive programming technique to change a `null` reference to an empty one.
    `static char[]` | `nullToEmpty(char[] array)` Defensive programming technique to change a `null` reference to an empty one.
    `static java.lang.Character[]` | `nullToEmpty(java.lang.Character[] array)` Defensive programming technique to change a `null` reference to an empty one.
    `static double[]` | `nullToEmpty(double[] array)` Defensive programming technique to change a `null` reference to an empty one.
    `static java.lang.Double[]` | `nullToEmpty(java.lang.Double[] array)` Defensive programming technique to change a `null` reference to an empty one.
    `static float[]` | `nullToEmpty(float[] array)` Defensive programming technique to change a `null` reference to an empty one.
    `static java.lang.Float[]` | `nullToEmpty(java.lang.Float[] array)` Defensive programming technique to change a `null` reference to an empty one.
    `static int[]` | `nullToEmpty(int[] array)` Defensive programming technique to change a `null` reference to an empty one.
    `static java.lang.Integer[]` | `nullToEmpty(java.lang.Integer[] array)` Defensive programming technique to change a `null` reference to an empty one.
    `static long[]` | `nullToEmpty(long[] array)` Defensive programming technique to change a `null` reference to an empty one.
    `static java.lang.Long[]` | `nullToEmpty(java.lang.Long[] array)` Defensive programming technique to change a `null` reference to an empty one.
    `static java.lang.Object[]` | `nullToEmpty(java.lang.Object[] array)` Defensive programming technique to change a `null` reference to an empty one.
    `static short[]` | `nullToEmpty(short[] array)` Defensive programming technique to change a `null` reference to an empty one.
    `static java.lang.Short[]` | `nullToEmpty(java.lang.Short[] array)` Defensive programming technique to change a `null` reference to an empty one.
    `static java.lang.String[]` | `nullToEmpty(java.lang.String[] array)` Defensive programming technique to change a `null` reference to an empty one.
    `static boolean[]` | `remove(boolean[] array, int index)` Removes the element at the specified position from the specified array.
    `static byte[]` | `remove(byte[] array, int index)` Removes the element at the specified position from the specified array.
    `static char[]` | `remove(char[] array, int index)` Removes the element at the specified position from the specified array.
    `static double[]` | `remove(double[] array, int index)` Removes the element at the specified position from the specified array.
    `static float[]` | `remove(float[] array, int index)` Removes the element at the specified position from the specified array.
    `static int[]` | `remove(int[] array, int index)` Removes the element at the specified position from the specified array.
    `static long[]` | `remove(long[] array, int index)` Removes the element at the specified position from the specified array.
    `static java.lang.Object[]` | `remove(java.lang.Object[] array, int index)` Removes the element at the specified position from the specified array.
    `static short[]` | `remove(short[] array, int index)` Removes the element at the specified position from the specified array.
    `static boolean[]` | `removeElement(boolean[] array, boolean element)` Removes the first occurrence of the specified element from the specified array.
    `static byte[]` | `removeElement(byte[] array, byte element)` Removes the first occurrence of the specified element from the specified array.
    `static char[]` | `removeElement(char[] array, char element)` Removes the first occurrence of the specified element from the specified array.
    `static double[]` | `removeElement(double[] array, double element)` Removes the first occurrence of the specified element from the specified array.
    `static float[]` | `removeElement(float[] array, float element)` Removes the first occurrence of the specified element from the specified array.
    `static int[]` | `removeElement(int[] array, int element)` Removes the first occurrence of the specified element from the specified array.
    `static long[]` | `removeElement(long[] array, long element)` Removes the first occurrence of the specified element from the specified array.
    `static java.lang.Object[]` | `removeElement(java.lang.Object[] array, java.lang.Object element)` Removes the first occurrence of the specified element from the specified array.
    `static short[]` | `removeElement(short[] array, short element)` Removes the first occurrence of the specified element from the specified array.
    `static void` | `reverse(boolean[] array)` Reverses the order of the given array.
    `static void` | `reverse(byte[] array)` Reverses the order of the given array.
    `static void` | `reverse(char[] array)` Reverses the order of the given array.
    `static void` | `reverse(double[] array)` Reverses the order of the given array.
    `static void` | `reverse(float[] array)` Reverses the order of the given array.
    `static void` | `reverse(int[] array)` Reverses the order of the given array.
    `static void` | `reverse(long[] array)` Reverses the order of the given array.
    `static void` | `reverse(java.lang.Object[] array)` Reverses the order of the given array.
    `static void` | `reverse(short[] array)` Reverses the order of the given array.
    `static boolean[]` | `subarray(boolean[] array, int startIndexInclusive, int endIndexExclusive)` Produces a new `boolean` array containing the elements between the start and end indices.
    `static byte[]` | `subarray(byte[] array, int startIndexInclusive, int endIndexExclusive)` Produces a new `byte` array containing the elements between the start and end indices.
    `static char[]` | `subarray(char[] array, int startIndexInclusive, int endIndexExclusive)` Produces a new `char` array containing the elements between the start and end indices.
    `static double[]` | `subarray(double[] array, int startIndexInclusive, int endIndexExclusive)` Produces a new `double` array containing the elements between the start and end indices.
    `static float[]` | `subarray(float[] array, int startIndexInclusive, int endIndexExclusive)` Produces a new `float` array containing the elements between the start and end indices.
    `static int[]` | `subarray(int[] array, int startIndexInclusive, int endIndexExclusive)` Produces a new `int` array containing the elements between the start and end indices.
    `static long[]` | `subarray(long[] array, int startIndexInclusive, int endIndexExclusive)` Produces a new `long` array containing the elements between the start and end indices.
    `static java.lang.Object[]` | `subarray(java.lang.Object[] array, int startIndexInclusive, int endIndexExclusive)` Produces a new array containing the elements between the start and end indices.
    `static short[]` | `subarray(short[] array, int startIndexInclusive, int endIndexExclusive)` Produces a new `short` array containing the elements between the start and end indices.
    `static java.util.Map` | `toMap(java.lang.Object[] array)` Converts the given array into a `Map`.
    `static java.lang.Boolean[]` | `toObject(boolean[] array)` Converts an array of primitive booleans to objects.
    `static java.lang.Byte[]` | `toObject(byte[] array)` Converts an array of primitive bytes to objects.
    `static java.lang.Character[]` | `toObject(char[] array)` Converts an array of primitive chars to objects.
    `static java.lang.Double[]` | `toObject(double[] array)` Converts an array of primitive doubles to objects.
    `static java.lang.Float[]` | `toObject(float[] array)` Converts an array of primitive floats to objects.
    `static java.lang.Integer[]` | `toObject(int[] array)` Converts an array of primitive ints to objects.
    `static java.lang.Long[]` | `toObject(long[] array)` Converts an array of primitive longs to objects.
    `static java.lang.Short[]` | `toObject(short[] array)` Converts an array of primitive shorts to objects.
    `static boolean[]` | `toPrimitive(java.lang.Boolean[] array)` Converts an array of object Booleans to primitives.
    `static boolean[]` | `toPrimitive(java.lang.Boolean[] array, boolean valueForNull)` Converts an array of object Booleans to primitives handling `null`.
    `static byte[]` | `toPrimitive(java.lang.Byte[] array)` Converts an array of object Bytes to primitives.
    `static byte[]` | `toPrimitive(java.lang.Byte[] array, byte valueForNull)` Converts an array of object Bytes to primitives handling `null`.
    `static char[]` | `toPrimitive(java.lang.Character[] array)` Converts an array of object Characters to primitives.
    `static char[]` | `toPrimitive(java.lang.Character[] array, char valueForNull)` Converts an array of object Character to primitives handling `null`.
    `static double[]` | `toPrimitive(java.lang.Double[] array)` Converts an array of object Doubles to primitives.
    `static double[]` | `toPrimitive(java.lang.Double[] array, double valueForNull)` Converts an array of object Doubles to primitives handling `null`.
    `static float[]` | `toPrimitive(java.lang.Float[] array)` Converts an array of object Floats to primitives.
    `static float[]` | `toPrimitive(java.lang.Float[] array, float valueForNull)` Converts an array of object Floats to primitives handling `null`.
    `static int[]` | `toPrimitive(java.lang.Integer[] array)` Converts an array of object Integers to primitives.
    `static int[]` | `toPrimitive(java.lang.Integer[] array, int valueForNull)` Converts an array of object Integer to primitives handling `null`.
    `static long[]` | `toPrimitive(java.lang.Long[] array)` Converts an array of object Longs to primitives.
    `static long[]` | `toPrimitive(java.lang.Long[] array, long valueForNull)` Converts an array of object Long to primitives handling `null`.
    `static short[]` | `toPrimitive(java.lang.Short[] array)` Converts an array of object Shorts to primitives.
    `static short[]` | `toPrimitive(java.lang.Short[] array, short valueForNull)` Converts an array of object Short to primitives handling `null`.
    `static java.lang.String` | `toString(java.lang.Object array)` Outputs an array as a String, treating `null` as an empty array.
    `static java.lang.String` | `toString(java.lang.Object array, java.lang.String stringIfNull)` Outputs an array as a String handling `null`s.

    - ### Methods inherited from class java.lang.Object

      `clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait`

- - ### Field Detail

    - #### EMPTY_OBJECT_ARRAY

          public static final java.lang.Object[] EMPTY_OBJECT_ARRAY

      An empty immutable `Object` array.

    - #### EMPTY_CLASS_ARRAY

          public static final java.lang.Class[] EMPTY_CLASS_ARRAY

      An empty immutable `Class` array.

    - #### EMPTY_STRING_ARRAY

          public static final java.lang.String[] EMPTY_STRING_ARRAY

      An empty immutable `String` array.

    - #### EMPTY_LONG_ARRAY

          public static final long[] EMPTY_LONG_ARRAY

      An empty immutable `long` array.

    - #### EMPTY_LONG_OBJECT_ARRAY

          public static final java.lang.Long[] EMPTY_LONG_OBJECT_ARRAY

      An empty immutable `Long` array.

    - #### EMPTY_INT_ARRAY

          public static final int[] EMPTY_INT_ARRAY

      An empty immutable `int` array.

    - #### EMPTY_INTEGER_OBJECT_ARRAY

          public static final java.lang.Integer[] EMPTY_INTEGER_OBJECT_ARRAY

      An empty immutable `Integer` array.

    - #### EMPTY_SHORT_ARRAY

          public static final short[] EMPTY_SHORT_ARRAY

      An empty immutable `short` array.

    - #### EMPTY_SHORT_OBJECT_ARRAY

          public static final java.lang.Short[] EMPTY_SHORT_OBJECT_ARRAY

      An empty immutable `Short` array.

    - #### EMPTY_BYTE_ARRAY

          public static final byte[] EMPTY_BYTE_ARRAY

      An empty immutable `byte` array.

    - #### EMPTY_BYTE_OBJECT_ARRAY

          public static final java.lang.Byte[] EMPTY_BYTE_OBJECT_ARRAY

      An empty immutable `Byte` array.

    - #### EMPTY_DOUBLE_ARRAY

          public static final double[] EMPTY_DOUBLE_ARRAY

      An empty immutable `double` array.

    - #### EMPTY_DOUBLE_OBJECT_ARRAY

          public static final java.lang.Double[] EMPTY_DOUBLE_OBJECT_ARRAY

      An empty immutable `Double` array.

    - #### EMPTY_FLOAT_ARRAY

          public static final float[] EMPTY_FLOAT_ARRAY

      An empty immutable `float` array.

    - #### EMPTY_FLOAT_OBJECT_ARRAY

          public static final java.lang.Float[] EMPTY_FLOAT_OBJECT_ARRAY

      An empty immutable `Float` array.

    - #### EMPTY_BOOLEAN_ARRAY

          public static final boolean[] EMPTY_BOOLEAN_ARRAY

      An empty immutable `boolean` array.

    - #### EMPTY_BOOLEAN_OBJECT_ARRAY

          public static final java.lang.Boolean[] EMPTY_BOOLEAN_OBJECT_ARRAY

      An empty immutable `Boolean` array.

    - #### EMPTY_CHAR_ARRAY

          public static final char[] EMPTY_CHAR_ARRAY

      An empty immutable `char` array.

    - #### EMPTY_CHARACTER_OBJECT_ARRAY

          public static final java.lang.Character[] EMPTY_CHARACTER_OBJECT_ARRAY

      An empty immutable `Character` array.

    - #### INDEX_NOT_FOUND

          public static final int INDEX_NOT_FOUND

      The index value when an element is not found in a list or array: `-1`. This value is returned by methods in this class and can also be used in comparisons with values returned by various method from `List`.
      See Also:
        Constant Field Values

  - ### Constructor Detail

    - #### ArrayUtils

          public ArrayUtils()

      ArrayUtils instances should NOT be constructed in standard programming. Instead, the class should be used as `ArrayUtils.clone(new int[] {2})`.

      This constructor is public to permit tools that require a JavaBean instance to operate.

  - ### Method Detail

    - #### toString

          public static java.lang.String toString(java.lang.Object array)

      Outputs an array as a String, treating `null` as an empty array.

      Multi-dimensional arrays are handled correctly, including multi-dimensional primitive arrays.

      The format is that of Java source code, for example `{a,b}`.

      Parameters:
        `array` - the array to get a toString for, may be `null`
      Returns:
        a String representation of the array, '{}' if null array input

    - #### toString

          public static java.lang.String toString(java.lang.Object array,
                                                  java.lang.String stringIfNull)

      Outputs an array as a String handling `null`s.

      Multi-dimensional arrays are handled correctly, including multi-dimensional primitive arrays.

      The format is that of Java source code, for example `{a,b}`.

      Parameters:
        `array` - the array to get a toString for, may be `null`
        `stringIfNull` - the String to return if the array is `null`
      Returns:
        a String representation of the array

    - #### hashCode

          public static int hashCode(java.lang.Object array)

      Get a hashCode for an array handling multi-dimensional arrays correctly.

      Multi-dimensional primitive arrays are also handled correctly by this method.

      Parameters:
        `array` - the array to get a hashCode for, may be `null`
      Returns:
        a hashCode for the array, zero if null array input

    - #### isEquals

          public static boolean isEquals(java.lang.Object array1,
                                         java.lang.Object array2)

      Compares two arrays, using equals(), handling multi-dimensional arrays correctly.

      Multi-dimensional primitive arrays are also handled correctly by this method.

      Parameters:
        `array1` - the left hand array to compare, may be `null`
        `array2` - the right hand array to compare, may be `null`
      Returns:
        `true` if the arrays are equal

    - #### toMap

          public static java.util.Map toMap(java.lang.Object[] array)

      Converts the given array into a `Map`. Each element of the array must be either a `Map.Entry` or an Array, containing at least two elements, where the first element is used as key and the second as value.

      This method can be used to initialize:

           // Create a Map mapping colors.
           Map colorMap = MapUtils.toMap(new String[][] {{
               {"RED", "#FF0000"},
               {"GREEN", "#00FF00"},
               {"BLUE", "#0000FF"}});

      This method returns `null` for a `null` input array.

      Parameters:
        `array` - an array whose elements are either a `Map.Entry` or an Array containing at least two elements, may be `null`
      Returns:
        a `Map` that was created from the array
      Throws:
        `java.lang.IllegalArgumentException` - if one element of this Array is itself an Array containing less then two elements
        `java.lang.IllegalArgumentException` - if the array contains elements other than `Map.Entry` and an Array

    - #### clone

          public static java.lang.Object[] clone(java.lang.Object[] array)

      Shallow clones an array returning a typecast result and handling `null`.

      The objects in the array are not cloned, thus there is no special handling for multi-dimensional arrays.

      This method returns `null` for a `null` input array.

      Parameters:
        `array` - the array to shallow clone, may be `null`
      Returns:
        the cloned array, `null` if `null` input

    - #### clone

          public static long[] clone(long[] array)

      Clones an array returning a typecast result and handling `null`.

      This method returns `null` for a `null` input array.

      Parameters:
        `array` - the array to clone, may be `null`
      Returns:
        the cloned array, `null` if `null` input

    - #### clone

          public static int[] clone(int[] array)

      Clones an array returning a typecast result and handling `null`.

      This method returns `null` for a `null` input array.

      Parameters:
        `array` - the array to clone, may be `null`
      Returns:
        the cloned array, `null` if `null` input

    - #### clone

          public static short[] clone(short[] array)

      Clones an array returning a typecast result and handling `null`.

      This method returns `null` for a `null` input array.

      Parameters:
        `array` - the array to clone, may be `null`
      Returns:
        the cloned array, `null` if `null` input

    - #### clone

          public static char[] clone(char[] array)

      Clones an array returning a typecast result and handling `null`.

      This method returns `null` for a `null` input array.

      Parameters:
        `array` - the array to clone, may be `null`
      Returns:
        the cloned array, `null` if `null` input

    - #### clone

          public static byte[] clone(byte[] array)

      Clones an array returning a typecast result and handling `null`.

      This method returns `null` for a `null` input array.

      Parameters:
        `array` - the array to clone, may be `null`
      Returns:
        the cloned array, `null` if `null` input

    - #### clone

          public static double[] clone(double[] array)

      Clones an array returning a typecast result and handling `null`.

      This method returns `null` for a `null` input array.

      Parameters:
        `array` - the array to clone, may be `null`
      Returns:
        the cloned array, `null` if `null` input

    - #### clone

          public static float[] clone(float[] array)

      Clones an array returning a typecast result and handling `null`.

      This method returns `null` for a `null` input array.

      Parameters:
        `array` - the array to clone, may be `null`
      Returns:
        the cloned array, `null` if `null` input

    - #### clone

          public static boolean[] clone(boolean[] array)

      Clones an array returning a typecast result and handling `null`.

      This method returns `null` for a `null` input array.

      Parameters:
        `array` - the array to clone, may be `null`
      Returns:
        the cloned array, `null` if `null` input

    - #### nullToEmpty

          public static java.lang.Object[] nullToEmpty(java.lang.Object[] array)

      Defensive programming technique to change a `null` reference to an empty one.

      This method returns an empty array for a `null` input array.

      As a memory optimizing technique an empty array passed in will be overridden with the empty `public static` references in this class.

      Parameters:
        `array` - the array to check for `null` or empty
      Returns:
        the same array, `public static` empty array if `null` or empty input
      Since:
        2.5

    - #### nullToEmpty

          public static java.lang.String[] nullToEmpty(java.lang.String[] array)

      Defensive programming technique to change a `null` reference to an empty one.

      This method returns an empty array for a `null` input array.

      As a memory optimizing technique an empty array passed in will be overridden with the empty `public static` references in this class.

      Parameters:
        `array` - the array to check for `null` or empty
      Returns:
        the same array, `public static` empty array if `null` or empty input
      Since:
        2.5

    - #### nullToEmpty

          public static long[] nullToEmpty(long[] array)

      Defensive programming technique to change a `null` reference to an empty one.

      This method returns an empty array for a `null` input array.

      As a memory optimizing technique an empty array passed in will be overridden with the empty `public static` references in this class.

      Parameters:
        `array` - the array to check for `null` or empty
      Returns:
        the same array, `public static` empty array if `null` or empty input
      Since:
        2.5

    - #### nullToEmpty

          public static int[] nullToEmpty(int[] array)

      Defensive programming technique to change a `null` reference to an empty one.

      This method returns an empty array for a `null` input array.

      As a memory optimizing technique an empty array passed in will be overridden with the empty `public static` references in this class.

      Parameters:
        `array` - the array to check for `null` or empty
      Returns:
        the same array, `public static` empty array if `null` or empty input
      Since:
        2.5

    - #### nullToEmpty

          public static short[] nullToEmpty(short[] array)

      Defensive programming technique to change a `null` reference to an empty one.

      This method returns an empty array for a `null` input array.

      As a memory optimizing technique an empty array passed in will be overridden with the empty `public static` references in this class.

      Parameters:
        `array` - the array to check for `null` or empty
      Returns:
        the same array, `public static` empty array if `null` or empty input
      Since:
        2.5

    - #### nullToEmpty

          public static char[] nullToEmpty(char[] array)

      Defensive programming technique to change a `null` reference to an empty one.

      This method returns an empty array for a `null` input array.

      As a memory optimizing technique an empty array passed in will be overridden with the empty `public static` references in this class.

      Parameters:
        `array` - the array to check for `null` or empty
      Returns:
        the same array, `public static` empty array if `null` or empty input
      Since:
        2.5

    - #### nullToEmpty

          public static byte[] nullToEmpty(byte[] array)

      Defensive programming technique to change a `null` reference to an empty one.

      This method returns an empty array for a `null` input array.

      As a memory optimizing technique an empty array passed in will be overridden with the empty `public static` references in this class.

      Parameters:
        `array` - the array to check for `null` or empty
      Returns:
        the same array, `public static` empty array if `null` or empty input
      Since:
        2.5

    - #### nullToEmpty

          public static double[] nullToEmpty(double[] array)

      Defensive programming technique to change a `null` reference to an empty one.

      This method returns an empty array for a `null` input array.

      As a memory optimizing technique an empty array passed in will be overridden with the empty `public static` references in this class.

      Parameters:
        `array` - the array to check for `null` or empty
      Returns:
        the same array, `public static` empty array if `null` or empty input
      Since:
        2.5

    - #### nullToEmpty

          public static float[] nullToEmpty(float[] array)

      Defensive programming technique to change a `null` reference to an empty one.

      This method returns an empty array for a `null` input array.

      As a memory optimizing technique an empty array passed in will be overridden with the empty `public static` references in this class.

      Parameters:
        `array` - the array to check for `null` or empty
      Returns:
        the same array, `public static` empty array if `null` or empty input
      Since:
        2.5

    - #### nullToEmpty

          public static boolean[] nullToEmpty(boolean[] array)

      Defensive programming technique to change a `null` reference to an empty one.

      This method returns an empty array for a `null` input array.

      As a memory optimizing technique an empty array passed in will be overridden with the empty `public static` references in this class.

      Parameters:
        `array` - the array to check for `null` or empty
      Returns:
        the same array, `public static` empty array if `null` or empty input
      Since:
        2.5

    - #### nullToEmpty

          public static java.lang.Long[] nullToEmpty(java.lang.Long[] array)

      Defensive programming technique to change a `null` reference to an empty one.

      This method returns an empty array for a `null` input array.

      As a memory optimizing technique an empty array passed in will be overridden with the empty `public static` references in this class.

      Parameters:
        `array` - the array to check for `null` or empty
      Returns:
        the same array, `public static` empty array if `null` or empty input
      Since:
        2.5

    - #### nullToEmpty

          public static java.lang.Integer[] nullToEmpty(java.lang.Integer[] array)

      Defensive programming technique to change a `null` reference to an empty one.

      This method returns an empty array for a `null` input array.

      As a memory optimizing technique an empty array passed in will be overridden with the empty `public static` references in this class.

      Parameters:
        `array` - the array to check for `null` or empty
      Returns:
        the same array, `public static` empty array if `null` or empty input
      Since:
        2.5

    - #### nullToEmpty

          public static java.lang.Short[] nullToEmpty(java.lang.Short[] array)

      Defensive programming technique to change a `null` reference to an empty one.

      This method returns an empty array for a `null` input array.

      As a memory optimizing technique an empty array passed in will be overridden with the empty `public static` references in this class.

      Parameters:
        `array` - the array to check for `null` or empty
      Returns:
        the same array, `public static` empty array if `null` or empty input
      Since:
        2.5

    - #### nullToEmpty

          public static java.lang.Character[] nullToEmpty(java.lang.Character[] array)

      Defensive programming technique to change a `null` reference to an empty one.

      This method returns an empty array for a `null` input array.

      As a memory optimizing technique an empty array passed in will be overridden with the empty `public static` references in this class.

      Parameters:
        `array` - the array to check for `null` or empty
      Returns:
        the same array, `public static` empty array if `null` or empty input
      Since:
        2.5

    - #### nullToEmpty

          public static java.lang.Byte[] nullToEmpty(java.lang.Byte[] array)

      Defensive programming technique to change a `null` reference to an empty one.

      This method returns an empty array for a `null` input array.

      As a memory optimizing technique an empty array passed in will be overridden with the empty `public static` references in this class.

      Parameters:
        `array` - the array to check for `null` or empty
      Returns:
        the same array, `public static` empty array if `null` or empty input
      Since:
        2.5

    - #### nullToEmpty

          public static java.lang.Double[] nullToEmpty(java.lang.Double[] array)

      Defensive programming technique to change a `null` reference to an empty one.

      This method returns an empty array for a `null` input array.

      As a memory optimizing technique an empty array passed in will be overridden with the empty `public static` references in this class.

      Parameters:
        `array` - the array to check for `null` or empty
      Returns:
        the same array, `public static` empty array if `null` or empty input
      Since:
        2.5

    - #### nullToEmpty

          public static java.lang.Float[] nullToEmpty(java.lang.Float[] array)

      Defensive programming technique to change a `null` reference to an empty one.

      This method returns an empty array for a `null` input array.

      As a memory optimizing technique an empty array passed in will be overridden with the empty `public static` references in this class.

      Parameters:
        `array` - the array to check for `null` or empty
      Returns:
        the same array, `public static` empty array if `null` or empty input
      Since:
        2.5

    - #### nullToEmpty

          public static java.lang.Boolean[] nullToEmpty(java.lang.Boolean[] array)

      Defensive programming technique to change a `null` reference to an empty one.

      This method returns an empty array for a `null` input array.

      As a memory optimizing technique an empty array passed in will be overridden with the empty `public static` references in this class.

      Parameters:
        `array` - the array to check for `null` or empty
      Returns:
        the same array, `public static` empty array if `null` or empty input
      Since:
        2.5

    - #### subarray

          public static java.lang.Object[] subarray(java.lang.Object[] array,
                                                    int startIndexInclusive,
                                                    int endIndexExclusive)

      Produces a new array containing the elements between the start and end indices.

      The start index is inclusive, the end index exclusive. Null array input produces null output.

      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 `Date`, the following usage is envisaged:

           Date[] someDates = (Date[])ArrayUtils.subarray(allDates, 2, 5);

      Parameters:
        `array` - the array
        `startIndexInclusive` - the starting index. Undervalue (<0) is promoted to 0, overvalue (>array.length) results in an empty array.
        `endIndexExclusive` - elements up to endIndex-1 are present in the returned subarray. Undervalue (< startIndex) produces empty array, overvalue (>array.length) is demoted to array length.
      Returns:
        a new array containing the elements between the start and end indices.
      Since:
        2.1

    - #### subarray

          public static long[] subarray(long[] array,
                                        int startIndexInclusive,
                                        int endIndexExclusive)

      Produces a new `long` array containing the elements between the start and end indices.

      The start index is inclusive, the end index exclusive. Null array input produces null output.

      Parameters:
        `array` - the array
        `startIndexInclusive` - the starting index. Undervalue (<0) is promoted to 0, overvalue (>array.length) results in an empty array.
        `endIndexExclusive` - elements up to endIndex-1 are present in the returned subarray. Undervalue (< startIndex) produces empty array, overvalue (>array.length) is demoted to array length.
      Returns:
        a new array containing the elements between the start and end indices.
      Since:
        2.1

    - #### subarray

          public static int[] subarray(int[] array,
                                       int startIndexInclusive,
                                       int endIndexExclusive)

      Produces a new `int` array containing the elements between the start and end indices.

      The start index is inclusive, the end index exclusive. Null array input produces null output.

      Parameters:
        `array` - the array
        `startIndexInclusive` - the starting index. Undervalue (<0) is promoted to 0, overvalue (>array.length) results in an empty array.
        `endIndexExclusive` - elements up to endIndex-1 are present in the returned subarray. Undervalue (< startIndex) produces empty array, overvalue (>array.length) is demoted to array length.
      Returns:
        a new array containing the elements between the start and end indices.
      Since:
        2.1

    - #### subarray

          public static short[] subarray(short[] array,
                                         int startIndexInclusive,
                                         int endIndexExclusive)

      Produces a new `short` array containing the elements between the start and end indices.

      The start index is inclusive, the end index exclusive. Null array input produces null output.

      Parameters:
        `array` - the array
        `startIndexInclusive` - the starting index. Undervalue (<0) is promoted to 0, overvalue (>array.length) results in an empty array.
        `endIndexExclusive` - elements up to endIndex-1 are present in the returned subarray. Undervalue (< startIndex) produces empty array, overvalue (>array.length) is demoted to array length.
      Returns:
        a new array containing the elements between the start and end indices.
      Since:
        2.1

    - #### subarray

          public static char[] subarray(char[] array,
                                        int startIndexInclusive,
                                        int endIndexExclusive)

      Produces a new `char` array containing the elements between the start and end indices.

      The start index is inclusive, the end index exclusive. Null array input produces null output.

      Parameters:
        `array` - the array
        `startIndexInclusive` - the starting index. Undervalue (<0) is promoted to 0, overvalue (>array.length) results in an empty array.
        `endIndexExclusive` - elements up to endIndex-1 are present in the returned subarray. Undervalue (< startIndex) produces empty array, overvalue (>array.length) is demoted to array length.
      Returns:
        a new array containing the elements between the start and end indices.
      Since:
        2.1

    - #### subarray

          public static byte[] subarray(byte[] array,
                                        int startIndexInclusive,
                                        int endIndexExclusive)

      Produces a new `byte` array containing the elements between the start and end indices.

      The start index is inclusive, the end index exclusive. Null array input produces null output.

      Parameters:
        `array` - the array
        `startIndexInclusive` - the starting index. Undervalue (<0) is promoted to 0, overvalue (>array.length) results in an empty array.
        `endIndexExclusive` - elements up to endIndex-1 are present in the returned subarray. Undervalue (< startIndex) produces empty array, overvalue (>array.length) is demoted to array length.
      Returns:
        a new array containing the elements between the start and end indices.
      Since:
        2.1

    - #### subarray

          public static double[] subarray(double[] array,
                                          int startIndexInclusive,
                                          int endIndexExclusive)

      Produces a new `double` array containing the elements between the start and end indices.

      The start index is inclusive, the end index exclusive. Null array input produces null output.

      Parameters:
        `array` - the array
        `startIndexInclusive` - the starting index. Undervalue (<0) is promoted to 0, overvalue (>array.length) results in an empty array.
        `endIndexExclusive` - elements up to endIndex-1 are present in the returned subarray. Undervalue (< startIndex) produces empty array, overvalue (>array.length) is demoted to array length.
      Returns:
        a new array containing the elements between the start and end indices.
      Since:
        2.1

    - #### subarray

          public static float[] subarray(float[] array,
                                         int startIndexInclusive,
                                         int endIndexExclusive)

      Produces a new `float` array containing the elements between the start and end indices.

      The start index is inclusive, the end index exclusive. Null array input produces null output.

      Parameters:
        `array` - the array
        `startIndexInclusive` - the starting index. Undervalue (<0) is promoted to 0, overvalue (>array.length) results in an empty array.
        `endIndexExclusive` - elements up to endIndex-1 are present in the returned subarray. Undervalue (< startIndex) produces empty array, overvalue (>array.length) is demoted to array length.
      Returns:
        a new array containing the elements between the start and end indices.
      Since:
        2.1

    - #### subarray

          public static boolean[] subarray(boolean[] array,
                                           int startIndexInclusive,
                                           int endIndexExclusive)

      Produces a new `boolean` array containing the elements between the start and end indices.

      The start index is inclusive, the end index exclusive. Null array input produces null output.

      Parameters:
        `array` - the array
        `startIndexInclusive` - the starting index. Undervalue (<0) is promoted to 0, overvalue (>array.length) results in an empty array.
        `endIndexExclusive` - elements up to endIndex-1 are present in the returned subarray. Undervalue (< startIndex) produces empty array, overvalue (>array.length) is demoted to array length.
      Returns:
        a new array containing the elements between the start and end indices.
      Since:
        2.1

    - #### isSameLength

          public static boolean isSameLength(java.lang.Object[] array1,
                                             java.lang.Object[] array2)

      Checks whether two arrays are the same length, treating `null` arrays as length `0`.

      Any multi-dimensional aspects of the arrays are ignored.

      Parameters:
        `array1` - the first array, may be `null`
        `array2` - the second array, may be `null`
      Returns:
        `true` if length of arrays matches, treating `null` as an empty array

    - #### isSameLength

          public static boolean isSameLength(long[] array1,
                                             long[] array2)

      Checks whether two arrays are the same length, treating `null` arrays as length `0`.

      Parameters:
        `array1` - the first array, may be `null`
        `array2` - the second array, may be `null`
      Returns:
        `true` if length of arrays matches, treating `null` as an empty array

    - #### isSameLength

          public static boolean isSameLength(int[] array1,
                                             int[] array2)

      Checks whether two arrays are the same length, treating `null` arrays as length `0`.

      Parameters:
        `array1` - the first array, may be `null`
        `array2` - the second array, may be `null`
      Returns:
        `true` if length of arrays matches, treating `null` as an empty array

    - #### isSameLength

          public static boolean isSameLength(short[] array1,
                                             short[] array2)

      Checks whether two arrays are the same length, treating `null` arrays as length `0`.

      Parameters:
        `array1` - the first array, may be `null`
        `array2` - the second array, may be `null`
      Returns:
        `true` if length of arrays matches, treating `null` as an empty array

    - #### isSameLength

          public static boolean isSameLength(char[] array1,
                                             char[] array2)

      Checks whether two arrays are the same length, treating `null` arrays as length `0`.

      Parameters:
        `array1` - the first array, may be `null`
        `array2` - the second array, may be `null`
      Returns:
        `true` if length of arrays matches, treating `null` as an empty array

    - #### isSameLength

          public static boolean isSameLength(byte[] array1,
                                             byte[] array2)

      Checks whether two arrays are the same length, treating `null` arrays as length `0`.

      Parameters:
        `array1` - the first array, may be `null`
        `array2` - the second array, may be `null`
      Returns:
        `true` if length of arrays matches, treating `null` as an empty array

    - #### isSameLength

          public static boolean isSameLength(double[] array1,
                                             double[] array2)

      Checks whether two arrays are the same length, treating `null` arrays as length `0`.

      Parameters:
        `array1` - the first array, may be `null`
        `array2` - the second array, may be `null`
      Returns:
        `true` if length of arrays matches, treating `null` as an empty array

    - #### isSameLength

          public static boolean isSameLength(float[] array1,
                                             float[] array2)

      Checks whether two arrays are the same length, treating `null` arrays as length `0`.

      Parameters:
        `array1` - the first array, may be `null`
        `array2` - the second array, may be `null`
      Returns:
        `true` if length of arrays matches, treating `null` as an empty array

    - #### isSameLength

          public static boolean isSameLength(boolean[] array1,
                                             boolean[] array2)

      Checks whether two arrays are the same length, treating `null` arrays as length `0`.

      Parameters:
        `array1` - the first array, may be `null`
        `array2` - the second array, may be `null`
      Returns:
        `true` if length of arrays matches, treating `null` as an empty array

    - #### getLength

          public static int getLength(java.lang.Object array)

      Returns the length of the specified array. This method can deal with `Object` arrays and with primitive arrays.

      If the input array is `null`, `0` is returned.

           ArrayUtils.getLength(null)            = 0
           ArrayUtils.getLength([])              = 0
           ArrayUtils.getLength([null])          = 1
           ArrayUtils.getLength([true, false])   = 2
           ArrayUtils.getLength([1, 2, 3])       = 3
           ArrayUtils.getLength(["a", "b", "c"]) = 3

      Parameters:
        `array` - the array to retrieve the length from, may be null
      Returns:
        The length of the array, or `0` if the array is `null`
      Throws:
        `java.lang.IllegalArgumentException` - if the object arguement is not an array.
      Since:
        2.1

    - #### isSameType

          public static boolean isSameType(java.lang.Object array1,
                                           java.lang.Object array2)

      Checks whether two arrays are the same type taking into account multi-dimensional arrays.

      Parameters:
        `array1` - the first array, must not be `null`
        `array2` - the second array, must not be `null`
      Returns:
        `true` if type of arrays matches
      Throws:
        `java.lang.IllegalArgumentException` - if either array is `null`

    - #### reverse

          public static void reverse(java.lang.Object[] array)

      Reverses the order of the given array.

      There is no special handling for multi-dimensional arrays.

      This method does nothing for a `null` input array.

      Parameters:
        `array` - the array to reverse, may be `null`

    - #### reverse

          public static void reverse(long[] array)

      Reverses the order of the given array.

      This method does nothing for a `null` input array.

      Parameters:
        `array` - the array to reverse, may be `null`

    - #### reverse

          public static void reverse(int[] array)

      Reverses the order of the given array.

      This method does nothing for a `null` input array.

      Parameters:
        `array` - the array to reverse, may be `null`

    - #### reverse

          public static void reverse(short[] array)

      Reverses the order of the given array.

      This method does nothing for a `null` input array.

      Parameters:
        `array` - the array to reverse, may be `null`

    - #### reverse

          public static void reverse(char[] array)

      Reverses the order of the given array.

      This method does nothing for a `null` input array.

      Parameters:
        `array` - the array to reverse, may be `null`

    - #### reverse

          public static void reverse(byte[] array)

      Reverses the order of the given array.

      This method does nothing for a `null` input array.

      Parameters:
        `array` - the array to reverse, may be `null`

    - #### reverse

          public static void reverse(double[] array)

      Reverses the order of the given array.

      This method does nothing for a `null` input array.

      Parameters:
        `array` - the array to reverse, may be `null`

    - #### reverse

          public static void reverse(float[] array)

      Reverses the order of the given array.

      This method does nothing for a `null` input array.

      Parameters:
        `array` - the array to reverse, may be `null`

    - #### reverse

          public static void reverse(boolean[] array)

      Reverses the order of the given array.

      This method does nothing for a `null` input array.

      Parameters:
        `array` - the array to reverse, may be `null`

    - #### indexOf

          public static int indexOf(java.lang.Object[] array,
                                    java.lang.Object objectToFind)

      Finds the index of the given object in the array.

      This method returns `INDEX_NOT_FOUND` (`-1`) for a `null` input array.

      Parameters:
        `array` - the array to search through for the object, may be `null`
        `objectToFind` - the object to find, may be `null`
      Returns:
        the index of the object within the array, `INDEX_NOT_FOUND` (`-1`) if not found or `null` array input

    - #### indexOf

          public static int indexOf(java.lang.Object[] array,
                                    java.lang.Object objectToFind,
                                    int startIndex)

      Finds the index of the given object in the array starting at the given index.

      This method returns `INDEX_NOT_FOUND` (`-1`) for a `null` input array.

      A negative startIndex is treated as zero. A startIndex larger than the array length will return `INDEX_NOT_FOUND` (`-1`).

      Parameters:
        `array` - the array to search through for the object, may be `null`
        `objectToFind` - the object to find, may be `null`
        `startIndex` - the index to start searching at
      Returns:
        the index of the object within the array starting at the index, `INDEX_NOT_FOUND` (`-1`) if not found or `null` array input

    - #### lastIndexOf

          public static int lastIndexOf(java.lang.Object[] array,
                                        java.lang.Object objectToFind)

      Finds the last index of the given object within the array.

      This method returns `INDEX_NOT_FOUND` (`-1`) for a `null` input array.

      Parameters:
        `array` - the array to travers backwords looking for the object, may be `null`
        `objectToFind` - the object to find, may be `null`
      Returns:
        the last index of the object within the array, `INDEX_NOT_FOUND` (`-1`) if not found or `null` array input

    - #### lastIndexOf

          public static int lastIndexOf(java.lang.Object[] array,
                                        java.lang.Object objectToFind,
                                        int startIndex)

      Finds the last index of the given object in the array starting at the given index.

      This method returns `INDEX_NOT_FOUND` (`-1`) for a `null` input array.

      A negative startIndex will return `INDEX_NOT_FOUND` (`-1`). A startIndex larger than the array length will search from the end of the array.

      Parameters:
        `array` - the array to traverse for looking for the object, may be `null`
        `objectToFind` - the object to find, may be `null`
        `startIndex` - the start index to travers backwards from
      Returns:
        the last index of the object within the array, `INDEX_NOT_FOUND` (`-1`) if not found or `null` array input

    - #### contains

          public static boolean contains(java.lang.Object[] array,
                                         java.lang.Object objectToFind)

      Checks if the object is in the given array.

      The method returns `false` if a `null` array is passed in.

      Parameters:
        `array` - the array to search through
        `objectToFind` - the object to find
      Returns:
        `true` if the array contains the object

    - #### indexOf

          public static int indexOf(long[] array,
                                    long valueToFind)

      Finds the index of the given value in the array.

      This method returns `INDEX_NOT_FOUND` (`-1`) for a `null` input array.

      Parameters:
        `array` - the array to search through for the object, may be `null`
        `valueToFind` - the value to find
      Returns:
        the index of the value within the array, `INDEX_NOT_FOUND` (`-1`) if not found or `null` array input

    - #### indexOf

          public static int indexOf(long[] array,
                                    long valueToFind,
                                    int startIndex)

      Finds the index of the given value in the array starting at the given index.

      This method returns `INDEX_NOT_FOUND` (`-1`) for a `null` input array.

      A negative startIndex is treated as zero. A startIndex larger than the array length will return `INDEX_NOT_FOUND` (`-1`).

      Parameters:
        `array` - the array to search through for the object, may be `null`
        `valueToFind` - the value to find
        `startIndex` - the index to start searching at
      Returns:
        the index of the value within the array, `INDEX_NOT_FOUND` (`-1`) if not found or `null` array input

    - #### lastIndexOf

          public static int lastIndexOf(long[] array,
                                        long valueToFind)

      Finds the last index of the given value within the array.

      This method returns `INDEX_NOT_FOUND` (`-1`) for a `null` input array.

      Parameters:
        `array` - the array to travers backwords looking for the object, may be `null`
        `valueToFind` - the object to find
      Returns:
        the last index of the value within the array, `INDEX_NOT_FOUND` (`-1`) if not found or `null` array input

    - #### lastIndexOf

          public static int lastIndexOf(long[] array,
                                        long valueToFind,
                                        int startIndex)

      Finds the last index of the given value in the array starting at the given index.

      This method returns `INDEX_NOT_FOUND` (`-1`) for a `null` input array.

      A negative startIndex will return `INDEX_NOT_FOUND` (`-1`). A startIndex larger than the array length will search from the end of the array.

      Parameters:
        `array` - the array to traverse for looking for the object, may be `null`
        `valueToFind` - the value to find
        `startIndex` - the start index to travers backwards from
      Returns:
        the last index of the value within the array, `INDEX_NOT_FOUND` (`-1`) if not found or `null` array input

    - #### contains

          public static boolean contains(long[] array,
                                         long valueToFind)

      Checks if the value is in the given array.

      The method returns `false` if a `null` array is passed in.

      Parameters:
        `array` - the array to search through
        `valueToFind` - the value to find
      Returns:
        `true` if the array contains the object

    - #### indexOf

          public static int indexOf(int[] array,
                                    int valueToFind)

      Finds the index of the given value in the array.

      This method returns `INDEX_NOT_FOUND` (`-1`) for a `null` input array.

      Parameters:
        `array` - the array to search through for the object, may be `null`
        `valueToFind` - the value to find
      Returns:
        the index of the value within the array, `INDEX_NOT_FOUND` (`-1`) if not found or `null` array input

    - #### indexOf

          public static int indexOf(int[] array,
                                    int valueToFind,
                                    int startIndex)

      Finds the index of the given value in the array starting at the given index.

      This method returns `INDEX_NOT_FOUND` (`-1`) for a `null` input array.

      A negative startIndex is treated as zero. A startIndex larger than the array length will return `INDEX_NOT_FOUND` (`-1`).

      Parameters:
        `array` - the array to search through for the object, may be `null`
        `valueToFind` - the value to find
        `startIndex` - the index to start searching at
      Returns:
        the index of the value within the array, `INDEX_NOT_FOUND` (`-1`) if not found or `null` array input

    - #### lastIndexOf

          public static int lastIndexOf(int[] array,
                                        int valueToFind)

      Finds the last index of the given value within the array.

      This method returns `INDEX_NOT_FOUND` (`-1`) for a `null` input array.

      Parameters:
        `array` - the array to travers backwords looking for the object, may be `null`
        `valueToFind` - the object to find
      Returns:
        the last index of the value within the array, `INDEX_NOT_FOUND` (`-1`) if not found or `null` array input

    - #### lastIndexOf

          public static int lastIndexOf(int[] array,
                                        int valueToFind,
                                        int startIndex)

      Finds the last index of the given value in the array starting at the given index.

      This method returns `INDEX_NOT_FOUND` (`-1`) for a `null` input array.

      A negative startIndex will return `INDEX_NOT_FOUND` (`-1`). A startIndex larger than the array length will search from the end of the array.

      Parameters:
        `array` - the array to traverse for looking for the object, may be `null`
        `valueToFind` - the value to find
        `startIndex` - the start index to travers backwards from
      Returns:
        the last index of the value within the array, `INDEX_NOT_FOUND` (`-1`) if not found or `null` array input

    - #### contains

          public static boolean contains(int[] array,
                                         int valueToFind)

      Checks if the value is in the given array.

      The method returns `false` if a `null` array is passed in.

      Parameters:
        `array` - the array to search through
        `valueToFind` - the value to find
      Returns:
        `true` if the array contains the object

    - #### indexOf

          public static int indexOf(short[] array,
                                    short valueToFind)

      Finds the index of the given value in the array.

      This method returns `INDEX_NOT_FOUND` (`-1`) for a `null` input array.

      Parameters:
        `array` - the array to search through for the object, may be `null`
        `valueToFind` - the value to find
      Returns:
        the index of the value within the array, `INDEX_NOT_FOUND` (`-1`) if not found or `null` array input

    - #### indexOf

          public static int indexOf(short[] array,
                                    short valueToFind,
                                    int startIndex)

      Finds the index of the given value in the array starting at the given index.

      This method returns `INDEX_NOT_FOUND` (`-1`) for a `null` input array.

      A negative startIndex is treated as zero. A startIndex larger than the array length will return `INDEX_NOT_FOUND` (`-1`).

      Parameters:
        `array` - the array to search through for the object, may be `null`
        `valueToFind` - the value to find
        `startIndex` - the index to start searching at
      Returns:
        the index of the value within the array, `INDEX_NOT_FOUND` (`-1`) if not found or `null` array input

    - #### lastIndexOf

          public static int lastIndexOf(short[] array,
                                        short valueToFind)

      Finds the last index of the given value within the array.

      This method returns `INDEX_NOT_FOUND` (`-1`) for a `null` input array.

      Parameters:
        `array` - the array to travers backwords looking for the object, may be `null`
        `valueToFind` - the object to find
      Returns:
        the last index of the value within the array, `INDEX_NOT_FOUND` (`-1`) if not found or `null` array input

    - #### lastIndexOf

          public static int lastIndexOf(short[] array,
                                        short valueToFind,
                                        int startIndex)

      Finds the last index of the given value in the array starting at the given index.

      This method returns `INDEX_NOT_FOUND` (`-1`) for a `null` input array.

      A negative startIndex will return `INDEX_NOT_FOUND` (`-1`). A startIndex larger than the array length will search from the end of the array.

      Parameters:
        `array` - the array to traverse for looking for the object, may be `null`
        `valueToFind` - the value to find
        `startIndex` - the start index to travers backwards from
      Returns:
        the last index of the value within the array, `INDEX_NOT_FOUND` (`-1`) if not found or `null` array input

    - #### contains

          public static boolean contains(short[] array,
                                         short valueToFind)

      Checks if the value is in the given array.

      The method returns `false` if a `null` array is passed in.

      Parameters:
        `array` - the array to search through
        `valueToFind` - the value to find
      Returns:
        `true` if the array contains the object

    - #### indexOf

          public static int indexOf(char[] array,
                                    char valueToFind)

      Finds the index of the given value in the array.

      This method returns `INDEX_NOT_FOUND` (`-1`) for a `null` input array.

      Parameters:
        `array` - the array to search through for the object, may be `null`
        `valueToFind` - the value to find
      Returns:
        the index of the value within the array, `INDEX_NOT_FOUND` (`-1`) if not found or `null` array input
      Since:
        2.1

    - #### indexOf

          public static int indexOf(char[] array,
                                    char valueToFind,
                                    int startIndex)

      Finds the index of the given value in the array starting at the given index.

      This method returns `INDEX_NOT_FOUND` (`-1`) for a `null` input array.

      A negative startIndex is treated as zero. A startIndex larger than the array length will return `INDEX_NOT_FOUND` (`-1`).

      Parameters:
        `array` - the array to search through for the object, may be `null`
        `valueToFind` - the value to find
        `startIndex` - the index to start searching at
      Returns:
        the index of the value within the array, `INDEX_NOT_FOUND` (`-1`) if not found or `null` array input
      Since:
        2.1

    - #### lastIndexOf

          public static int lastIndexOf(char[] array,
                                        char valueToFind)

      Finds the last index of the given value within the array.

      This method returns `INDEX_NOT_FOUND` (`-1`) for a `null` input array.

      Parameters:
        `array` - the array to travers backwords looking for the object, may be `null`
        `valueToFind` - the object to find
      Returns:
        the last index of the value within the array, `INDEX_NOT_FOUND` (`-1`) if not found or `null` array input
      Since:
        2.1

    - #### lastIndexOf

          public static int lastIndexOf(char[] array,
                                        char valueToFind,
                                        int startIndex)

      Finds the last index of the given value in the array starting at the given index.

      This method returns `INDEX_NOT_FOUND` (`-1`) for a `null` input array.

      A negative startIndex will return `INDEX_NOT_FOUND` (`-1`). A startIndex larger than the array length will search from the end of the array.

      Parameters:
        `array` - the array to traverse for looking for the object, may be `null`
        `valueToFind` - the value to find
        `startIndex` - the start index to travers backwards from
      Returns:
        the last index of the value within the array, `INDEX_NOT_FOUND` (`-1`) if not found or `null` array input
      Since:
        2.1

    - #### contains

          public static boolean contains(char[] array,
                                         char valueToFind)

      Checks if the value is in the given array.

      The method returns `false` if a `null` array is passed in.

      Parameters:
        `array` - the array to search through
        `valueToFind` - the value to find
      Returns:
        `true` if the array contains the object
      Since:
        2.1

    - #### indexOf

          public static int indexOf(byte[] array,
                                    byte valueToFind)

      Finds the index of the given value in the array.

      This method returns `INDEX_NOT_FOUND` (`-1`) for a `null` input array.

      Parameters:
        `array` - the array to search through for the object, may be `null`
        `valueToFind` - the value to find
      Returns:
        the index of the value within the array, `INDEX_NOT_FOUND` (`-1`) if not found or `null` array input

    - #### indexOf

          public static int indexOf(byte[] array,
                                    byte valueToFind,
                                    int startIndex)

      Finds the index of the given value in the array starting at the given index.

      This method returns `INDEX_NOT_FOUND` (`-1`) for a `null` input array.

      A negative startIndex is treated as zero. A startIndex larger than the array length will return `INDEX_NOT_FOUND` (`-1`).

      Parameters:
        `array` - the array to search through for the object, may be `null`
        `valueToFind` - the value to find
        `startIndex` - the index to start searching at
      Returns:
        the index of the value within the array, `INDEX_NOT_FOUND` (`-1`) if not found or `null` array input

    - #### lastIndexOf

          public static int lastIndexOf(byte[] array,
                                        byte valueToFind)

      Finds the last index of the given value within the array.

      This method returns `INDEX_NOT_FOUND` (`-1`) for a `null` input array.

      Parameters:
        `array` - the array to travers backwords looking for the object, may be `null`
        `valueToFind` - the object to find
      Returns:
        the last index of the value within the array, `INDEX_NOT_FOUND` (`-1`) if not found or `null` array input

    - #### lastIndexOf

          public static int lastIndexOf(byte[] array,
                                        byte valueToFind,
                                        int startIndex)

      Finds the last index of the given value in the array starting at the given index.

      This method returns `INDEX_NOT_FOUND` (`-1`) for a `null` input array.

      A negative startIndex will return `INDEX_NOT_FOUND` (`-1`). A startIndex larger than the array length will search from the end of the array.

      Parameters:
        `array` - the array to traverse for looking for the object, may be `null`
        `valueToFind` - the value to find
        `startIndex` - the start index to travers backwards from
      Returns:
        the last index of the value within the array, `INDEX_NOT_FOUND` (`-1`) if not found or `null` array input

    - #### contains

          public static boolean contains(byte[] array,
                                         byte valueToFind)

      Checks if the value is in the given array.

      The method returns `false` if a `null` array is passed in.

      Parameters:
        `array` - the array to search through
        `valueToFind` - the value to find
      Returns:
        `true` if the array contains the object

    - #### indexOf

          public static int indexOf(double[] array,
                                    double valueToFind)

      Finds the index of the given value in the array.

      This method returns `INDEX_NOT_FOUND` (`-1`) for a `null` input array.

      Parameters:
        `array` - the array to search through for the object, may be `null`
        `valueToFind` - the value to find
      Returns:
        the index of the value within the array, `INDEX_NOT_FOUND` (`-1`) if not found or `null` array input

    - #### indexOf

          public static int indexOf(double[] array,
                                    double valueToFind,
                                    double tolerance)

      Finds the index of the given value within a given tolerance in the array. This method will return the index of the first value which falls between the region defined by valueToFind - tolerance and valueToFind + tolerance.

      This method returns `INDEX_NOT_FOUND` (`-1`) for a `null` input array.

      Parameters:
        `array` - the array to search through for the object, may be `null`
        `valueToFind` - the value to find
        `tolerance` - tolerance of the search
      Returns:
        the index of the value within the array, `INDEX_NOT_FOUND` (`-1`) if not found or `null` array input

    - #### indexOf

          public static int indexOf(double[] array,
                                    double valueToFind,
                                    int startIndex)

      Finds the index of the given value in the array starting at the given index.

      This method returns `INDEX_NOT_FOUND` (`-1`) for a `null` input array.

      A negative startIndex is treated as zero. A startIndex larger than the array length will return `INDEX_NOT_FOUND` (`-1`).

      Parameters:
        `array` - the array to search through for the object, may be `null`
        `valueToFind` - the value to find
        `startIndex` - the index to start searching at
      Returns:
        the index of the value within the array, `INDEX_NOT_FOUND` (`-1`) if not found or `null` array input

    - #### indexOf

          public static int indexOf(double[] array,
                                    double valueToFind,
                                    int startIndex,
                                    double tolerance)

      Finds the index of the given value in the array starting at the given index. This method will return the index of the first value which falls between the region defined by valueToFind - tolerance and valueToFind + tolerance.

      This method returns `INDEX_NOT_FOUND` (`-1`) for a `null` input array.

      A negative startIndex is treated as zero. A startIndex larger than the array length will return `INDEX_NOT_FOUND` (`-1`).

      Parameters:
        `array` - the array to search through for the object, may be `null`
        `valueToFind` - the value to find
        `startIndex` - the index to start searching at
        `tolerance` - tolerance of the search
      Returns:
        the index of the value within the array, `INDEX_NOT_FOUND` (`-1`) if not found or `null` array input

    - #### lastIndexOf

          public static int lastIndexOf(double[] array,
                                        double valueToFind)

      Finds the last index of the given value within the array.

      This method returns `INDEX_NOT_FOUND` (`-1`) for a `null` input array.

      Parameters:
        `array` - the array to travers backwords looking for the object, may be `null`
        `valueToFind` - the object to find
      Returns:
        the last index of the value within the array, `INDEX_NOT_FOUND` (`-1`) if not found or `null` array input

    - #### lastIndexOf

          public static int lastIndexOf(double[] array,
                                        double valueToFind,
                                        double tolerance)

      Finds the last index of the given value within a given tolerance in the array. This method will return the index of the last value which falls between the region defined by valueToFind - tolerance and valueToFind + tolerance.

      This method returns `INDEX_NOT_FOUND` (`-1`) for a `null` input array.

      Parameters:
        `array` - the array to search through for the object, may be `null`
        `valueToFind` - the value to find
        `tolerance` - tolerance of the search
      Returns:
        the index of the value within the array, `INDEX_NOT_FOUND` (`-1`) if not found or `null` array input

    - #### lastIndexOf

          public static int lastIndexOf(double[] array,
                                        double valueToFind,
                                        int startIndex)

      Finds the last index of the given value in the array starting at the given index.

      This method returns `INDEX_NOT_FOUND` (`-1`) for a `null` input array.

      A negative startIndex will return `INDEX_NOT_FOUND` (`-1`). A startIndex larger than the array length will search from the end of the array.

      Parameters:
        `array` - the array to traverse for looking for the object, may be `null`
        `valueToFind` - the value to find
        `startIndex` - the start index to travers backwards from
      Returns:
        the last index of the value within the array, `INDEX_NOT_FOUND` (`-1`) if not found or `null` array input

    - #### lastIndexOf

          public static int lastIndexOf(double[] array,
                                        double valueToFind,
                                        int startIndex,
                                        double tolerance)

      Finds the last index of the given value in the array starting at the given index. This method will return the index of the last value which falls between the region defined by valueToFind - tolerance and valueToFind + tolerance.

      This method returns `INDEX_NOT_FOUND` (`-1`) for a `null` input array.

      A negative startIndex will return `INDEX_NOT_FOUND` (`-1`). A startIndex larger than the array length will search from the end of the array.

      Parameters:
        `array` - the array to traverse for looking for the object, may be `null`
        `valueToFind` - the value to find
        `startIndex` - the start index to travers backwards from
        `tolerance` - search for value within plus/minus this amount
      Returns:
        the last index of the value within the array, `INDEX_NOT_FOUND` (`-1`) if not found or `null` array input

    - #### contains

          public static boolean contains(double[] array,
                                         double valueToFind)

      Checks if the value is in the given array.

      The method returns `false` if a `null` array is passed in.

      Parameters:
        `array` - the array to search through
        `valueToFind` - the value to find
      Returns:
        `true` if the array contains the object

    - #### contains

          public static boolean contains(double[] array,
                                         double valueToFind,
                                         double tolerance)

      Checks if a value falling within the given tolerance is in the given array. If the array contains a value within the inclusive range defined by (value - tolerance) to (value + tolerance).

      The method returns `false` if a `null` array is passed in.

      Parameters:
        `array` - the array to search
        `valueToFind` - the value to find
        `tolerance` - the array contains the tolerance of the search
      Returns:
        true if value falling within tolerance is in array

    - #### indexOf

          public static int indexOf(float[] array,
                                    float valueToFind)

      Finds the index of the given value in the array.

      This method returns `INDEX_NOT_FOUND` (`-1`) for a `null` input array.

      Parameters:
        `array` - the array to search through for the object, may be `null`
        `valueToFind` - the value to find
      Returns:
        the index of the value within the array, `INDEX_NOT_FOUND` (`-1`) if not found or `null` array input

    - #### indexOf

          public static int indexOf(float[] array,
                                    float valueToFind,
                                    int startIndex)

      Finds the index of the given value in the array starting at the given index.

      This method returns `INDEX_NOT_FOUND` (`-1`) for a `null` input array.

      A negative startIndex is treated as zero. A startIndex larger than the array length will return `INDEX_NOT_FOUND` (`-1`).

      Parameters:
        `array` - the array to search through for the object, may be `null`
        `valueToFind` - the value to find
        `startIndex` - the index to start searching at
      Returns:
        the index of the value within the array, `INDEX_NOT_FOUND` (`-1`) if not found or `null` array input

    - #### lastIndexOf

          public static int lastIndexOf(float[] array,
                                        float valueToFind)

      Finds the last index of the given value within the array.

      This method returns `INDEX_NOT_FOUND` (`-1`) for a `null` input array.

      Parameters:
        `array` - the array to travers backwords looking for the object, may be `null`
        `valueToFind` - the object to find
      Returns:
        the last index of the value within the array, `INDEX_NOT_FOUND` (`-1`) if not found or `null` array input

    - #### lastIndexOf

          public static int lastIndexOf(float[] array,
                                        float valueToFind,
                                        int startIndex)

      Finds the last index of the given value in the array starting at the given index.

      This method returns `INDEX_NOT_FOUND` (`-1`) for a `null` input array.

      A negative startIndex will return `INDEX_NOT_FOUND` (`-1`). A startIndex larger than the array length will search from the end of the array.

      Parameters:
        `array` - the array to traverse for looking for the object, may be `null`
        `valueToFind` - the value to find
        `startIndex` - the start index to travers backwards from
      Returns:
        the last index of the value within the array, `INDEX_NOT_FOUND` (`-1`) if not found or `null` array input

    - #### contains

          public static boolean contains(float[] array,
                                         float valueToFind)

      Checks if the value is in the given array.

      The method returns `false` if a `null` array is passed in.

      Parameters:
        `array` - the array to search through
        `valueToFind` - the value to find
      Returns:
        `true` if the array contains the object

    - #### indexOf

          public static int indexOf(boolean[] array,
                                    boolean valueToFind)

      Finds the index of the given value in the array.

      This method returns `INDEX_NOT_FOUND` (`-1`) for a `null` input array.

      Parameters:
        `array` - the array to search through for the object, may be `null`
        `valueToFind` - the value to find
      Returns:
        the index of the value within the array, `INDEX_NOT_FOUND` (`-1`) if not found or `null` array input

    - #### indexOf

          public static int indexOf(boolean[] array,
                                    boolean valueToFind,
                                    int startIndex)

      Finds the index of the given value in the array starting at the given index.

      This method returns `INDEX_NOT_FOUND` (`-1`) for a `null` input array.

      A negative startIndex is treated as zero. A startIndex larger than the array length will return `INDEX_NOT_FOUND` (`-1`).

      Parameters:
        `array` - the array to search through for the object, may be `null`
        `valueToFind` - the value to find
        `startIndex` - the index to start searching at
      Returns:
        the index of the value within the array, `INDEX_NOT_FOUND` (`-1`) if not found or `null` array input

    - #### lastIndexOf

          public static int lastIndexOf(boolean[] array,
                                        boolean valueToFind)

      Finds the last index of the given value within the array.

      This method returns `INDEX_NOT_FOUND` (`-1`) if `null` array input.

      Parameters:
        `array` - the array to travers backwords looking for the object, may be `null`
        `valueToFind` - the object to find
      Returns:
        the last index of the value within the array, `INDEX_NOT_FOUND` (`-1`) if not found or `null` array input

    - #### lastIndexOf

          public static int lastIndexOf(boolean[] array,
                                        boolean valueToFind,
                                        int startIndex)

      Finds the last index of the given value in the array starting at the given index.

      This method returns `INDEX_NOT_FOUND` (`-1`) for a `null` input array.

      A negative startIndex will return `INDEX_NOT_FOUND` (`-1`). A startIndex larger than the array length will search from the end of the array.

      Parameters:
        `array` - the array to traverse for looking for the object, may be `null`
        `valueToFind` - the value to find
        `startIndex` - the start index to travers backwards from
      Returns:
        the last index of the value within the array, `INDEX_NOT_FOUND` (`-1`) if not found or `null` array input

    - #### contains

          public static boolean contains(boolean[] array,
                                         boolean valueToFind)

      Checks if the value is in the given array.

      The method returns `false` if a `null` array is passed in.

      Parameters:
        `array` - the array to search through
        `valueToFind` - the value to find
      Returns:
        `true` if the array contains the object

    - #### toPrimitive

          public static char[] toPrimitive(java.lang.Character[] array)

      Converts an array of object Characters to primitives.

      This method returns `null` for a `null` input array.

      Parameters:
        `array` - a `Character` array, may be `null`
      Returns:
        a `char` array, `null` if null array input
      Throws:
        `java.lang.NullPointerException` - if array content is `null`

    - #### toPrimitive

          public static char[] toPrimitive(java.lang.Character[] array,
                                           char valueForNull)

      Converts an array of object Character to primitives handling `null`.

      This method returns `null` for a `null` input array.

      Parameters:
        `array` - a `Character` array, may be `null`
        `valueForNull` - the value to insert if `null` found
      Returns:
        a `char` array, `null` if null array input

    - #### toObject

          public static java.lang.Character[] toObject(char[] array)

      Converts an array of primitive chars to objects.

      This method returns `null` for a `null` input array.

      Parameters:
        `array` - a `char` array
      Returns:
        a `Character` array, `null` if null array input

    - #### toPrimitive

          public static long[] toPrimitive(java.lang.Long[] array)

      Converts an array of object Longs to primitives.

      This method returns `null` for a `null` input array.

      Parameters:
        `array` - a `Long` array, may be `null`
      Returns:
        a `long` array, `null` if null array input
      Throws:
        `java.lang.NullPointerException` - if array content is `null`

    - #### toPrimitive

          public static long[] toPrimitive(java.lang.Long[] array,
                                           long valueForNull)

      Converts an array of object Long to primitives handling `null`.

      This method returns `null` for a `null` input array.

      Parameters:
        `array` - a `Long` array, may be `null`
        `valueForNull` - the value to insert if `null` found
      Returns:
        a `long` array, `null` if null array input

    - #### toObject

          public static java.lang.Long[] toObject(long[] array)

      Converts an array of primitive longs to objects.

      This method returns `null` for a `null` input array.

      Parameters:
        `array` - a `long` array
      Returns:
        a `Long` array, `null` if null array input

    - #### toPrimitive

          public static int[] toPrimitive(java.lang.Integer[] array)

      Converts an array of object Integers to primitives.

      This method returns `null` for a `null` input array.

      Parameters:
        `array` - a `Integer` array, may be `null`
      Returns:
        an `int` array, `null` if null array input
      Throws:
        `java.lang.NullPointerException` - if array content is `null`

    - #### toPrimitive

          public static int[] toPrimitive(java.lang.Integer[] array,
                                          int valueForNull)

      Converts an array of object Integer to primitives handling `null`.

      This method returns `null` for a `null` input array.

      Parameters:
        `array` - a `Integer` array, may be `null`
        `valueForNull` - the value to insert if `null` found
      Returns:
        an `int` array, `null` if null array input

    - #### toObject

          public static java.lang.Integer[] toObject(int[] array)

      Converts an array of primitive ints to objects.

      This method returns `null` for a `null` input array.

      Parameters:
        `array` - an `int` array
      Returns:
        an `Integer` array, `null` if null array input

    - #### toPrimitive

          public static short[] toPrimitive(java.lang.Short[] array)

      Converts an array of object Shorts to primitives.

      This method returns `null` for a `null` input array.

      Parameters:
        `array` - a `Short` array, may be `null`
      Returns:
        a `byte` array, `null` if null array input
      Throws:
        `java.lang.NullPointerException` - if array content is `null`

    - #### toPrimitive

          public static short[] toPrimitive(java.lang.Short[] array,
                                            short valueForNull)

      Converts an array of object Short to primitives handling `null`.

      This method returns `null` for a `null` input array.

      Parameters:
        `array` - a `Short` array, may be `null`
        `valueForNull` - the value to insert if `null` found
      Returns:
        a `byte` array, `null` if null array input

    - #### toObject

          public static java.lang.Short[] toObject(short[] array)

      Converts an array of primitive shorts to objects.

      This method returns `null` for a `null` input array.

      Parameters:
        `array` - a `short` array
      Returns:
        a `Short` array, `null` if null array input

    - #### toPrimitive

          public static byte[] toPrimitive(java.lang.Byte[] array)

      Converts an array of object Bytes to primitives.

      This method returns `null` for a `null` input array.

      Parameters:
        `array` - a `Byte` array, may be `null`
      Returns:
        a `byte` array, `null` if null array input
      Throws:
        `java.lang.NullPointerException` - if array content is `null`

    - #### toPrimitive

          public static byte[] toPrimitive(java.lang.Byte[] array,
                                           byte valueForNull)

      Converts an array of object Bytes to primitives handling `null`.

      This method returns `null` for a `null` input array.

      Parameters:
        `array` - a `Byte` array, may be `null`
        `valueForNull` - the value to insert if `null` found
      Returns:
        a `byte` array, `null` if null array input

    - #### toObject

          public static java.lang.Byte[] toObject(byte[] array)

      Converts an array of primitive bytes to objects.

      This method returns `null` for a `null` input array.

      Parameters:
        `array` - a `byte` array
      Returns:
        a `Byte` array, `null` if null array input

    - #### toPrimitive

          public static double[] toPrimitive(java.lang.Double[] array)

      Converts an array of object Doubles to primitives.

      This method returns `null` for a `null` input array.

      Parameters:
        `array` - a `Double` array, may be `null`
      Returns:
        a `double` array, `null` if null array input
      Throws:
        `java.lang.NullPointerException` - if array content is `null`

    - #### toPrimitive

          public static double[] toPrimitive(java.lang.Double[] array,
                                             double valueForNull)

      Converts an array of object Doubles to primitives handling `null`.

      This method returns `null` for a `null` input array.

      Parameters:
        `array` - a `Double` array, may be `null`
        `valueForNull` - the value to insert if `null` found
      Returns:
        a `double` array, `null` if null array input

    - #### toObject

          public static java.lang.Double[] toObject(double[] array)

      Converts an array of primitive doubles to objects.

      This method returns `null` for a `null` input array.

      Parameters:
        `array` - a `double` array
      Returns:
        a `Double` array, `null` if null array input

    - #### toPrimitive

          public static float[] toPrimitive(java.lang.Float[] array)

      Converts an array of object Floats to primitives.

      This method returns `null` for a `null` input array.

      Parameters:
        `array` - a `Float` array, may be `null`
      Returns:
        a `float` array, `null` if null array input
      Throws:
        `java.lang.NullPointerException` - if array content is `null`

    - #### toPrimitive

          public static float[] toPrimitive(java.lang.Float[] array,
                                            float valueForNull)

      Converts an array of object Floats to primitives handling `null`.

      This method returns `null` for a `null` input array.

      Parameters:
        `array` - a `Float` array, may be `null`
        `valueForNull` - the value to insert if `null` found
      Returns:
        a `float` array, `null` if null array input

    - #### toObject

          public static java.lang.Float[] toObject(float[] array)

      Converts an array of primitive floats to objects.

      This method returns `null` for a `null` input array.

      Parameters:
        `array` - a `float` array
      Returns:
        a `Float` array, `null` if null array input

    - #### toPrimitive

          public static boolean[] toPrimitive(java.lang.Boolean[] array)

      Converts an array of object Booleans to primitives.

      This method returns `null` for a `null` input array.

      Parameters:
        `array` - a `Boolean` array, may be `null`
      Returns:
        a `boolean` array, `null` if null array input
      Throws:
        `java.lang.NullPointerException` - if array content is `null`

    - #### toPrimitive

          public static boolean[] toPrimitive(java.lang.Boolean[] array,
                                              boolean valueForNull)

      Converts an array of object Booleans to primitives handling `null`.

      This method returns `null` for a `null` input array.

      Parameters:
        `array` - a `Boolean` array, may be `null`
        `valueForNull` - the value to insert if `null` found
      Returns:
        a `boolean` array, `null` if null array input

    - #### toObject

          public static java.lang.Boolean[] toObject(boolean[] array)

      Converts an array of primitive booleans to objects.

      This method returns `null` for a `null` input array.

      Parameters:
        `array` - a `boolean` array
      Returns:
        a `Boolean` array, `null` if null array input

    - #### isEmpty

          public static boolean isEmpty(java.lang.Object[] array)

      Checks if an array of Objects is empty or `null`.

      Parameters:
        `array` - the array to test
      Returns:
        `true` if the array is empty or `null`
      Since:
        2.1

    - #### isEmpty

          public static boolean isEmpty(long[] array)

      Checks if an array of primitive longs is empty or `null`.

      Parameters:
        `array` - the array to test
      Returns:
        `true` if the array is empty or `null`
      Since:
        2.1

    - #### isEmpty

          public static boolean isEmpty(int[] array)

      Checks if an array of primitive ints is empty or `null`.

      Parameters:
        `array` - the array to test
      Returns:
        `true` if the array is empty or `null`
      Since:
        2.1

    - #### isEmpty

          public static boolean isEmpty(short[] array)

      Checks if an array of primitive shorts is empty or `null`.

      Parameters:
        `array` - the array to test
      Returns:
        `true` if the array is empty or `null`
      Since:
        2.1

    - #### isEmpty

          public static boolean isEmpty(char[] array)

      Checks if an array of primitive chars is empty or `null`.

      Parameters:
        `array` - the array to test
      Returns:
        `true` if the array is empty or `null`
      Since:
        2.1

    - #### isEmpty

          public static boolean isEmpty(byte[] array)

      Checks if an array of primitive bytes is empty or `null`.

      Parameters:
        `array` - the array to test
      Returns:
        `true` if the array is empty or `null`
      Since:
        2.1

    - #### isEmpty

          public static boolean isEmpty(double[] array)

      Checks if an array of primitive doubles is empty or `null`.

      Parameters:
        `array` - the array to test
      Returns:
        `true` if the array is empty or `null`
      Since:
        2.1

    - #### isEmpty

          public static boolean isEmpty(float[] array)

      Checks if an array of primitive floats is empty or `null`.

      Parameters:
        `array` - the array to test
      Returns:
        `true` if the array is empty or `null`
      Since:
        2.1

    - #### isEmpty

          public static boolean isEmpty(boolean[] array)

      Checks if an array of primitive booleans is empty or `null`.

      Parameters:
        `array` - the array to test
      Returns:
        `true` if the array is empty or `null`
      Since:
        2.1

    - #### isNotEmpty

          public static boolean isNotEmpty(java.lang.Object[] array)

      Checks if an array of Objects is not empty or not `null`.

      Parameters:
        `array` - the array to test
      Returns:
        `true` if the array is not empty or not `null`
      Since:
        2.5

    - #### isNotEmpty

          public static boolean isNotEmpty(long[] array)

      Checks if an array of primitive longs is not empty or not `null`.

      Parameters:
        `array` - the array to test
      Returns:
        `true` if the array is not empty or not `null`
      Since:
        2.5

    - #### isNotEmpty

          public static boolean isNotEmpty(int[] array)

      Checks if an array of primitive ints is not empty or not `null`.

      Parameters:
        `array` - the array to test
      Returns:
        `true` if the array is not empty or not `null`
      Since:
        2.5

    - #### isNotEmpty

          public static boolean isNotEmpty(short[] array)

      Checks if an array of primitive shorts is not empty or not `null`.

      Parameters:
        `array` - the array to test
      Returns:
        `true` if the array is not empty or not `null`
      Since:
        2.5

    - #### isNotEmpty

          public static boolean isNotEmpty(char[] array)

      Checks if an array of primitive chars is not empty or not `null`.

      Parameters:
        `array` - the array to test
      Returns:
        `true` if the array is not empty or not `null`
      Since:
        2.5

    - #### isNotEmpty

          public static boolean isNotEmpty(byte[] array)

      Checks if an array of primitive bytes is not empty or not `null`.

      Parameters:
        `array` - the array to test
      Returns:
        `true` if the array is not empty or not `null`
      Since:
        2.5

    - #### isNotEmpty

          public static boolean isNotEmpty(double[] array)

      Checks if an array of primitive doubles is not empty or not `null`.

      Parameters:
        `array` - the array to test
      Returns:
        `true` if the array is not empty or not `null`
      Since:
        2.5

    - #### isNotEmpty

          public static boolean isNotEmpty(float[] array)

      Checks if an array of primitive floats is not empty or not `null`.

      Parameters:
        `array` - the array to test
      Returns:
        `true` if the array is not empty or not `null`
      Since:
        2.5

    - #### isNotEmpty

          public static boolean isNotEmpty(boolean[] array)

      Checks if an array of primitive booleans is not empty or not `null`.

      Parameters:
        `array` - the array to test
      Returns:
        `true` if the array is not empty or not `null`
      Since:
        2.5

    - #### addAll

          public static java.lang.Object[] addAll(java.lang.Object[] array1,
                                                  java.lang.Object[] array2)

      Adds all the elements of the given arrays into a new array.

      The new array contains all of the element of `array1` followed by all of the elements `array2`. When an array is returned, it is always a new array.

           ArrayUtils.addAll(null, null)     = null
           ArrayUtils.addAll(array1, null)   = cloned copy of array1
           ArrayUtils.addAll(null, array2)   = cloned copy of array2
           ArrayUtils.addAll([], [])         = []
           ArrayUtils.addAll([null], [null]) = [null, null]
           ArrayUtils.addAll(["a", "b", "c"], ["1", "2", "3"]) = ["a", "b", "c", "1", "2", "3"]

      Parameters:
        `array1` - the first array whose elements are added to the new array, may be `null`
        `array2` - the second array whose elements are added to the new array, may be `null`
      Returns:
        The new array, `null` if both arrays are `null`. The type of the new array is the type of the first array, unless the first array is null, in which case the type is the same as the second array.
      Throws:
        `java.lang.IllegalArgumentException` - if the array types are incompatible
      Since:
        2.1

    - #### addAll

          public static boolean[] addAll(boolean[] array1,
                                         boolean[] array2)

      Adds all the elements of the given arrays into a new array.

      The new array contains all of the element of `array1` followed by all of the elements `array2`. When an array is returned, it is always a new array.

           ArrayUtils.addAll(array1, null)   = cloned copy of array1
           ArrayUtils.addAll(null, array2)   = cloned copy of array2
           ArrayUtils.addAll([], [])         = []

      Parameters:
        `array1` - the first array whose elements are added to the new array.
        `array2` - the second array whose elements are added to the new array.
      Returns:
        The new boolean[] array.
      Since:
        2.1

    - #### addAll

          public static char[] addAll(char[] array1,
                                      char[] array2)

      Adds all the elements of the given arrays into a new array.

      The new array contains all of the element of `array1` followed by all of the elements `array2`. When an array is returned, it is always a new array.

           ArrayUtils.addAll(array1, null)   = cloned copy of array1
           ArrayUtils.addAll(null, array2)   = cloned copy of array2
           ArrayUtils.addAll([], [])         = []

      Parameters:
        `array1` - the first array whose elements are added to the new array.
        `array2` - the second array whose elements are added to the new array.
      Returns:
        The new char[] array.
      Since:
        2.1

    - #### addAll

          public static byte[] addAll(byte[] array1,
                                      byte[] array2)

      Adds all the elements of the given arrays into a new array.

      The new array contains all of the element of `array1` followed by all of the elements `array2`. When an array is returned, it is always a new array.

           ArrayUtils.addAll(array1, null)   = cloned copy of array1
           ArrayUtils.addAll(null, array2)   = cloned copy of array2
           ArrayUtils.addAll([], [])         = []

      Parameters:
        `array1` - the first array whose elements are added to the new array.
        `array2` - the second array whose elements are added to the new array.
      Returns:
        The new byte[] array.
      Since:
        2.1

    - #### addAll

          public static short[] addAll(short[] array1,
                                       short[] array2)

      Adds all the elements of the given arrays into a new array.

      The new array contains all of the element of `array1` followed by all of the elements `array2`. When an array is returned, it is always a new array.

           ArrayUtils.addAll(array1, null)   = cloned copy of array1
           ArrayUtils.addAll(null, array2)   = cloned copy of array2
           ArrayUtils.addAll([], [])         = []

      Parameters:
        `array1` - the first array whose elements are added to the new array.
        `array2` - the second array whose elements are added to the new array.
      Returns:
        The new short[] array.
      Since:
        2.1

    - #### addAll

          public static int[] addAll(int[] array1,
                                     int[] array2)

      Adds all the elements of the given arrays into a new array.

      The new array contains all of the element of `array1` followed by all of the elements `array2`. When an array is returned, it is always a new array.

           ArrayUtils.addAll(array1, null)   = cloned copy of array1
           ArrayUtils.addAll(null, array2)   = cloned copy of array2
           ArrayUtils.addAll([], [])         = []

      Parameters:
        `array1` - the first array whose elements are added to the new array.
        `array2` - the second array whose elements are added to the new array.
      Returns:
        The new int[] array.
      Since:
        2.1

    - #### addAll

          public static long[] addAll(long[] array1,
                                      long[] array2)

      Adds all the elements of the given arrays into a new array.

      The new array contains all of the element of `array1` followed by all of the elements `array2`. When an array is returned, it is always a new array.

           ArrayUtils.addAll(array1, null)   = cloned copy of array1
           ArrayUtils.addAll(null, array2)   = cloned copy of array2
           ArrayUtils.addAll([], [])         = []

      Parameters:
        `array1` - the first array whose elements are added to the new array.
        `array2` - the second array whose elements are added to the new array.
      Returns:
        The new long[] array.
      Since:
        2.1

    - #### addAll

          public static float[] addAll(float[] array1,
                                       float[] array2)

      Adds all the elements of the given arrays into a new array.

      The new array contains all of the element of `array1` followed by all of the elements `array2`. When an array is returned, it is always a new array.

           ArrayUtils.addAll(array1, null)   = cloned copy of array1
           ArrayUtils.addAll(null, array2)   = cloned copy of array2
           ArrayUtils.addAll([], [])         = []

      Parameters:
        `array1` - the first array whose elements are added to the new array.
        `array2` - the second array whose elements are added to the new array.
      Returns:
        The new float[] array.
      Since:
        2.1

    - #### addAll

          public static double[] addAll(double[] array1,
                                        double[] array2)

      Adds all the elements of the given arrays into a new array.

      The new array contains all of the element of `array1` followed by all of the elements `array2`. When an array is returned, it is always a new array.

           ArrayUtils.addAll(array1, null)   = cloned copy of array1
           ArrayUtils.addAll(null, array2)   = cloned copy of array2
           ArrayUtils.addAll([], [])         = []

      Parameters:
        `array1` - the first array whose elements are added to the new array.
        `array2` - the second array whose elements are added to the new array.
      Returns:
        The new double[] array.
      Since:
        2.1

    - #### add

          public static java.lang.Object[] add(java.lang.Object[] array,
                                               java.lang.Object element)

      Copies the given array and adds the given element at the end of the new array.

      The new array contains the same elements of the input array plus the given element in the last position. The component type of the new array is the same as that of the input array.

      If the input array is `null`, a new one element array is returned whose component type is the same as the element, unless the element itself is null, in which case the return type is Object[]

           ArrayUtils.add(null, null)      = [null]
           ArrayUtils.add(null, "a")       = ["a"]
           ArrayUtils.add(["a"], null)     = ["a", null]
           ArrayUtils.add(["a"], "b")      = ["a", "b"]
           ArrayUtils.add(["a", "b"], "c") = ["a", "b", "c"]

      Parameters:
        `array` - the array to "add" the element to, may be `null`
        `element` - the object to add, may be `null`
      Returns:
        A new array containing the existing elements plus the new element The returned array type will be that of the input array (unless null), in which case it will have the same type as the element.
      Since:
        2.1

    - #### add

          public static boolean[] add(boolean[] array,
                                      boolean element)

      Copies the given array and adds the given element at the end of the new array.

      The new array contains the same elements of the input array plus the given element in the last position. The component type of the new array is the same as that of the input array.

      If the input array is `null`, a new one element array is returned whose component type is the same as the element.

           ArrayUtils.add(null, true)          = [true]
           ArrayUtils.add([true], false)       = [true, false]
           ArrayUtils.add([true, false], true) = [true, false, true]

      Parameters:
        `array` - the array to copy and add the element to, may be `null`
        `element` - the object to add at the last index of the new array
      Returns:
        A new array containing the existing elements plus the new element
      Since:
        2.1

    - #### add

          public static byte[] add(byte[] array,
                                   byte element)

      Copies the given array and adds the given element at the end of the new array.

      The new array contains the same elements of the input array plus the given element in the last position. The component type of the new array is the same as that of the input array.

      If the input array is `null`, a new one element array is returned whose component type is the same as the element.

           ArrayUtils.add(null, 0)   = [0]
           ArrayUtils.add([1], 0)    = [1, 0]
           ArrayUtils.add([1, 0], 1) = [1, 0, 1]

      Parameters:
        `array` - the array to copy and add the element to, may be `null`
        `element` - the object to add at the last index of the new array
      Returns:
        A new array containing the existing elements plus the new element
      Since:
        2.1

    - #### add

          public static char[] add(char[] array,
                                   char element)

      Copies the given array and adds the given element at the end of the new array.

      The new array contains the same elements of the input array plus the given element in the last position. The component type of the new array is the same as that of the input array.

      If the input array is `null`, a new one element array is returned whose component type is the same as the element.

           ArrayUtils.add(null, '0')       = ['0']
           ArrayUtils.add(['1'], '0')      = ['1', '0']
           ArrayUtils.add(['1', '0'], '1') = ['1', '0', '1']

      Parameters:
        `array` - the array to copy and add the element to, may be `null`
        `element` - the object to add at the last index of the new array
      Returns:
        A new array containing the existing elements plus the new element
      Since:
        2.1

    - #### add

          public static double[] add(double[] array,
                                     double element)

      Copies the given array and adds the given element at the end of the new array.

      The new array contains the same elements of the input array plus the given element in the last position. The component type of the new array is the same as that of the input array.

      If the input array is `null`, a new one element array is returned whose component type is the same as the element.

           ArrayUtils.add(null, 0)   = [0]
           ArrayUtils.add([1], 0)    = [1, 0]
           ArrayUtils.add([1, 0], 1) = [1, 0, 1]

      Parameters:
        `array` - the array to copy and add the element to, may be `null`
        `element` - the object to add at the last index of the new array
      Returns:
        A new array containing the existing elements plus the new element
      Since:
        2.1

    - #### add

          public static float[] add(float[] array,
                                    float element)

      Copies the given array and adds the given element at the end of the new array.

      The new array contains the same elements of the input array plus the given element in the last position. The component type of the new array is the same as that of the input array.

      If the input array is `null`, a new one element array is returned whose component type is the same as the element.

           ArrayUtils.add(null, 0)   = [0]
           ArrayUtils.add([1], 0)    = [1, 0]
           ArrayUtils.add([1, 0], 1) = [1, 0, 1]

      Parameters:
        `array` - the array to copy and add the element to, may be `null`
        `element` - the object to add at the last index of the new array
      Returns:
        A new array containing the existing elements plus the new element
      Since:
        2.1

    - #### add

          public static int[] add(int[] array,
                                  int element)

      Copies the given array and adds the given element at the end of the new array.

      The new array contains the same elements of the input array plus the given element in the last position. The component type of the new array is the same as that of the input array.

      If the input array is `null`, a new one element array is returned whose component type is the same as the element.

           ArrayUtils.add(null, 0)   = [0]
           ArrayUtils.add([1], 0)    = [1, 0]
           ArrayUtils.add([1, 0], 1) = [1, 0, 1]

      Parameters:
        `array` - the array to copy and add the element to, may be `null`
        `element` - the object to add at the last index of the new array
      Returns:
        A new array containing the existing elements plus the new element
      Since:
        2.1

    - #### add

          public static long[] add(long[] array,
                                   long element)

      Copies the given array and adds the given element at the end of the new array.

      The new array contains the same elements of the input array plus the given element in the last position. The component type of the new array is the same as that of the input array.

      If the input array is `null`, a new one element array is returned whose component type is the same as the element.

           ArrayUtils.add(null, 0)   = [0]
           ArrayUtils.add([1], 0)    = [1, 0]
           ArrayUtils.add([1, 0], 1) = [1, 0, 1]

      Parameters:
        `array` - the array to copy and add the element to, may be `null`
        `element` - the object to add at the last index of the new array
      Returns:
        A new array containing the existing elements plus the new element
      Since:
        2.1

    - #### add

          public static short[] add(short[] array,
                                    short element)

      Copies the given array and adds the given element at the end of the new array.

      The new array contains the same elements of the input array plus the given element in the last position. The component type of the new array is the same as that of the input array.

      If the input array is `null`, a new one element array is returned whose component type is the same as the element.

           ArrayUtils.add(null, 0)   = [0]
           ArrayUtils.add([1], 0)    = [1, 0]
           ArrayUtils.add([1, 0], 1) = [1, 0, 1]

      Parameters:
        `array` - the array to copy and add the element to, may be `null`
        `element` - the object to add at the last index of the new array
      Returns:
        A new array containing the existing elements plus the new element
      Since:
        2.1

    - #### add

          public static java.lang.Object[] add(java.lang.Object[] array,
                                               int index,
                                               java.lang.Object element)

      Inserts the specified element at the specified position in the array. Shifts the element currently at that position (if any) and any subsequent elements to the right (adds one to their indices).

      This method returns a new array with the same elements of the input array plus the given element on the specified position. The component type of the returned array is always the same as that of the input array.

      If the input array is `null`, a new one element array is returned whose component type is the same as the element.

           ArrayUtils.add(null, 0, null)      = [null]
           ArrayUtils.add(null, 0, "a")       = ["a"]
           ArrayUtils.add(["a"], 1, null)     = ["a", null]
           ArrayUtils.add(["a"], 1, "b")      = ["a", "b"]
           ArrayUtils.add(["a", "b"], 3, "c") = ["a", "b", "c"]

      Parameters:
        `array` - the array to add the element to, may be `null`
        `index` - the position of the new object
        `element` - the object to add
      Returns:
        A new array containing the existing elements and the new element
      Throws:
        `java.lang.IndexOutOfBoundsException` - if the index is out of range (index < 0 || index > array.length).

    - #### add

          public static boolean[] add(boolean[] array,
                                      int index,
                                      boolean element)

      Inserts the specified element at the specified position in the array. Shifts the element currently at that position (if any) and any subsequent elements to the right (adds one to their indices).

      This method returns a new array with the same elements of the input array plus the given element on the specified position. The component type of the returned array is always the same as that of the input array.

      If the input array is `null`, a new one element array is returned whose component type is the same as the element.

           ArrayUtils.add(null, 0, true)          = [true]
           ArrayUtils.add([true], 0, false)       = [false, true]
           ArrayUtils.add([false], 1, true)       = [false, true]
           ArrayUtils.add([true, false], 1, true) = [true, true, false]

      Parameters:
        `array` - the array to add the element to, may be `null`
        `index` - the position of the new object
        `element` - the object to add
      Returns:
        A new array containing the existing elements and the new element
      Throws:
        `java.lang.IndexOutOfBoundsException` - if the index is out of range (index < 0 || index > array.length).

    - #### add

          public static char[] add(char[] array,
                                   int index,
                                   char element)

      Inserts the specified element at the specified position in the array. Shifts the element currently at that position (if any) and any subsequent elements to the right (adds one to their indices).

      This method returns a new array with the same elements of the input array plus the given element on the specified position. The component type of the returned array is always the same as that of the input array.

      If the input array is `null`, a new one element array is returned whose component type is the same as the element.

           ArrayUtils.add(null, 0, 'a')            = ['a']
           ArrayUtils.add(['a'], 0, 'b')           = ['b', 'a']
           ArrayUtils.add(['a', 'b'], 0, 'c')      = ['c', 'a', 'b']
           ArrayUtils.add(['a', 'b'], 1, 'k')      = ['a', 'k', 'b']
           ArrayUtils.add(['a', 'b', 'c'], 1, 't') = ['a', 't', 'b', 'c']

      Parameters:
        `array` - the array to add the element to, may be `null`
        `index` - the position of the new object
        `element` - the object to add
      Returns:
        A new array containing the existing elements and the new element
      Throws:
        `java.lang.IndexOutOfBoundsException` - if the index is out of range (index < 0 || index > array.length).

    - #### add

          public static byte[] add(byte[] array,
                                   int index,
                                   byte element)

      Inserts the specified element at the specified position in the array. Shifts the element currently at that position (if any) and any subsequent elements to the right (adds one to their indices).

      This method returns a new array with the same elements of the input array plus the given element on the specified position. The component type of the returned array is always the same as that of the input array.

      If the input array is `null`, a new one element array is returned whose component type is the same as the element.

           ArrayUtils.add([1], 0, 2)         = [2, 1]
           ArrayUtils.add([2, 6], 2, 3)      = [2, 6, 3]
           ArrayUtils.add([2, 6], 0, 1)      = [1, 2, 6]
           ArrayUtils.add([2, 6, 3], 2, 1)   = [2, 6, 1, 3]

      Parameters:
        `array` - the array to add the element to, may be `null`
        `index` - the position of the new object
        `element` - the object to add
      Returns:
        A new array containing the existing elements and the new element
      Throws:
        `java.lang.IndexOutOfBoundsException` - if the index is out of range (index < 0 || index > array.length).

    - #### add

          public static short[] add(short[] array,
                                    int index,
                                    short element)

      Inserts the specified element at the specified position in the array. Shifts the element currently at that position (if any) and any subsequent elements to the right (adds one to their indices).

      This method returns a new array with the same elements of the input array plus the given element on the specified position. The component type of the returned array is always the same as that of the input array.

      If the input array is `null`, a new one element array is returned whose component type is the same as the element.

           ArrayUtils.add([1], 0, 2)         = [2, 1]
           ArrayUtils.add([2, 6], 2, 10)     = [2, 6, 10]
           ArrayUtils.add([2, 6], 0, -4)     = [-4, 2, 6]
           ArrayUtils.add([2, 6, 3], 2, 1)   = [2, 6, 1, 3]

      Parameters:
        `array` - the array to add the element to, may be `null`
        `index` - the position of the new object
        `element` - the object to add
      Returns:
        A new array containing the existing elements and the new element
      Throws:
        `java.lang.IndexOutOfBoundsException` - if the index is out of range (index < 0 || index > array.length).

    - #### add

          public static int[] add(int[] array,
                                  int index,
                                  int element)

      Inserts the specified element at the specified position in the array. Shifts the element currently at that position (if any) and any subsequent elements to the right (adds one to their indices).

      This method returns a new array with the same elements of the input array plus the given element on the specified position. The component type of the returned array is always the same as that of the input array.

      If the input array is `null`, a new one element array is returned whose component type is the same as the element.

           ArrayUtils.add([1], 0, 2)         = [2, 1]
           ArrayUtils.add([2, 6], 2, 10)     = [2, 6, 10]
           ArrayUtils.add([2, 6], 0, -4)     = [-4, 2, 6]
           ArrayUtils.add([2, 6, 3], 2, 1)   = [2, 6, 1, 3]

      Parameters:
        `array` - the array to add the element to, may be `null`
        `index` - the position of the new object
        `element` - the object to add
      Returns:
        A new array containing the existing elements and the new element
      Throws:
        `java.lang.IndexOutOfBoundsException` - if the index is out of range (index < 0 || index > array.length).

    - #### add

          public static long[] add(long[] array,
                                   int index,
                                   long element)

      Inserts the specified element at the specified position in the array. Shifts the element currently at that position (if any) and any subsequent elements to the right (adds one to their indices).

      This method returns a new array with the same elements of the input array plus the given element on the specified position. The component type of the returned array is always the same as that of the input array.

      If the input array is `null`, a new one element array is returned whose component type is the same as the element.

           ArrayUtils.add([1L], 0, 2L)           = [2L, 1L]
           ArrayUtils.add([2L, 6L], 2, 10L)      = [2L, 6L, 10L]
           ArrayUtils.add([2L, 6L], 0, -4L)      = [-4L, 2L, 6L]
           ArrayUtils.add([2L, 6L, 3L], 2, 1L)   = [2L, 6L, 1L, 3L]

      Parameters:
        `array` - the array to add the element to, may be `null`
        `index` - the position of the new object
        `element` - the object to add
      Returns:
        A new array containing the existing elements and the new element
      Throws:
        `java.lang.IndexOutOfBoundsException` - if the index is out of range (index < 0 || index > array.length).

    - #### add

          public static float[] add(float[] array,
                                    int index,
                                    float element)

      Inserts the specified element at the specified position in the array. Shifts the element currently at that position (if any) and any subsequent elements to the right (adds one to their indices).

      This method returns a new array with the same elements of the input array plus the given element on the specified position. The component type of the returned array is always the same as that of the input array.

      If the input array is `null`, a new one element array is returned whose component type is the same as the element.

           ArrayUtils.add([1.1f], 0, 2.2f)               = [2.2f, 1.1f]
           ArrayUtils.add([2.3f, 6.4f], 2, 10.5f)        = [2.3f, 6.4f, 10.5f]
           ArrayUtils.add([2.6f, 6.7f], 0, -4.8f)        = [-4.8f, 2.6f, 6.7f]
           ArrayUtils.add([2.9f, 6.0f, 0.3f], 2, 1.0f)   = [2.9f, 6.0f, 1.0f, 0.3f]

      Parameters:
        `array` - the array to add the element to, may be `null`
        `index` - the position of the new object
        `element` - the object to add
      Returns:
        A new array containing the existing elements and the new element
      Throws:
        `java.lang.IndexOutOfBoundsException` - if the index is out of range (index < 0 || index > array.length).

    - #### add

          public static double[] add(double[] array,
                                     int index,
                                     double element)

      Inserts the specified element at the specified position in the array. Shifts the element currently at that position (if any) and any subsequent elements to the right (adds one to their indices).

      This method returns a new array with the same elements of the input array plus the given element on the specified position. The component type of the returned array is always the same as that of the input array.

      If the input array is `null`, a new one element array is returned whose component type is the same as the element.

           ArrayUtils.add([1.1], 0, 2.2)              = [2.2, 1.1]
           ArrayUtils.add([2.3, 6.4], 2, 10.5)        = [2.3, 6.4, 10.5]
           ArrayUtils.add([2.6, 6.7], 0, -4.8)        = [-4.8, 2.6, 6.7]
           ArrayUtils.add([2.9, 6.0, 0.3], 2, 1.0)    = [2.9, 6.0, 1.0, 0.3]

      Parameters:
        `array` - the array to add the element to, may be `null`
        `index` - the position of the new object
        `element` - the object to add
      Returns:
        A new array containing the existing elements and the new element
      Throws:
        `java.lang.IndexOutOfBoundsException` - if the index is out of range (index < 0 || index > array.length).

    - #### remove

          public static java.lang.Object[] remove(java.lang.Object[] array,
                                                  int index)

      Removes the element at the specified position from the specified array. All subsequent elements are shifted to the left (substracts one from their indices).

      This method returns a new array with the same elements of the input array except the element on the specified position. The component type of the returned array is always the same as that of the input array.

      If the input array is `null`, an IndexOutOfBoundsException will be thrown, because in that case no valid index can be specified.

           ArrayUtils.remove(["a"], 0)           = []
           ArrayUtils.remove(["a", "b"], 0)      = ["b"]
           ArrayUtils.remove(["a", "b"], 1)      = ["a"]
           ArrayUtils.remove(["a", "b", "c"], 1) = ["a", "c"]

      Parameters:
        `array` - the array to remove the element from, may not be `null`
        `index` - the position of the element to be removed
      Returns:
        A new array containing the existing elements except the element at the specified position.
      Throws:
        `java.lang.IndexOutOfBoundsException` - if the index is out of range (index < 0 || index >= array.length), or if the array is `null`.
      Since:
        2.1

    - #### removeElement

          public static java.lang.Object[] removeElement(java.lang.Object[] array,
                                                         java.lang.Object element)

      Removes the first occurrence of the specified element from the specified array. All subsequent elements are shifted to the left (substracts one from their indices). If the array doesn't contains such an element, no elements are removed from the array.

      This method returns a new array with the same elements of the input array except the first occurrence of the specified element. The component type of the returned array is always the same as that of the input array.

           ArrayUtils.removeElement(null, "a")            = null
           ArrayUtils.removeElement([], "a")              = []
           ArrayUtils.removeElement(["a"], "b")           = ["a"]
           ArrayUtils.removeElement(["a", "b"], "a")      = ["b"]
           ArrayUtils.removeElement(["a", "b", "a"], "a") = ["b", "a"]

      Parameters:
        `array` - the array to remove the element from, may be `null`
        `element` - the element to be removed
      Returns:
        A new array containing the existing elements except the first occurrence of the specified element.
      Since:
        2.1

    - #### remove

          public static boolean[] remove(boolean[] array,
                                         int index)

      Removes the element at the specified position from the specified array. All subsequent elements are shifted to the left (substracts one from their indices).

      This method returns a new array with the same elements of the input array except the element on the specified position. The component type of the returned array is always the same as that of the input array.

      If the input array is `null`, an IndexOutOfBoundsException will be thrown, because in that case no valid index can be specified.

           ArrayUtils.remove([true], 0)              = []
           ArrayUtils.remove([true, false], 0)       = [false]
           ArrayUtils.remove([true, false], 1)       = [true]
           ArrayUtils.remove([true, true, false], 1) = [true, false]

      Parameters:
        `array` - the array to remove the element from, may not be `null`
        `index` - the position of the element to be removed
      Returns:
        A new array containing the existing elements except the element at the specified position.
      Throws:
        `java.lang.IndexOutOfBoundsException` - if the index is out of range (index < 0 || index >= array.length), or if the array is `null`.
      Since:
        2.1

    - #### removeElement

          public static boolean[] removeElement(boolean[] array,
                                                boolean element)

      Removes the first occurrence of the specified element from the specified array. All subsequent elements are shifted to the left (substracts one from their indices). If the array doesn't contains such an element, no elements are removed from the array.

      This method returns a new array with the same elements of the input array except the first occurrence of the specified element. The component type of the returned array is always the same as that of the input array.

           ArrayUtils.removeElement(null, true)                = null
           ArrayUtils.removeElement([], true)                  = []
           ArrayUtils.removeElement([true], false)             = [true]
           ArrayUtils.removeElement([true, false], false)      = [true]
           ArrayUtils.removeElement([true, false, true], true) = [false, true]

      Parameters:
        `array` - the array to remove the element from, may be `null`
        `element` - the element to be removed
      Returns:
        A new array containing the existing elements except the first occurrence of the specified element.
      Since:
        2.1

    - #### remove

          public static byte[] remove(byte[] array,
                                      int index)

      Removes the element at the specified position from the specified array. All subsequent elements are shifted to the left (substracts one from their indices).

      This method returns a new array with the same elements of the input array except the element on the specified position. The component type of the returned array is always the same as that of the input array.

      If the input array is `null`, an IndexOutOfBoundsException will be thrown, because in that case no valid index can be specified.

           ArrayUtils.remove([1], 0)          = []
           ArrayUtils.remove([1, 0], 0)       = [0]
           ArrayUtils.remove([1, 0], 1)       = [1]
           ArrayUtils.remove([1, 0, 1], 1)    = [1, 1]

      Parameters:
        `array` - the array to remove the element from, may not be `null`
        `index` - the position of the element to be removed
      Returns:
        A new array containing the existing elements except the element at the specified position.
      Throws:
        `java.lang.IndexOutOfBoundsException` - if the index is out of range (index < 0 || index >= array.length), or if the array is `null`.
      Since:
        2.1

    - #### removeElement

          public static byte[] removeElement(byte[] array,
                                             byte element)

      Removes the first occurrence of the specified element from the specified array. All subsequent elements are shifted to the left (substracts one from their indices). If the array doesn't contains such an element, no elements are removed from the array.

      This method returns a new array with the same elements of the input array except the first occurrence of the specified element. The component type of the returned array is always the same as that of the input array.

           ArrayUtils.removeElement(null, 1)        = null
           ArrayUtils.removeElement([], 1)          = []
           ArrayUtils.removeElement([1], 0)         = [1]
           ArrayUtils.removeElement([1, 0], 0)      = [1]
           ArrayUtils.removeElement([1, 0, 1], 1)   = [0, 1]

      Parameters:
        `array` - the array to remove the element from, may be `null`
        `element` - the element to be removed
      Returns:
        A new array containing the existing elements except the first occurrence of the specified element.
      Since:
        2.1

    - #### remove

          public static char[] remove(char[] array,
                                      int index)

      Removes the element at the specified position from the specified array. All subsequent elements are shifted to the left (substracts one from their indices).

      This method returns a new array with the same elements of the input array except the element on the specified position. The component type of the returned array is always the same as that of the input array.

      If the input array is `null`, an IndexOutOfBoundsException will be thrown, because in that case no valid index can be specified.

           ArrayUtils.remove(['a'], 0)           = []
           ArrayUtils.remove(['a', 'b'], 0)      = ['b']
           ArrayUtils.remove(['a', 'b'], 1)      = ['a']
           ArrayUtils.remove(['a', 'b', 'c'], 1) = ['a', 'c']

      Parameters:
        `array` - the array to remove the element from, may not be `null`
        `index` - the position of the element to be removed
      Returns:
        A new array containing the existing elements except the element at the specified position.
      Throws:
        `java.lang.IndexOutOfBoundsException` - if the index is out of range (index < 0 || index >= array.length), or if the array is `null`.
      Since:
        2.1

    - #### removeElement

          public static char[] removeElement(char[] array,
                                             char element)

      Removes the first occurrence of the specified element from the specified array. All subsequent elements are shifted to the left (substracts one from their indices). If the array doesn't contains such an element, no elements are removed from the array.

      This method returns a new array with the same elements of the input array except the first occurrence of the specified element. The component type of the returned array is always the same as that of the input array.

           ArrayUtils.removeElement(null, 'a')            = null
           ArrayUtils.removeElement([], 'a')              = []
           ArrayUtils.removeElement(['a'], 'b')           = ['a']
           ArrayUtils.removeElement(['a', 'b'], 'a')      = ['b']
           ArrayUtils.removeElement(['a', 'b', 'a'], 'a') = ['b', 'a']

      Parameters:
        `array` - the array to remove the element from, may be `null`
        `element` - the element to be removed
      Returns:
        A new array containing the existing elements except the first occurrence of the specified element.
      Since:
        2.1

    - #### remove

          public static double[] remove(double[] array,
                                        int index)

      Removes the element at the specified position from the specified array. All subsequent elements are shifted to the left (substracts one from their indices).

      This method returns a new array with the same elements of the input array except the element on the specified position. The component type of the returned array is always the same as that of the input array.

      If the input array is `null`, an IndexOutOfBoundsException will be thrown, because in that case no valid index can be specified.

           ArrayUtils.remove([1.1], 0)           = []
           ArrayUtils.remove([2.5, 6.0], 0)      = [6.0]
           ArrayUtils.remove([2.5, 6.0], 1)      = [2.5]
           ArrayUtils.remove([2.5, 6.0, 3.8], 1) = [2.5, 3.8]

      Parameters:
        `array` - the array to remove the element from, may not be `null`
        `index` - the position of the element to be removed
      Returns:
        A new array containing the existing elements except the element at the specified position.
      Throws:
        `java.lang.IndexOutOfBoundsException` - if the index is out of range (index < 0 || index >= array.length), or if the array is `null`.
      Since:
        2.1

    - #### removeElement

          public static double[] removeElement(double[] array,
                                               double element)

      Removes the first occurrence of the specified element from the specified array. All subsequent elements are shifted to the left (substracts one from their indices). If the array doesn't contains such an element, no elements are removed from the array.

      This method returns a new array with the same elements of the input array except the first occurrence of the specified element. The component type of the returned array is always the same as that of the input array.

           ArrayUtils.removeElement(null, 1.1)            = null
           ArrayUtils.removeElement([], 1.1)              = []
           ArrayUtils.removeElement([1.1], 1.2)           = [1.1]
           ArrayUtils.removeElement([1.1, 2.3], 1.1)      = [2.3]
           ArrayUtils.removeElement([1.1, 2.3, 1.1], 1.1) = [2.3, 1.1]

      Parameters:
        `array` - the array to remove the element from, may be `null`
        `element` - the element to be removed
      Returns:
        A new array containing the existing elements except the first occurrence of the specified element.
      Since:
        2.1

    - #### remove

          public static float[] remove(float[] array,
                                       int index)

      Removes the element at the specified position from the specified array. All subsequent elements are shifted to the left (substracts one from their indices).

      This method returns a new array with the same elements of the input array except the element on the specified position. The component type of the returned array is always the same as that of the input array.

      If the input array is `null`, an IndexOutOfBoundsException will be thrown, because in that case no valid index can be specified.

           ArrayUtils.remove([1.1], 0)           = []
           ArrayUtils.remove([2.5, 6.0], 0)      = [6.0]
           ArrayUtils.remove([2.5, 6.0], 1)      = [2.5]
           ArrayUtils.remove([2.5, 6.0, 3.8], 1) = [2.5, 3.8]

      Parameters:
        `array` - the array to remove the element from, may not be `null`
        `index` - the position of the element to be removed
      Returns:
        A new array containing the existing elements except the element at the specified position.
      Throws:
        `java.lang.IndexOutOfBoundsException` - if the index is out of range (index < 0 || index >= array.length), or if the array is `null`.
      Since:
        2.1

    - #### removeElement

          public static float[] removeElement(float[] array,
                                              float element)

      Removes the first occurrence of the specified element from the specified array. All subsequent elements are shifted to the left (substracts one from their indices). If the array doesn't contains such an element, no elements are removed from the array.

      This method returns a new array with the same elements of the input array except the first occurrence of the specified element. The component type of the returned array is always the same as that of the input array.

           ArrayUtils.removeElement(null, 1.1)            = null
           ArrayUtils.removeElement([], 1.1)              = []
           ArrayUtils.removeElement([1.1], 1.2)           = [1.1]
           ArrayUtils.removeElement([1.1, 2.3], 1.1)      = [2.3]
           ArrayUtils.removeElement([1.1, 2.3, 1.1], 1.1) = [2.3, 1.1]

      Parameters:
        `array` - the array to remove the element from, may be `null`
        `element` - the element to be removed
      Returns:
        A new array containing the existing elements except the first occurrence of the specified element.
      Since:
        2.1

    - #### remove

          public static int[] remove(int[] array,
                                     int index)

      Removes the element at the specified position from the specified array. All subsequent elements are shifted to the left (substracts one from their indices).

      This method returns a new array with the same elements of the input array except the element on the specified position. The component type of the returned array is always the same as that of the input array.

      If the input array is `null`, an IndexOutOfBoundsException will be thrown, because in that case no valid index can be specified.

           ArrayUtils.remove([1], 0)         = []
           ArrayUtils.remove([2, 6], 0)      = [6]
           ArrayUtils.remove([2, 6], 1)      = [2]
           ArrayUtils.remove([2, 6, 3], 1)   = [2, 3]

      Parameters:
        `array` - the array to remove the element from, may not be `null`
        `index` - the position of the element to be removed
      Returns:
        A new array containing the existing elements except the element at the specified position.
      Throws:
        `java.lang.IndexOutOfBoundsException` - if the index is out of range (index < 0 || index >= array.length), or if the array is `null`.
      Since:
        2.1

    - #### removeElement

          public static int[] removeElement(int[] array,
                                            int element)

      Removes the first occurrence of the specified element from the specified array. All subsequent elements are shifted to the left (substracts one from their indices). If the array doesn't contains such an element, no elements are removed from the array.

      This method returns a new array with the same elements of the input array except the first occurrence of the specified element. The component type of the returned array is always the same as that of the input array.

           ArrayUtils.removeElement(null, 1)      = null
           ArrayUtils.removeElement([], 1)        = []
           ArrayUtils.removeElement([1], 2)       = [1]
           ArrayUtils.removeElement([1, 3], 1)    = [3]
           ArrayUtils.removeElement([1, 3, 1], 1) = [3, 1]

      Parameters:
        `array` - the array to remove the element from, may be `null`
        `element` - the element to be removed
      Returns:
        A new array containing the existing elements except the first occurrence of the specified element.
      Since:
        2.1

    - #### remove

          public static long[] remove(long[] array,
                                      int index)

      Removes the element at the specified position from the specified array. All subsequent elements are shifted to the left (substracts one from their indices).

      This method returns a new array with the same elements of the input array except the element on the specified position. The component type of the returned array is always the same as that of the input array.

      If the input array is `null`, an IndexOutOfBoundsException will be thrown, because in that case no valid index can be specified.

           ArrayUtils.remove([1], 0)         = []
           ArrayUtils.remove([2, 6], 0)      = [6]
           ArrayUtils.remove([2, 6], 1)      = [2]
           ArrayUtils.remove([2, 6, 3], 1)   = [2, 3]

      Parameters:
        `array` - the array to remove the element from, may not be `null`
        `index` - the position of the element to be removed
      Returns:
        A new array containing the existing elements except the element at the specified position.
      Throws:
        `java.lang.IndexOutOfBoundsException` - if the index is out of range (index < 0 || index >= array.length), or if the array is `null`.
      Since:
        2.1

    - #### removeElement

          public static long[] removeElement(long[] array,
                                             long element)

      Removes the first occurrence of the specified element from the specified array. All subsequent elements are shifted to the left (substracts one from their indices). If the array doesn't contains such an element, no elements are removed from the array.

      This method returns a new array with the same elements of the input array except the first occurrence of the specified element. The component type of the returned array is always the same as that of the input array.

           ArrayUtils.removeElement(null, 1)      = null
           ArrayUtils.removeElement([], 1)        = []
           ArrayUtils.removeElement([1], 2)       = [1]
           ArrayUtils.removeElement([1, 3], 1)    = [3]
           ArrayUtils.removeElement([1, 3, 1], 1) = [3, 1]

      Parameters:
        `array` - the array to remove the element from, may be `null`
        `element` - the element to be removed
      Returns:
        A new array containing the existing elements except the first occurrence of the specified element.
      Since:
        2.1

    - #### remove

          public static short[] remove(short[] array,
                                       int index)

      Removes the element at the specified position from the specified array. All subsequent elements are shifted to the left (substracts one from their indices).

      This method returns a new array with the same elements of the input array except the element on the specified position. The component type of the returned array is always the same as that of the input array.

      If the input array is `null`, an IndexOutOfBoundsException will be thrown, because in that case no valid index can be specified.

           ArrayUtils.remove([1], 0)         = []
           ArrayUtils.remove([2, 6], 0)      = [6]
           ArrayUtils.remove([2, 6], 1)      = [2]
           ArrayUtils.remove([2, 6, 3], 1)   = [2, 3]

      Parameters:
        `array` - the array to remove the element from, may not be `null`
        `index` - the position of the element to be removed
      Returns:
        A new array containing the existing elements except the element at the specified position.
      Throws:
        `java.lang.IndexOutOfBoundsException` - if the index is out of range (index < 0 || index >= array.length), or if the array is `null`.
      Since:
        2.1

    - #### removeElement

          public static short[] removeElement(short[] array,
                                              short element)

      Removes the first occurrence of the specified element from the specified array. All subsequent elements are shifted to the left (substracts one from their indices). If the array doesn't contains such an element, no elements are removed from the array.

      This method returns a new array with the same elements of the input array except the first occurrence of the specified element. The component type of the returned array is always the same as that of the input array.

           ArrayUtils.removeElement(null, 1)      = null
           ArrayUtils.removeElement([], 1)        = []
           ArrayUtils.removeElement([1], 2)       = [1]
           ArrayUtils.removeElement([1, 3], 1)    = [3]
           ArrayUtils.removeElement([1, 3, 1], 1) = [3, 1]

      Parameters:
        `array` - the array to remove the element from, may be `null`
        `element` - the element to be removed
      Returns:
        A new array containing the existing elements except the first occurrence of the specified element.
      Since:
        2.1

Copyright © 2001-2019 - Apache Software Foundation