ArrayUtil (bap-util_API

java.lang.Object
- bap.util.ArrayUtil

```
public class ArrayUtil
extends java.lang.Object
```
功能描述: 对数组的一些通用操作，全部来自apache commons lang 2.5的ArrayUtils
创建日期: 2014-12-30 下午5:42:03
开发环境: JDK6.0

Field Summary

Fields
Modifier and Type	Field and Description
`static boolean[]`	`EMPTY_BOOLEAN_ARRAY` 一个空的不可变的 `boolean` 数组。
`static java.lang.Boolean[]`	`EMPTY_BOOLEAN_OBJECT_ARRAY` 一个空的不可变的 `Boolean` 数组。
`static byte[]`	`EMPTY_BYTE_ARRAY` 一个空的不可变的 `byte` 数组。
`static java.lang.Byte[]`	`EMPTY_BYTE_OBJECT_ARRAY` 一个空的不可变的 `Byte` 数组。
`static char[]`	`EMPTY_CHAR_ARRAY` 一个空的不可变的 `char` 数组。
`static java.lang.Character[]`	`EMPTY_CHARACTER_OBJECT_ARRAY` 一个空的不可变的 `Character` 数组。
`static java.lang.Class[]`	`EMPTY_CLASS_ARRAY` 一个空的不可变的 `Class` 数组。
`static double[]`	`EMPTY_DOUBLE_ARRAY` 一个空的不可变的 `double` 数组。
`static java.lang.Double[]`	`EMPTY_DOUBLE_OBJECT_ARRAY` 一个空的不可变的 `Double` 数组。
`static float[]`	`EMPTY_FLOAT_ARRAY` 一个空的不可变的 `float` 数组。
`static java.lang.Float[]`	`EMPTY_FLOAT_OBJECT_ARRAY` 一个空的不可变的 `Float` 数组。
`static int[]`	`EMPTY_INT_ARRAY` 一个空的不可变的 `int` 数组。
`static java.lang.Integer[]`	`EMPTY_INTEGER_OBJECT_ARRAY` 一个空的不可变的 `Integer` 数组。
`static long[]`	`EMPTY_LONG_ARRAY` 一个空的不可变的 `long` 数组。
`static java.lang.Long[]`	`EMPTY_LONG_OBJECT_ARRAY` 一个空的不可变的 `Long` 数组。
`static java.lang.Object[]`	`EMPTY_OBJECT_ARRAY` 一个空的不可变的 `Object` 数组。
`static short[]`	`EMPTY_SHORT_ARRAY` 一个空的不可变的 `short` 数组。
`static java.lang.Short[]`	`EMPTY_SHORT_OBJECT_ARRAY` 一个空的不可变的 `Short` 数组。
`static java.lang.String[]`	`EMPTY_STRING_ARRAY` 一个空的不可变的 `String` 数组。
`static int`	`INDEX_NOT_FOUND` 未被找到的索引值： `-1`。

Constructor Summary

Constructors
Constructor and Description

ArrayUtil()

Constructors
Constructor and Description
`ArrayUtil()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static boolean[]`	`add(boolean[] array, boolean element)` 功能描述：
`static boolean[]`	`add(boolean[] array, int index, boolean element)` 功能描述：
`static byte[]`	`add(byte[] array, byte element)` 功能描述：
`static byte[]`	`add(byte[] array, int index, byte element)` 功能描述：
`static char[]`	`add(char[] array, char element)` 功能描述：
`static char[]`	`add(char[] array, int index, char element)` 功能描述：
`static double[]`	`add(double[] array, double element)` 功能描述：
`static double[]`	`add(double[] array, int index, double element)` 功能描述：
`static float[]`	`add(float[] array, float element)` 功能描述：
`static float[]`	`add(float[] array, int index, float element)` 功能描述：
`static int[]`	`add(int[] array, int element)` 功能描述：
`static int[]`	`add(int[] array, int index, int element)` 功能描述：
`static long[]`	`add(long[] array, int index, long element)` 功能描述：
`static long[]`	`add(long[] array, long element)` 功能描述：
`static java.lang.Object[]`	`add(java.lang.Object[] array, int index, java.lang.Object element)` 功能描述：
`static java.lang.Object[]`	`add(java.lang.Object[] array, java.lang.Object element)` 功能描述：
`static short[]`	`add(short[] array, int index, short element)` 功能描述：
`static short[]`	`add(short[] array, short element)` 功能描述：
`static boolean[]`	`addAll(boolean[] array1, boolean[] array2)` 功能描述：
`static byte[]`	`addAll(byte[] array1, byte[] array2)` 功能描述：
`static char[]`	`addAll(char[] array1, char[] array2)` 功能描述：
`static double[]`	`addAll(double[] array1, double[] array2)` 功能描述：
`static float[]`	`addAll(float[] array1, float[] array2)` 功能描述：
`static int[]`	`addAll(int[] array1, int[] array2)` 功能描述：
`static long[]`	`addAll(long[] array1, long[] array2)` 功能描述：
`static java.lang.Object[]`	`addAll(java.lang.Object[] array1, java.lang.Object[] array2)` 功能描述：
`static short[]`	`addAll(short[] array1, short[] array2)` 功能描述：
`static boolean[]`	`clone(boolean[] array)` 功能描述：
`static byte[]`	`clone(byte[] array)` 功能描述：
`static char[]`	`clone(char[] array)` 功能描述：
`static double[]`	`clone(double[] array)` 功能描述：
`static float[]`	`clone(float[] array)` 功能描述：
`static int[]`	`clone(int[] array)` 功能描述：
`static long[]`	`clone(long[] array)` 功能描述：
`static java.lang.Object[]`	`clone(java.lang.Object[] array)` 功能描述：
`static short[]`	`clone(short[] array)` 功能描述：
`static boolean`	`contains(boolean[] array, boolean valueToFind)` 功能描述：
`static boolean`	`contains(byte[] array, byte valueToFind)` 功能描述：
`static boolean`	`contains(char[] array, char valueToFind)` 功能描述：
`static boolean`	`contains(double[] array, double valueToFind)` 功能描述：
`static boolean`	`contains(double[] array, double valueToFind, double tolerance)` 功能描述：
`static boolean`	`contains(float[] array, float valueToFind)` 功能描述：
`static boolean`	`contains(int[] array, int valueToFind)` 功能描述：
`static boolean`	`contains(long[] array, long valueToFind)` 功能描述：
`static boolean`	`contains(java.lang.Object[] array, java.lang.Object objectToFind)` 功能描述：
`static boolean`	`contains(short[] array, short valueToFind)` 功能描述：
`static int`	`getLength(java.lang.Object array)` 功能描述：
`static int`	`indexOf(boolean[] array, boolean valueToFind)` 功能描述：
`static int`	`indexOf(boolean[] array, boolean valueToFind, int startIndex)` 功能描述：
`static int`	`indexOf(byte[] array, byte valueToFind)` 功能描述：
`static int`	`indexOf(byte[] array, byte valueToFind, int startIndex)` 功能描述：
`static int`	`indexOf(char[] array, char valueToFind)` 功能描述：
`static int`	`indexOf(char[] array, char valueToFind, int startIndex)` 功能描述：
`static int`	`indexOf(double[] array, double valueToFind)` 功能描述：
`static int`	`indexOf(double[] array, double valueToFind, double tolerance)` 功能描述：
`static int`	`indexOf(double[] array, double valueToFind, int startIndex)` 功能描述：
`static int`	`indexOf(double[] array, double valueToFind, int startIndex, double tolerance)` 功能描述：
`static int`	`indexOf(float[] array, float valueToFind)` 功能描述：
`static int`	`indexOf(float[] array, float valueToFind, int startIndex)` 功能描述：
`static int`	`indexOf(int[] array, int valueToFind)` 功能描述：
`static int`	`indexOf(int[] array, int valueToFind, int startIndex)` 功能描述：
`static int`	`indexOf(long[] array, long valueToFind)` 功能描述：
`static int`	`indexOf(long[] array, long valueToFind, int startIndex)` 功能描述：
`static int`	`indexOf(java.lang.Object[] array, java.lang.Object objectToFind)` 功能描述：
`static int`	`indexOf(java.lang.Object[] array, java.lang.Object objectToFind, int startIndex)` 功能描述：
`static int`	`indexOf(short[] array, short valueToFind)` 功能描述：
`static int`	`indexOf(short[] array, short valueToFind, int startIndex)` 功能描述：
`static boolean`	`isEmpty(boolean[] array)` 功能描述：
`static boolean`	`isEmpty(byte[] array)` 功能描述：
`static boolean`	`isEmpty(char[] array)` 功能描述：
`static boolean`	`isEmpty(double[] array)` 功能描述：
`static boolean`	`isEmpty(float[] array)` 功能描述：
`static boolean`	`isEmpty(int[] array)` 功能描述：
`static boolean`	`isEmpty(long[] array)` 功能描述：
`static boolean`	`isEmpty(java.lang.Object[] array)` 功能描述：
`static boolean`	`isEmpty(short[] array)` 功能描述：
`static boolean`	`isEquals(java.lang.Object array1, java.lang.Object array2)` 功能描述：
`static boolean`	`isNotEmpty(boolean[] array)` 功能描述：
`static boolean`	`isNotEmpty(byte[] array)` 功能描述：
`static boolean`	`isNotEmpty(char[] array)` 功能描述：
`static boolean`	`isNotEmpty(double[] array)` 功能描述：
`static boolean`	`isNotEmpty(float[] array)` 功能描述：
`static boolean`	`isNotEmpty(int[] array)` 功能描述：
`static boolean`	`isNotEmpty(long[] array)` 功能描述：
`static boolean`	`isNotEmpty(java.lang.Object[] array)` 功能描述：
`static boolean`	`isNotEmpty(short[] array)` 功能描述：
`static boolean`	`isSameLength(boolean[] array1, boolean[] array2)` 功能描述：
`static boolean`	`isSameLength(byte[] array1, byte[] array2)` 功能描述：
`static boolean`	`isSameLength(char[] array1, char[] array2)` 功能描述：
`static boolean`	`isSameLength(double[] array1, double[] array2)` 功能描述：
`static boolean`	`isSameLength(float[] array1, float[] array2)` 功能描述：
`static boolean`	`isSameLength(int[] array1, int[] array2)` 功能描述：
`static boolean`	`isSameLength(long[] array1, long[] array2)` 功能描述：
`static boolean`	`isSameLength(java.lang.Object[] array1, java.lang.Object[] array2)` 功能描述：
`static boolean`	`isSameLength(short[] array1, short[] array2)` 功能描述：
`static boolean`	`isSameType(java.lang.Object array1, java.lang.Object array2)` 功能描述：
`static int`	`lastIndexOf(boolean[] array, boolean valueToFind)` 功能描述：
`static int`	`lastIndexOf(boolean[] array, boolean valueToFind, int startIndex)` 功能描述：
`static int`	`lastIndexOf(byte[] array, byte valueToFind)` 功能描述：
`static int`	`lastIndexOf(byte[] array, byte valueToFind, int startIndex)` 功能描述：
`static int`	`lastIndexOf(char[] array, char valueToFind)` 功能描述：
`static int`	`lastIndexOf(char[] array, char valueToFind, int startIndex)` 功能描述：
`static int`	`lastIndexOf(double[] array, double valueToFind)` 功能描述：
`static int`	`lastIndexOf(double[] array, double valueToFind, double tolerance)` 功能描述：
`static int`	`lastIndexOf(double[] array, double valueToFind, int startIndex)` 功能描述：
`static int`	`lastIndexOf(double[] array, double valueToFind, int startIndex, double tolerance)` 功能描述：
`static int`	`lastIndexOf(float[] array, float valueToFind)` 功能描述：
`static int`	`lastIndexOf(float[] array, float valueToFind, int startIndex)` 功能描述：
`static int`	`lastIndexOf(int[] array, int valueToFind)` 功能描述：
`static int`	`lastIndexOf(int[] array, int valueToFind, int startIndex)` 功能描述：
`static int`	`lastIndexOf(long[] array, long valueToFind)` 功能描述：
`static int`	`lastIndexOf(long[] array, long valueToFind, int startIndex)` 功能描述：
`static int`	`lastIndexOf(java.lang.Object[] array, java.lang.Object objectToFind)` 功能描述：
`static int`	`lastIndexOf(java.lang.Object[] array, java.lang.Object objectToFind, int startIndex)` 功能描述：
`static int`	`lastIndexOf(short[] array, short valueToFind)` 功能描述：
`static int`	`lastIndexOf(short[] array, short valueToFind, int startIndex)` 功能描述：
`static boolean[]`	`nullToEmpty(boolean[] array)` 功能描述：
`static java.lang.Boolean[]`	`nullToEmpty(java.lang.Boolean[] array)` 功能描述：
`static byte[]`	`nullToEmpty(byte[] array)` 功能描述：
`static java.lang.Byte[]`	`nullToEmpty(java.lang.Byte[] array)` 功能描述：
`static char[]`	`nullToEmpty(char[] array)` 功能描述：
`static java.lang.Character[]`	`nullToEmpty(java.lang.Character[] array)` 功能描述：
`static double[]`	`nullToEmpty(double[] array)` 功能描述：
`static java.lang.Double[]`	`nullToEmpty(java.lang.Double[] array)` 功能描述：
`static float[]`	`nullToEmpty(float[] array)` 功能描述：
`static java.lang.Float[]`	`nullToEmpty(java.lang.Float[] array)` 功能描述：
`static int[]`	`nullToEmpty(int[] array)` 功能描述：
`static java.lang.Integer[]`	`nullToEmpty(java.lang.Integer[] array)` 功能描述：
`static long[]`	`nullToEmpty(long[] array)` 功能描述：
`static java.lang.Long[]`	`nullToEmpty(java.lang.Long[] array)` 功能描述：
`static java.lang.Object[]`	`nullToEmpty(java.lang.Object[] array)` 功能描述：
`static short[]`	`nullToEmpty(short[] array)` 功能描述：
`static java.lang.Short[]`	`nullToEmpty(java.lang.Short[] array)` 功能描述：
`static java.lang.String[]`	`nullToEmpty(java.lang.String[] array)` 功能描述：
`static boolean[]`	`remove(boolean[] array, int index)` 功能描述：
`static byte[]`	`remove(byte[] array, int index)` 功能描述：
`static char[]`	`remove(char[] array, int index)` 功能描述：
`static double[]`	`remove(double[] array, int index)` 功能描述：
`static float[]`	`remove(float[] array, int index)` 功能描述：
`static int[]`	`remove(int[] array, int index)` 功能描述：
`static long[]`	`remove(long[] array, int index)` 功能描述：
`static java.lang.Object[]`	`remove(java.lang.Object[] array, int index)` 功能描述：
`static short[]`	`remove(short[] array, int index)` 功能描述：
`static boolean[]`	`removeElement(boolean[] array, boolean element)` 功能描述：
`static byte[]`	`removeElement(byte[] array, byte element)` 功能描述：
`static char[]`	`removeElement(char[] array, char element)` 功能描述：
`static double[]`	`removeElement(double[] array, double element)` 功能描述：
`static float[]`	`removeElement(float[] array, float element)` 功能描述：
`static int[]`	`removeElement(int[] array, int element)` 功能描述：
`static long[]`	`removeElement(long[] array, long element)` 功能描述：
`static java.lang.Object[]`	`removeElement(java.lang.Object[] array, java.lang.Object element)` 功能描述：
`static short[]`	`removeElement(short[] array, short element)` 功能描述：
`static void`	`reverse(boolean[] array)` 功能描述：
`static void`	`reverse(byte[] array)` 功能描述：
`static void`	`reverse(char[] array)` 功能描述：
`static void`	`reverse(double[] array)` 功能描述：
`static void`	`reverse(float[] array)` 功能描述：
`static void`	`reverse(int[] array)` 功能描述：
`static void`	`reverse(long[] array)` 功能描述：
`static void`	`reverse(java.lang.Object[] array)` 功能描述：
`static void`	`reverse(short[] array)` 功能描述：
`static boolean[]`	`subarray(boolean[] array, int startIndexInclusive, int endIndexExclusive)` 功能描述：
`static byte[]`	`subarray(byte[] array, int startIndexInclusive, int endIndexExclusive)` 功能描述：
`static char[]`	`subarray(char[] array, int startIndexInclusive, int endIndexExclusive)` 功能描述：
`static double[]`	`subarray(double[] array, int startIndexInclusive, int endIndexExclusive)` 功能描述：
`static float[]`	`subarray(float[] array, int startIndexInclusive, int endIndexExclusive)` 功能描述：
`static int[]`	`subarray(int[] array, int startIndexInclusive, int endIndexExclusive)` 功能描述：
`static long[]`	`subarray(long[] array, int startIndexInclusive, int endIndexExclusive)` 功能描述：
`static java.lang.Object[]`	`subarray(java.lang.Object[] array, int startIndexInclusive, int endIndexExclusive)` 功能描述：
`static short[]`	`subarray(short[] array, int startIndexInclusive, int endIndexExclusive)` 功能描述：
`static java.lang.Boolean[]`	`toObject(boolean[] array)` 功能描述：
`static java.lang.Byte[]`	`toObject(byte[] array)` 功能描述：
`static java.lang.Character[]`	`toObject(char[] array)` 功能描述：
`static java.lang.Double[]`	`toObject(double[] array)` 功能描述：
`static java.lang.Float[]`	`toObject(float[] array)` 功能描述：
`static java.lang.Integer[]`	`toObject(int[] array)` 功能描述：
`static java.lang.Long[]`	`toObject(long[] array)` 功能描述：
`static java.lang.Short[]`	`toObject(short[] array)` 功能描述：
`static boolean[]`	`toPrimitive(java.lang.Boolean[] array)` 功能描述：
`static boolean[]`	`toPrimitive(java.lang.Boolean[] array, boolean valueForNull)` 功能描述：
`static byte[]`	`toPrimitive(java.lang.Byte[] array)` 功能描述：
`static byte[]`	`toPrimitive(java.lang.Byte[] array, byte valueForNull)` 功能描述：
`static char[]`	`toPrimitive(java.lang.Character[] array)` 功能描述：
`static char[]`	`toPrimitive(java.lang.Character[] array, char valueForNull)` 功能描述：
`static double[]`	`toPrimitive(java.lang.Double[] array)` 功能描述：
`static double[]`	`toPrimitive(java.lang.Double[] array, double valueForNull)` 功能描述：
`static float[]`	`toPrimitive(java.lang.Float[] array)` 功能描述：
`static float[]`	`toPrimitive(java.lang.Float[] array, float valueForNull)` 功能描述：
`static int[]`	`toPrimitive(java.lang.Integer[] array)` 功能描述：
`static int[]`	`toPrimitive(java.lang.Integer[] array, int valueForNull)` 功能描述：
`static long[]`	`toPrimitive(java.lang.Long[] array)` 功能描述：
`static long[]`	`toPrimitive(java.lang.Long[] array, long valueForNull)` 功能描述：
`static short[]`	`toPrimitive(java.lang.Short[] array)` 功能描述：
`static short[]`	`toPrimitive(java.lang.Short[] array, short valueForNull)` 功能描述：
`static java.lang.String`	`toString(java.lang.Object array)` 功能描述：
`static java.lang.String`	`toString(java.lang.Object array, java.lang.String stringIfNull)` 功能描述：

Methods inherited from class java.lang.Object
equals, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Field Detail
  - EMPTY_OBJECT_ARRAY
```
public static final java.lang.Object[] EMPTY_OBJECT_ARRAY
```
    一个空的不可变的 Object 数组。
  - EMPTY_CLASS_ARRAY
```
public static final java.lang.Class[] EMPTY_CLASS_ARRAY
```
    一个空的不可变的 Class 数组。
  - EMPTY_STRING_ARRAY
```
public static final java.lang.String[] EMPTY_STRING_ARRAY
```
    一个空的不可变的 String 数组。
  - EMPTY_LONG_ARRAY
```
public static final long[] EMPTY_LONG_ARRAY
```
    一个空的不可变的 long 数组。
  - EMPTY_LONG_OBJECT_ARRAY
```
public static final java.lang.Long[] EMPTY_LONG_OBJECT_ARRAY
```
    一个空的不可变的 Long 数组。
  - EMPTY_INT_ARRAY
```
public static final int[] EMPTY_INT_ARRAY
```
    一个空的不可变的 int 数组。
  - EMPTY_INTEGER_OBJECT_ARRAY
```
public static final java.lang.Integer[] EMPTY_INTEGER_OBJECT_ARRAY
```
    一个空的不可变的 Integer 数组。
  - EMPTY_SHORT_ARRAY
```
public static final short[] EMPTY_SHORT_ARRAY
```
    一个空的不可变的 short 数组。
  - EMPTY_SHORT_OBJECT_ARRAY
```
public static final java.lang.Short[] EMPTY_SHORT_OBJECT_ARRAY
```
    一个空的不可变的 Short 数组。
  - EMPTY_BYTE_ARRAY
```
public static final byte[] EMPTY_BYTE_ARRAY
```
    一个空的不可变的 byte 数组。
  - EMPTY_BYTE_OBJECT_ARRAY
```
public static final java.lang.Byte[] EMPTY_BYTE_OBJECT_ARRAY
```
    一个空的不可变的 Byte 数组。
  - EMPTY_DOUBLE_ARRAY
```
public static final double[] EMPTY_DOUBLE_ARRAY
```
    一个空的不可变的 double 数组。
  - EMPTY_DOUBLE_OBJECT_ARRAY
```
public static final java.lang.Double[] EMPTY_DOUBLE_OBJECT_ARRAY
```
    一个空的不可变的 Double 数组。
  - EMPTY_FLOAT_ARRAY
```
public static final float[] EMPTY_FLOAT_ARRAY
```
    一个空的不可变的 float 数组。
  - EMPTY_FLOAT_OBJECT_ARRAY
```
public static final java.lang.Float[] EMPTY_FLOAT_OBJECT_ARRAY
```
    一个空的不可变的 Float 数组。
  - EMPTY_BOOLEAN_ARRAY
```
public static final boolean[] EMPTY_BOOLEAN_ARRAY
```
    一个空的不可变的 boolean 数组。
  - EMPTY_BOOLEAN_OBJECT_ARRAY
```
public static final java.lang.Boolean[] EMPTY_BOOLEAN_OBJECT_ARRAY
```
    一个空的不可变的 Boolean 数组。
  - EMPTY_CHAR_ARRAY
```
public static final char[] EMPTY_CHAR_ARRAY
```
    一个空的不可变的 char 数组。
  - EMPTY_CHARACTER_OBJECT_ARRAY
```
public static final java.lang.Character[] EMPTY_CHARACTER_OBJECT_ARRAY
```
    一个空的不可变的 Character 数组。
  - INDEX_NOT_FOUND
```
public static final int INDEX_NOT_FOUND
```
    未被找到的索引值： -1。
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - ArrayUtil
```
public ArrayUtil()
```
- Method Detail
  - toString
```
public static java.lang.String toString(java.lang.Object array)
```
    功能描述：
    将数组格式化成字符串。
    
    如果array为null，则返回“{}”。
    
    Parameters:
    
    array - 将要被格式化成字符串的数组，可以为null
    
    Returns:
    
    格式化成的字符串，如果array为null，则返回“{}”
  - toString
```
public static java.lang.String toString(java.lang.Object array,
                                        java.lang.String stringIfNull)
```
    功能描述：
    将数组格式化成字符串。
    
    如果array为null，则返回stringIfNull。
    
    Parameters:
    
    array - 将要被格式化成字符串的数组
    
    stringIfNull - 如果array为null，其将被返回
    
    Returns:
    
    格式化成的字符串，如果array为null，则返回stringIfNull
  - isEquals
```
public static boolean isEquals(java.lang.Object array1,
                               java.lang.Object array2)
```
    功能描述：
    比较两个数组是否相等。
    
    Parameters:
    
    array1 - 将要比较的数组
    
    array2 - 将要比较的数组
    
    Returns:
    
    如果数组相等，则返回true，否则返回false
  - clone
```
public static java.lang.Object[] clone(java.lang.Object[] array)
```
    功能描述：
    克隆数组。此方法不会克隆数组中的对象。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 将要被克隆的数组
    
    Returns:
    
    克隆形成的数组，如果array为null，则返回null
  - clone
```
public static long[] clone(long[] array)
```
    功能描述：
    克隆数组。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 将要被克隆的数组
    
    Returns:
    
    克隆形成的数组，如果array为null，则返回null
  - clone
```
public static int[] clone(int[] array)
```
    功能描述：
    克隆数组。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 将要被克隆的数组
    
    Returns:
    
    克隆形成的数组，如果array为null，则返回null
  - clone
```
public static short[] clone(short[] array)
```
    功能描述：
    克隆数组。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 将要被克隆的数组
    
    Returns:
    
    克隆形成的数组，如果array为null，则返回null
  - clone
```
public static char[] clone(char[] array)
```
    功能描述：
    克隆数组。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 将要被克隆的数组
    
    Returns:
    
    克隆形成的数组，如果array为null，则返回null
  - clone
```
public static byte[] clone(byte[] array)
```
    功能描述：
    克隆数组。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 将要被克隆的数组
    
    Returns:
    
    克隆形成的数组，如果array为null，则返回null
  - clone
```
public static double[] clone(double[] array)
```
    功能描述：
    克隆数组。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 将要被克隆的数组
    
    Returns:
    
    克隆形成的数组，如果array为null，则返回null
  - clone
```
public static float[] clone(float[] array)
```
    功能描述：
    克隆数组。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 将要被克隆的数组
    
    Returns:
    
    克隆形成的数组，如果array为null，则返回null
  - clone
```
public static boolean[] clone(boolean[] array)
```
    功能描述：
    克隆数组。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 将要被克隆的数组
    
    Returns:
    
    克隆形成的数组，如果array为null，则返回null
  - nullToEmpty
```
public static java.lang.Object[] nullToEmpty(java.lang.Object[] array)
```
    功能描述：
    如果array为null，将返回一个相应类型的空的数组。
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    array，如果array为null，则返回一个相应类型的空的数组
  - nullToEmpty
```
public static java.lang.String[] nullToEmpty(java.lang.String[] array)
```
    功能描述：
    如果array为null，将返回一个相应类型的空的数组。
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    array，如果array为null，则返回一个相应类型的空的数组
  - nullToEmpty
```
public static long[] nullToEmpty(long[] array)
```
    功能描述：
    如果array为null，将返回一个相应类型的空的数组。
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    array，如果array为null，则返回一个相应类型的空的数组
  - nullToEmpty
```
public static int[] nullToEmpty(int[] array)
```
    功能描述：
    如果array为null，将返回一个相应类型的空的数组。
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    array，如果array为null，则返回一个相应类型的空的数组
  - nullToEmpty
```
public static short[] nullToEmpty(short[] array)
```
    功能描述：
    如果array为null，将返回一个相应类型的空的数组。
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    array，如果array为null，则返回一个相应类型的空的数组
  - nullToEmpty
```
public static char[] nullToEmpty(char[] array)
```
    功能描述：
    如果array为null，将返回一个相应类型的空的数组。
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    array，如果array为null，则返回一个相应类型的空的数组
  - nullToEmpty
```
public static byte[] nullToEmpty(byte[] array)
```
    功能描述：
    如果array为null，将返回一个相应类型的空的数组。
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    array，如果array为null，则返回一个相应类型的空的数组
  - nullToEmpty
```
public static double[] nullToEmpty(double[] array)
```
    功能描述：
    如果array为null，将返回一个相应类型的空的数组。
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    array，如果array为null，则返回一个相应类型的空的数组
  - nullToEmpty
```
public static float[] nullToEmpty(float[] array)
```
    功能描述：
    如果array为null，将返回一个相应类型的空的数组。
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    array，如果array为null，则返回一个相应类型的空的数组
  - nullToEmpty
```
public static boolean[] nullToEmpty(boolean[] array)
```
    功能描述：
    如果array为null，将返回一个相应类型的空的数组。
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    array，如果array为null，则返回一个相应类型的空的数组
  - nullToEmpty
```
public static java.lang.Long[] nullToEmpty(java.lang.Long[] array)
```
    功能描述：
    如果array为null，将返回一个相应类型的空的数组。
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    array，如果array为null，则返回一个相应类型的空的数组
  - nullToEmpty
```
public static java.lang.Integer[] nullToEmpty(java.lang.Integer[] array)
```
    功能描述：
    如果array为null，将返回一个相应类型的空的数组。
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    array，如果array为null，则返回一个相应类型的空的数组
  - nullToEmpty
```
public static java.lang.Short[] nullToEmpty(java.lang.Short[] array)
```
    功能描述：
    如果array为null，将返回一个相应类型的空的数组。
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    array，如果array为null，则返回一个相应类型的空的数组
  - nullToEmpty
```
public static java.lang.Character[] nullToEmpty(java.lang.Character[] array)
```
    功能描述：
    如果array为null，将返回一个相应类型的空的数组。
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    array，如果array为null，则返回一个相应类型的空的数组
  - nullToEmpty
```
public static java.lang.Byte[] nullToEmpty(java.lang.Byte[] array)
```
    功能描述：
    如果array为null，将返回一个相应类型的空的数组。
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    array，如果array为null，则返回一个相应类型的空的数组
  - nullToEmpty
```
public static java.lang.Double[] nullToEmpty(java.lang.Double[] array)
```
    功能描述：
    如果array为null，将返回一个相应类型的空的数组。
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    array，如果array为null，则返回一个相应类型的空的数组
  - nullToEmpty
```
public static java.lang.Float[] nullToEmpty(java.lang.Float[] array)
```
    功能描述：
    如果array为null，将返回一个相应类型的空的数组。
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    array，如果array为null，则返回一个相应类型的空的数组
  - nullToEmpty
```
public static java.lang.Boolean[] nullToEmpty(java.lang.Boolean[] array)
```
    功能描述：
    如果array为null，将返回一个相应类型的空的数组。
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    array，如果array为null，则返回一个相应类型的空的数组
  - subarray
```
public static java.lang.Object[] subarray(java.lang.Object[] array,
                                          int startIndexInclusive,
                                          int endIndexExclusive)
```
    功能描述：
    截取从开始索引到结束索引之间的元素，作为一个新的数组返回。
    
    新的数组包含开始索引的元素，不包含结束索引的元素。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 数组
    
    startIndexInclusive - 开始索引
    
    endIndexExclusive - 结束索引
    
    Returns:
    
    一个新的数组，包含从开始索引到结束索引之间的元素
  - subarray
```
public static long[] subarray(long[] array,
                              int startIndexInclusive,
                              int endIndexExclusive)
```
    功能描述：
    截取从开始索引到结束索引之间的元素，作为一个新的数组返回。
    
    新的数组包含开始索引的元素，不包含结束索引的元素。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 数组
    
    startIndexInclusive - 开始索引
    
    endIndexExclusive - 结束索引
    
    Returns:
    
    一个新的数组，包含从开始索引到结束索引之间的元素
  - subarray
```
public static int[] subarray(int[] array,
                             int startIndexInclusive,
                             int endIndexExclusive)
```
    功能描述：
    截取从开始索引到结束索引之间的元素，作为一个新的数组返回。
    
    新的数组包含开始索引的元素，不包含结束索引的元素。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 数组
    
    startIndexInclusive - 开始索引
    
    endIndexExclusive - 结束索引
    
    Returns:
    
    一个新的数组，包含从开始索引到结束索引之间的元素
  - subarray
```
public static short[] subarray(short[] array,
                               int startIndexInclusive,
                               int endIndexExclusive)
```
    功能描述：
    截取从开始索引到结束索引之间的元素，作为一个新的数组返回。
    
    新的数组包含开始索引的元素，不包含结束索引的元素。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 数组
    
    startIndexInclusive - 开始索引
    
    endIndexExclusive - 结束索引
    
    Returns:
    
    一个新的数组，包含从开始索引到结束索引之间的元素
  - subarray
```
public static char[] subarray(char[] array,
                              int startIndexInclusive,
                              int endIndexExclusive)
```
    功能描述：
    截取从开始索引到结束索引之间的元素，作为一个新的数组返回。
    
    新的数组包含开始索引的元素，不包含结束索引的元素。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 数组
    
    startIndexInclusive - 开始索引
    
    endIndexExclusive - 结束索引
    
    Returns:
    
    一个新的数组，包含从开始索引到结束索引之间的元素
  - subarray
```
public static byte[] subarray(byte[] array,
                              int startIndexInclusive,
                              int endIndexExclusive)
```
    功能描述：
    截取从开始索引到结束索引之间的元素，作为一个新的数组返回。
    
    新的数组包含开始索引的元素，不包含结束索引的元素。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 数组
    
    startIndexInclusive - 开始索引
    
    endIndexExclusive - 结束索引
    
    Returns:
    
    一个新的数组，包含从开始索引到结束索引之间的元素
  - subarray
```
public static double[] subarray(double[] array,
                                int startIndexInclusive,
                                int endIndexExclusive)
```
    功能描述：
    截取从开始索引到结束索引之间的元素，作为一个新的数组返回。
    
    新的数组包含开始索引的元素，不包含结束索引的元素。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 数组
    
    startIndexInclusive - 开始索引
    
    endIndexExclusive - 结束索引
    
    Returns:
    
    一个新的数组，包含从开始索引到结束索引之间的元素
  - subarray
```
public static float[] subarray(float[] array,
                               int startIndexInclusive,
                               int endIndexExclusive)
```
    功能描述：
    截取从开始索引到结束索引之间的元素，作为一个新的数组返回。
    
    新的数组包含开始索引的元素，不包含结束索引的元素。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 数组
    
    startIndexInclusive - 开始索引
    
    endIndexExclusive - 结束索引
    
    Returns:
    
    一个新的数组，包含从开始索引到结束索引之间的元素
  - subarray
```
public static boolean[] subarray(boolean[] array,
                                 int startIndexInclusive,
                                 int endIndexExclusive)
```
    功能描述：
    截取从开始索引到结束索引之间的元素，作为一个新的数组返回。
    
    新的数组包含开始索引的元素，不包含结束索引的元素。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 数组
    
    startIndexInclusive - 开始索引
    
    endIndexExclusive - 结束索引
    
    Returns:
    
    一个新的数组，包含从开始索引到结束索引之间的元素
  - isSameLength
```
public static boolean isSameLength(java.lang.Object[] array1,
                                   java.lang.Object[] array2)
```
    功能描述：
    比较两个数组的长度是否相同。此方法将null视为长度为0的数组。
    
    Parameters:
    
    array1 - 要进行比较的数组
    
    array2 - 要进行比较的数组
    
    Returns:
    
    如果长度相同，则返回true，否则返回false
  - isSameLength
```
public static boolean isSameLength(long[] array1,
                                   long[] array2)
```
    功能描述：
    比较两个数组的长度是否相同。此方法将null视为长度为0的数组。
    
    Parameters:
    
    array1 - 要进行比较的数组
    
    array2 - 要进行比较的数组
    
    Returns:
    
    如果长度相同，则返回true，否则返回false
  - isSameLength
```
public static boolean isSameLength(int[] array1,
                                   int[] array2)
```
    功能描述：
    比较两个数组的长度是否相同。此方法将null视为长度为0的数组。
    
    Parameters:
    
    array1 - 要进行比较的数组
    
    array2 - 要进行比较的数组
    
    Returns:
    
    如果长度相同，则返回true，否则返回false
  - isSameLength
```
public static boolean isSameLength(short[] array1,
                                   short[] array2)
```
    功能描述：
    比较两个数组的长度是否相同。此方法将null视为长度为0的数组。
    
    Parameters:
    
    array1 - 要进行比较的数组
    
    array2 - 要进行比较的数组
    
    Returns:
    
    如果长度相同，则返回true，否则返回false
  - isSameLength
```
public static boolean isSameLength(char[] array1,
                                   char[] array2)
```
    功能描述：
    比较两个数组的长度是否相同。此方法将null视为长度为0的数组。
    
    Parameters:
    
    array1 - 要进行比较的数组
    
    array2 - 要进行比较的数组
    
    Returns:
    
    如果长度相同，则返回true，否则返回false
  - isSameLength
```
public static boolean isSameLength(byte[] array1,
                                   byte[] array2)
```
    功能描述：
    比较两个数组的长度是否相同。此方法将null视为长度为0的数组。
    
    Parameters:
    
    array1 - 要进行比较的数组
    
    array2 - 要进行比较的数组
    
    Returns:
    
    如果长度相同，则返回true，否则返回false
  - isSameLength
```
public static boolean isSameLength(double[] array1,
                                   double[] array2)
```
    功能描述：
    比较两个数组的长度是否相同。此方法将null视为长度为0的数组。
    
    Parameters:
    
    array1 - 要进行比较的数组
    
    array2 - 要进行比较的数组
    
    Returns:
    
    如果长度相同，则返回true，否则返回false
  - isSameLength
```
public static boolean isSameLength(float[] array1,
                                   float[] array2)
```
    功能描述：
    比较两个数组的长度是否相同。此方法将null视为长度为0的数组。
    
    Parameters:
    
    array1 - 要进行比较的数组
    
    array2 - 要进行比较的数组
    
    Returns:
    
    如果长度相同，则返回true，否则返回false
  - isSameLength
```
public static boolean isSameLength(boolean[] array1,
                                   boolean[] array2)
```
    功能描述：
    比较两个数组的长度是否相同。此方法将null视为长度为0的数组。
    
    Parameters:
    
    array1 - 要进行比较的数组
    
    array2 - 要进行比较的数组
    
    Returns:
    
    如果长度相同，则返回true，否则返回false
  - getLength
```
public static int getLength(java.lang.Object array)
```
    功能描述：
    获取数组的长度。
    
    如果array为null，则返回0。
```
 ArrayUtil.getLength(null)            = 0
 ArrayUtil.getLength([])              = 0
 ArrayUtil.getLength([null])          = 1
 ArrayUtil.getLength([true, false])   = 2
 ArrayUtil.getLength([1, 2, 3])       = 3
 ArrayUtil.getLength(["a", "b", "c"]) = 3
 
```
    Parameters:
    
    array - 数组
    
    Returns:
    
    array的长度，如果array为null，则返回0
  - isSameType
```
public static boolean isSameType(java.lang.Object array1,
                                 java.lang.Object array2)
```
    功能描述：
    判断两个数组的类型是否相同。
    
    如果某一数组为null，则抛出异常。
    
    Parameters:
    
    array1 - 要比较的数组
    
    array2 - 要比较的数组
    
    Returns:
    
    如果类型相同返回true，否则返回false
    
    Throws:
    
    java.lang.IllegalArgumentException - 如果某一数组为null。
  - reverse
```
public static void reverse(java.lang.Object[] array)
```
    功能描述：
    翻转数组中元素的顺序。
    
    如果array为null，则不做任何处理。
    
    Parameters:
    
    array - 数组
  - reverse
```
public static void reverse(long[] array)
```
    功能描述：
    翻转数组中元素的顺序。
    
    如果array为null，则不做任何处理。
    
    Parameters:
    
    array - 数组
  - reverse
```
public static void reverse(int[] array)
```
    功能描述：
    翻转数组中元素的顺序。
    
    如果array为null，则不做任何处理。
    
    Parameters:
    
    array - 数组
  - reverse
```
public static void reverse(short[] array)
```
    功能描述：
    翻转数组中元素的顺序。
    
    如果array为null，则不做任何处理。
    
    Parameters:
    
    array - 数组
  - reverse
```
public static void reverse(char[] array)
```
    功能描述：
    翻转数组中元素的顺序。
    
    如果array为null，则不做任何处理。
    
    Parameters:
    
    array - 数组
  - reverse
```
public static void reverse(byte[] array)
```
    功能描述：
    翻转数组中元素的顺序。
    
    如果array为null，则不做任何处理。
    
    Parameters:
    
    array - 数组
  - reverse
```
public static void reverse(double[] array)
```
    功能描述：
    翻转数组中元素的顺序。
    
    如果array为null，则不做任何处理。
    
    Parameters:
    
    array - 数组
  - reverse
```
public static void reverse(float[] array)
```
    功能描述：
    翻转数组中元素的顺序。
    
    如果array为null，则不做任何处理。
    
    Parameters:
    
    array - 数组
  - reverse
```
public static void reverse(boolean[] array)
```
    功能描述：
    翻转数组中元素的顺序。
    
    如果array为null，则不做任何处理。
    
    Parameters:
    
    array - 数组
  - indexOf
```
public static int indexOf(java.lang.Object[] array,
                          java.lang.Object objectToFind)
```
    功能描述：
    获取指定对象在数组中第一次出现处的索引。
    
    如果array为null，则返回INDEX_NOT_FOUND (-1)。
    
    Parameters:
    
    array - 要搜索的数组
    
    objectToFind - 要查找的对象
    
    Returns:
    
    指定对象在数组中第一次出现处的索引，如果array为null或者objectToFind没有被找到，则返回INDEX_NOT_FOUND (-1)。
  - indexOf
```
public static int indexOf(java.lang.Object[] array,
                          java.lang.Object objectToFind,
                          int startIndex)
```
    功能描述：
    获取指定对象在数组中第一次出现处的索引，从指定索引处开始搜索。
    
    Parameters:
    
    array - 要搜索的数组
    
    objectToFind - 要查找的对象
    
    startIndex - 开始索引
    
    Returns:
    
    指定对象在数组中第一次出现处的索引，如果array为null或者objectToFind没有被找到，则返回INDEX_NOT_FOUND (-1)。
  - lastIndexOf
```
public static int lastIndexOf(java.lang.Object[] array,
                              java.lang.Object objectToFind)
```
    功能描述：
    获取指定对象在数组中最后一次出现处的索引。
    
    如果array为null，则返回INDEX_NOT_FOUND (-1)。
    
    Parameters:
    
    array - 要搜索的数组
    
    objectToFind - 要查找的对象
    
    Returns:
    
    指定对象在数组中最后一次出现处的索引，如果array为null或者objectToFind没有被找到，则返回INDEX_NOT_FOUND (-1)。
  - lastIndexOf
```
public static int lastIndexOf(java.lang.Object[] array,
                              java.lang.Object objectToFind,
                              int startIndex)
```
    功能描述：
    获取指定对象在数组中最后一次出现处的索引，从指定索引处开始搜索。
    
    Parameters:
    
    array - 要搜索的数组
    
    objectToFind - 要查找的对象
    
    startIndex - 开始索引
    
    Returns:
    
    指定对象在数组中最后一次出现处的索引，如果array为null或者objectToFind没有被找到，则返回INDEX_NOT_FOUND (-1)。
  - contains
```
public static boolean contains(java.lang.Object[] array,
                               java.lang.Object objectToFind)
```
    功能描述：
    判断指定数组中是否包含指定对象。
    
    Parameters:
    
    array - 要搜索的数组
    
    objectToFind - 要查找的对象
    
    Returns:
    
    如果指定数组中包含指定对象，则返回true，否则返回false
  - indexOf
```
public static int indexOf(long[] array,
                          long valueToFind)
```
    功能描述：
    获取指定值在数组中第一次出现处的索引。
    
    如果array为null，则返回INDEX_NOT_FOUND (-1)。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    Returns:
    
    指定值在数组中第一次出现处的索引，如果array为null或者objectToFind没有被找到，则返回INDEX_NOT_FOUND (-1)。
  - indexOf
```
public static int indexOf(long[] array,
                          long valueToFind,
                          int startIndex)
```
    功能描述：
    获取指定值在数组中第一次出现处的索引，从指定索引处开始搜索。
    
    如果array为null，则返回INDEX_NOT_FOUND (-1)。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    startIndex - 开始索引
    
    Returns:
    
    指定值在数组中第一次出现处的索引，如果array为null或者objectToFind没有被找到，则返回INDEX_NOT_FOUND (-1)。
  - lastIndexOf
```
public static int lastIndexOf(long[] array,
                              long valueToFind)
```
    功能描述：
    获取指定值在数组中最后一次出现处的索引。
    
    如果array为null，则返回INDEX_NOT_FOUND (-1)。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    Returns:
    
    指定值在数组中最后一次出现处的索引，如果array为null或者objectToFind没有被找到，则返回INDEX_NOT_FOUND (-1)。
  - lastIndexOf
```
public static int lastIndexOf(long[] array,
                              long valueToFind,
                              int startIndex)
```
    功能描述：
    获取指定值在数组中最后一次出现处的索引，从指定索引处开始搜索。
    
    如果array为null，则返回INDEX_NOT_FOUND (-1)。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    startIndex - 开始索引
    
    Returns:
    
    指定值在数组中最后一次出现处的索引，如果array为null或者objectToFind没有被找到，则返回INDEX_NOT_FOUND (-1)。
  - contains
```
public static boolean contains(long[] array,
                               long valueToFind)
```
    功能描述：
    判断指定数组中是否包含指定值。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    Returns:
    
    如果指定数组中包含指定值，则返回true，否则返回false
  - indexOf
```
public static int indexOf(int[] array,
                          int valueToFind)
```
    功能描述：
    获取指定值在数组中第一次出现处的索引。
    
    如果array为null，则返回INDEX_NOT_FOUND (-1)。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    Returns:
    
    指定值在数组中第一次出现处的索引，如果array为null或者objectToFind没有被找到，则返回INDEX_NOT_FOUND (-1)。
  - indexOf
```
public static int indexOf(int[] array,
                          int valueToFind,
                          int startIndex)
```
    功能描述：
    获取指定值在数组中第一次出现处的索引，从指定索引处开始搜索。
    
    如果array为null，则返回INDEX_NOT_FOUND (-1)。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    startIndex - 开始索引
    
    Returns:
    
    指定值在数组中第一次出现处的索引，如果array为null或者objectToFind没有被找到，则返回INDEX_NOT_FOUND (-1)。
  - lastIndexOf
```
public static int lastIndexOf(int[] array,
                              int valueToFind)
```
    功能描述：
    获取指定值在数组中最后一次出现处的索引。
    
    如果array为null，则返回INDEX_NOT_FOUND (-1)。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    Returns:
    
    指定值在数组中最后一次出现处的索引，如果array为null或者objectToFind没有被找到，则返回INDEX_NOT_FOUND (-1)。
  - lastIndexOf
```
public static int lastIndexOf(int[] array,
                              int valueToFind,
                              int startIndex)
```
    功能描述：
    获取指定值在数组中最后一次出现处的索引，从指定索引处开始搜索。
    
    如果array为null，则返回INDEX_NOT_FOUND (-1)。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    startIndex - 开始索引
    
    Returns:
    
    指定值在数组中最后一次出现处的索引，如果array为null或者objectToFind没有被找到，则返回INDEX_NOT_FOUND (-1)。
  - contains
```
public static boolean contains(int[] array,
                               int valueToFind)
```
    功能描述：
    判断指定数组中是否包含指定值。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    Returns:
    
    如果指定数组中包含指定值，则返回true，否则返回false
  - indexOf
```
public static int indexOf(short[] array,
                          short valueToFind)
```
    功能描述：
    获取指定值在数组中第一次出现处的索引。
    
    如果array为null，则返回INDEX_NOT_FOUND (-1)。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    Returns:
    
    指定值在数组中第一次出现处的索引，如果array为null或者objectToFind没有被找到，则返回INDEX_NOT_FOUND (-1)。
  - indexOf
```
public static int indexOf(short[] array,
                          short valueToFind,
                          int startIndex)
```
    功能描述：
    获取指定值在数组中第一次出现处的索引，从指定索引处开始搜索。
    
    如果array为null，则返回INDEX_NOT_FOUND (-1)。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    startIndex - 开始索引
    
    Returns:
    
    指定值在数组中第一次出现处的索引，如果array为null或者objectToFind没有被找到，则返回INDEX_NOT_FOUND (-1)。
  - lastIndexOf
```
public static int lastIndexOf(short[] array,
                              short valueToFind)
```
    功能描述：
    获取指定值在数组中最后一次出现处的索引。
    
    如果array为null，则返回INDEX_NOT_FOUND (-1)。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    Returns:
    
    指定值在数组中最后一次出现处的索引，如果array为null或者objectToFind没有被找到，则返回INDEX_NOT_FOUND (-1)。
  - lastIndexOf
```
public static int lastIndexOf(short[] array,
                              short valueToFind,
                              int startIndex)
```
    功能描述：
    获取指定值在数组中最后一次出现处的索引，从指定索引处开始搜索。
    
    如果array为null，则返回INDEX_NOT_FOUND (-1)。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    startIndex - 开始索引
    
    Returns:
    
    指定值在数组中最后一次出现处的索引，如果array为null或者objectToFind没有被找到，则返回INDEX_NOT_FOUND (-1)。
  - contains
```
public static boolean contains(short[] array,
                               short valueToFind)
```
    功能描述：
    判断指定数组中是否包含指定值。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    Returns:
    
    如果指定数组中包含指定值，则返回true，否则返回false
  - indexOf
```
public static int indexOf(char[] array,
                          char valueToFind)
```
    功能描述：
    获取指定值在数组中第一次出现处的索引。
    
    如果array为null，则返回INDEX_NOT_FOUND (-1)。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    Returns:
    
    指定值在数组中第一次出现处的索引，如果array为null或者objectToFind没有被找到，则返回INDEX_NOT_FOUND (-1)。
  - indexOf
```
public static int indexOf(char[] array,
                          char valueToFind,
                          int startIndex)
```
    功能描述：
    获取指定值在数组中第一次出现处的索引，从指定索引处开始搜索。
    
    如果array为null，则返回INDEX_NOT_FOUND (-1)。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    startIndex - 开始索引
    
    Returns:
    
    指定值在数组中第一次出现处的索引，如果array为null或者objectToFind没有被找到，则返回INDEX_NOT_FOUND (-1)。
  - lastIndexOf
```
public static int lastIndexOf(char[] array,
                              char valueToFind)
```
    功能描述：
    获取指定值在数组中最后一次出现处的索引。
    
    如果array为null，则返回INDEX_NOT_FOUND (-1)。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    Returns:
    
    指定值在数组中最后一次出现处的索引，如果array为null或者objectToFind没有被找到，则返回INDEX_NOT_FOUND (-1)。
  - lastIndexOf
```
public static int lastIndexOf(char[] array,
                              char valueToFind,
                              int startIndex)
```
    功能描述：
    获取指定值在数组中最后一次出现处的索引，从指定索引处开始搜索。
    
    如果array为null，则返回INDEX_NOT_FOUND (-1)。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    startIndex - 开始索引
    
    Returns:
    
    指定值在数组中最后一次出现处的索引，如果array为null或者objectToFind没有被找到，则返回INDEX_NOT_FOUND (-1)。
  - contains
```
public static boolean contains(char[] array,
                               char valueToFind)
```
    功能描述：
    判断指定数组中是否包含指定值。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    Returns:
    
    如果指定数组中包含指定值，则返回true，否则返回false
  - indexOf
```
public static int indexOf(byte[] array,
                          byte valueToFind)
```
    功能描述：
    获取指定值在数组中第一次出现处的索引。
    
    如果array为null，则返回INDEX_NOT_FOUND (-1)。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    Returns:
    
    指定值在数组中第一次出现处的索引，如果array为null或者objectToFind没有被找到，则返回INDEX_NOT_FOUND (-1)。
  - indexOf
```
public static int indexOf(byte[] array,
                          byte valueToFind,
                          int startIndex)
```
    功能描述：
    获取指定值在数组中第一次出现处的索引，从指定索引处开始搜索。
    
    如果array为null，则返回INDEX_NOT_FOUND (-1)。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    startIndex - 开始索引
    
    Returns:
    
    指定值在数组中第一次出现处的索引，如果array为null或者objectToFind没有被找到，则返回INDEX_NOT_FOUND (-1)。
  - lastIndexOf
```
public static int lastIndexOf(byte[] array,
                              byte valueToFind)
```
    功能描述：
    获取指定值在数组中最后一次出现处的索引。
    
    如果array为null，则返回INDEX_NOT_FOUND (-1)。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    Returns:
    
    指定值在数组中最后一次出现处的索引，如果array为null或者objectToFind没有被找到，则返回INDEX_NOT_FOUND (-1)。
  - lastIndexOf
```
public static int lastIndexOf(byte[] array,
                              byte valueToFind,
                              int startIndex)
```
    功能描述：
    获取指定值在数组中最后一次出现处的索引，从指定索引处开始搜索。
    
    如果array为null，则返回INDEX_NOT_FOUND (-1)。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    startIndex - 开始索引
    
    Returns:
    
    指定值在数组中最后一次出现处的索引，如果array为null或者objectToFind没有被找到，则返回INDEX_NOT_FOUND (-1)。
  - contains
```
public static boolean contains(byte[] array,
                               byte valueToFind)
```
    功能描述：
    判断指定数组中是否包含指定值。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    Returns:
    
    如果指定数组中包含指定值，则返回true，否则返回false
  - indexOf
```
public static int indexOf(double[] array,
                          double valueToFind)
```
    功能描述：
    获取指定值在数组中第一次出现处的索引。
    
    如果array为null，则返回INDEX_NOT_FOUND (-1)。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    Returns:
    
    指定值在数组中第一次出现处的索引，如果array为null或者objectToFind没有被找到，则返回INDEX_NOT_FOUND (-1)。
  - indexOf
```
public static int indexOf(double[] array,
                          double valueToFind,
                          double tolerance)
```
    功能描述：
    获取指定值在指定误差范围内在数组中第一次出现处的索引。
    
    如果array为null，则返回INDEX_NOT_FOUND (-1)。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    tolerance - 误差范围
    
    Returns:
    
    指定值在指定误差范围内在数组中第一次出现处的索引，如果array为null或者objectToFind没有被找到，则返回INDEX_NOT_FOUND (-1)。
  - indexOf
```
public static int indexOf(double[] array,
                          double valueToFind,
                          int startIndex)
```
    功能描述：
    获取指定值在数组中第一次出现处的索引，从指定索引处开始搜索。
    
    如果array为null，则返回INDEX_NOT_FOUND (-1)。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    startIndex - 开始索引
    
    Returns:
    
    指定值在数组中第一次出现处的索引，如果array为null或者objectToFind没有被找到，则返回INDEX_NOT_FOUND (-1)。
  - indexOf
```
public static int indexOf(double[] array,
                          double valueToFind,
                          int startIndex,
                          double tolerance)
```
    功能描述：
    获取指定值在指定误差范围内在数组中第一次出现处的索引，从指定索引处开始搜索。
    
    如果array为null，则返回INDEX_NOT_FOUND (-1)。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    startIndex - 开始索引
    
    tolerance - 误差范围
    
    Returns:
    
    指定值在指定误差范围内在数组中第一次出现处的索引，如果array为null或者objectToFind没有被找到，则返回INDEX_NOT_FOUND (-1)。
  - lastIndexOf
```
public static int lastIndexOf(double[] array,
                              double valueToFind)
```
    功能描述：
    获取指定值在数组中最后一次出现处的索引。
    
    如果array为null，则返回INDEX_NOT_FOUND (-1)。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    Returns:
    
    指定值在数组中最后一次出现处的索引，如果array为null或者objectToFind没有被找到，则返回INDEX_NOT_FOUND (-1)。
  - lastIndexOf
```
public static int lastIndexOf(double[] array,
                              double valueToFind,
                              double tolerance)
```
    功能描述：
    获取指定值在指定误差范围内在数组中最后一次出现处的索引。
    
    如果array为null，则返回INDEX_NOT_FOUND (-1)。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    tolerance - 误差范围
    
    Returns:
    
    指定值在指定误差范围内在数组中最后一次出现处的索引，如果array为null或者objectToFind没有被找到，则返回INDEX_NOT_FOUND (-1)。
  - lastIndexOf
```
public static int lastIndexOf(double[] array,
                              double valueToFind,
                              int startIndex)
```
    功能描述：
    获取指定值在数组中最后一次出现处的索引，从指定索引处开始搜索。
    
    如果array为null，则返回INDEX_NOT_FOUND (-1)。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    startIndex - 开始索引
    
    Returns:
    
    指定值在数组中最后一次出现处的索引，如果array为null或者objectToFind没有被找到，则返回INDEX_NOT_FOUND (-1)。
  - lastIndexOf
```
public static int lastIndexOf(double[] array,
                              double valueToFind,
                              int startIndex,
                              double tolerance)
```
    功能描述：
    获取指定值在指定误差范围内在数组中最后一次出现处的索引，从指定索引处开始搜索。
    
    如果array为null，则返回INDEX_NOT_FOUND (-1)。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    startIndex - 开始索引
    
    tolerance - 误差范围
    
    Returns:
    
    指定值在指定误差范围内在数组中最后一次出现处的索引，如果array为null或者objectToFind没有被找到，则返回INDEX_NOT_FOUND (-1)。
  - contains
```
public static boolean contains(double[] array,
                               double valueToFind)
```
    功能描述：
    判断指定数组中是否包含指定值。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    Returns:
    
    如果指定数组中包含指定值，则返回true，否则返回false
  - contains
```
public static boolean contains(double[] array,
                               double valueToFind,
                               double tolerance)
```
    功能描述：
    判断指定数组中是否包含指定值，允许指定的误差。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    tolerance - 误差范围
    
    Returns:
    
    如果指定数组中包含指定值，则返回true，否则返回false
  - indexOf
```
public static int indexOf(float[] array,
                          float valueToFind)
```
    功能描述：
    获取指定值在数组中第一次出现处的索引。
    
    如果array为null，则返回INDEX_NOT_FOUND (-1)。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    Returns:
    
    指定值在数组中第一次出现处的索引，如果array为null或者objectToFind没有被找到，则返回INDEX_NOT_FOUND (-1)。
  - indexOf
```
public static int indexOf(float[] array,
                          float valueToFind,
                          int startIndex)
```
    功能描述：
    获取指定值在数组中第一次出现处的索引，从指定索引处开始搜索。
    
    如果array为null，则返回INDEX_NOT_FOUND (-1)。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    startIndex - 开始索引
    
    Returns:
    
    指定值在数组中第一次出现处的索引，如果array为null或者objectToFind没有被找到，则返回INDEX_NOT_FOUND (-1)。
  - lastIndexOf
```
public static int lastIndexOf(float[] array,
                              float valueToFind)
```
    功能描述：
    获取指定值在数组中最后一次出现处的索引。
    
    如果array为null，则返回INDEX_NOT_FOUND (-1)。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    Returns:
    
    指定值在数组中最后一次出现处的索引，如果array为null或者objectToFind没有被找到，则返回INDEX_NOT_FOUND (-1)。
  - lastIndexOf
```
public static int lastIndexOf(float[] array,
                              float valueToFind,
                              int startIndex)
```
    功能描述：
    获取指定值在数组中最后一次出现处的索引，从指定索引处开始搜索。
    
    如果array为null，则返回INDEX_NOT_FOUND (-1)。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    startIndex - 开始索引
    
    Returns:
    
    指定值在数组中最后一次出现处的索引，如果array为null或者objectToFind没有被找到，则返回INDEX_NOT_FOUND (-1)。
  - contains
```
public static boolean contains(float[] array,
                               float valueToFind)
```
    功能描述：
    判断指定数组中是否包含指定值。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    Returns:
    
    如果指定数组中包含指定值，则返回true，否则返回false
  - indexOf
```
public static int indexOf(boolean[] array,
                          boolean valueToFind)
```
    功能描述：
    获取指定值在数组中第一次出现处的索引。
    
    如果array为null，则返回INDEX_NOT_FOUND (-1)。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    Returns:
    
    指定值在数组中第一次出现处的索引，如果array为null或者objectToFind没有被找到，则返回INDEX_NOT_FOUND (-1)。
  - indexOf
```
public static int indexOf(boolean[] array,
                          boolean valueToFind,
                          int startIndex)
```
    功能描述：
    获取指定值在数组中第一次出现处的索引，从指定索引处开始搜索。
    
    如果array为null，则返回INDEX_NOT_FOUND (-1)。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    startIndex - 开始索引
    
    Returns:
    
    指定值在数组中第一次出现处的索引，如果array为null或者objectToFind没有被找到，则返回INDEX_NOT_FOUND (-1)。
  - lastIndexOf
```
public static int lastIndexOf(boolean[] array,
                              boolean valueToFind)
```
    功能描述：
    获取指定值在数组中最后一次出现处的索引。
    
    如果array为null，则返回INDEX_NOT_FOUND (-1)。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    Returns:
    
    指定值在数组中最后一次出现处的索引，如果array为null或者objectToFind没有被找到，则返回INDEX_NOT_FOUND (-1)。
  - lastIndexOf
```
public static int lastIndexOf(boolean[] array,
                              boolean valueToFind,
                              int startIndex)
```
    功能描述：
    获取指定值在数组中最后一次出现处的索引，从指定索引处开始搜索。
    
    如果array为null，则返回INDEX_NOT_FOUND (-1)。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    startIndex - 开始索引
    
    Returns:
    
    指定值在数组中最后一次出现处的索引，如果array为null或者objectToFind没有被找到，则返回INDEX_NOT_FOUND (-1)。
  - contains
```
public static boolean contains(boolean[] array,
                               boolean valueToFind)
```
    功能描述：
    判断指定数组中是否包含指定值。
    
    Parameters:
    
    array - 要搜索的数组
    
    valueToFind - 要查找的值
    
    Returns:
    
    如果指定数组中包含指定值，则返回true，否则返回false
  - toPrimitive
```
public static char[] toPrimitive(java.lang.Character[] array)
```
    功能描述：
    将数组转换成相应的基本类型数组。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 要被转换的数组
    
    Returns:
    
    相应的基本类型的数组，如果array为null，则返回null
    
    Throws:
    
    java.lang.NullPointerException - 如果array中有元素为null
  - toPrimitive
```
public static char[] toPrimitive(java.lang.Character[] array,
                                 char valueForNull)
```
    功能描述：
    将数组转换成相应的基本类型数组。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 要被转换的数组
    
    valueForNull - 如果array中有元素为null，则其将被插入到基本类型数组中
    
    Returns:
    
    相应的基本类型的数组，如果array为null，则返回null
  - toObject
```
public static java.lang.Character[] toObject(char[] array)
```
    功能描述：
    将数组转换成相应的引用类型数组。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 要被转换的数组
    
    Returns:
    
    相应的引用类型数组，如果array为null，则返回null
    
    Throws:
    
    java.lang.NullPointerException - 如果array中有元素为null
  - toPrimitive
```
public static long[] toPrimitive(java.lang.Long[] array)
```
    功能描述：
    将数组转换成相应的基本类型数组。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 要被转换的数组
    
    Returns:
    
    相应的基本类型的数组，如果array为null，则返回null
    
    Throws:
    
    java.lang.NullPointerException - 如果array中有元素为null
  - toPrimitive
```
public static long[] toPrimitive(java.lang.Long[] array,
                                 long valueForNull)
```
    功能描述：
    将数组转换成相应的基本类型数组。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 要被转换的数组
    
    valueForNull - 如果array中有元素为null，则其将被插入到基本类型数组中
    
    Returns:
    
    相应的基本类型的数组，如果array为null，则返回null
  - toObject
```
public static java.lang.Long[] toObject(long[] array)
```
    功能描述：
    将数组转换成相应的引用类型数组。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 要被转换的数组
    
    Returns:
    
    相应的引用类型数组，如果array为null，则返回null
    
    Throws:
    
    java.lang.NullPointerException - 如果array中有元素为null
  - toPrimitive
```
public static int[] toPrimitive(java.lang.Integer[] array)
```
    功能描述：
    将数组转换成相应的基本类型数组。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 要被转换的数组
    
    Returns:
    
    相应的基本类型的数组，如果array为null，则返回null
    
    Throws:
    
    java.lang.NullPointerException - 如果array中有元素为null
  - toPrimitive
```
public static int[] toPrimitive(java.lang.Integer[] array,
                                int valueForNull)
```
    功能描述：
    将数组转换成相应的基本类型数组。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 要被转换的数组
    
    valueForNull - 如果array中有元素为null，则其将被插入到基本类型数组中
    
    Returns:
    
    相应的基本类型的数组，如果array为null，则返回null
  - toObject
```
public static java.lang.Integer[] toObject(int[] array)
```
    功能描述：
    将数组转换成相应的引用类型数组。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 要被转换的数组
    
    Returns:
    
    相应的引用类型数组，如果array为null，则返回null
    
    Throws:
    
    java.lang.NullPointerException - 如果array中有元素为null
  - toPrimitive
```
public static short[] toPrimitive(java.lang.Short[] array)
```
    功能描述：
    将数组转换成相应的基本类型数组。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 要被转换的数组
    
    Returns:
    
    相应的基本类型的数组，如果array为null，则返回null
    
    Throws:
    
    java.lang.NullPointerException - 如果array中有元素为null
  - toPrimitive
```
public static short[] toPrimitive(java.lang.Short[] array,
                                  short valueForNull)
```
    功能描述：
    将数组转换成相应的基本类型数组。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 要被转换的数组
    
    valueForNull - 如果array中有元素为null，则其将被插入到基本类型数组中
    
    Returns:
    
    相应的基本类型的数组，如果array为null，则返回null
  - toObject
```
public static java.lang.Short[] toObject(short[] array)
```
    功能描述：
    将数组转换成相应的引用类型数组。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 要被转换的数组
    
    Returns:
    
    相应的引用类型数组，如果array为null，则返回null
    
    Throws:
    
    java.lang.NullPointerException - 如果array中有元素为null
  - toPrimitive
```
public static byte[] toPrimitive(java.lang.Byte[] array)
```
    功能描述：
    将数组转换成相应的基本类型数组。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 要被转换的数组
    
    Returns:
    
    相应的基本类型的数组，如果array为null，则返回null
    
    Throws:
    
    java.lang.NullPointerException - 如果array中有元素为null
  - toPrimitive
```
public static byte[] toPrimitive(java.lang.Byte[] array,
                                 byte valueForNull)
```
    功能描述：
    将数组转换成相应的基本类型数组。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 要被转换的数组
    
    valueForNull - 如果array中有元素为null，则其将被插入到基本类型数组中
    
    Returns:
    
    相应的基本类型的数组，如果array为null，则返回null
  - toObject
```
public static java.lang.Byte[] toObject(byte[] array)
```
    功能描述：
    将数组转换成相应的引用类型数组。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 要被转换的数组
    
    Returns:
    
    相应的引用类型数组，如果array为null，则返回null
    
    Throws:
    
    java.lang.NullPointerException - 如果array中有元素为null
  - toPrimitive
```
public static double[] toPrimitive(java.lang.Double[] array)
```
    功能描述：
    将数组转换成相应的基本类型数组。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 要被转换的数组
    
    Returns:
    
    相应的基本类型的数组，如果array为null，则返回null
    
    Throws:
    
    java.lang.NullPointerException - 如果array中有元素为null
  - toPrimitive
```
public static double[] toPrimitive(java.lang.Double[] array,
                                   double valueForNull)
```
    功能描述：
    将数组转换成相应的基本类型数组。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 要被转换的数组
    
    valueForNull - 如果array中有元素为null，则其将被插入到基本类型数组中
    
    Returns:
    
    相应的基本类型的数组，如果array为null，则返回null
  - toObject
```
public static java.lang.Double[] toObject(double[] array)
```
    功能描述：
    将数组转换成相应的引用类型数组。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 要被转换的数组
    
    Returns:
    
    相应的引用类型数组，如果array为null，则返回null
    
    Throws:
    
    java.lang.NullPointerException - 如果array中有元素为null
  - toPrimitive
```
public static float[] toPrimitive(java.lang.Float[] array)
```
    功能描述：
    将数组转换成相应的基本类型数组。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 要被转换的数组
    
    Returns:
    
    相应的基本类型的数组，如果array为null，则返回null
    
    Throws:
    
    java.lang.NullPointerException - 如果array中有元素为null
  - toPrimitive
```
public static float[] toPrimitive(java.lang.Float[] array,
                                  float valueForNull)
```
    功能描述：
    将数组转换成相应的基本类型数组。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 要被转换的数组
    
    valueForNull - 如果array中有元素为null，则其将被插入到基本类型数组中
    
    Returns:
    
    相应的基本类型的数组，如果array为null，则返回null
  - toObject
```
public static java.lang.Float[] toObject(float[] array)
```
    功能描述：
    将数组转换成相应的引用类型数组。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 要被转换的数组
    
    Returns:
    
    相应的引用类型数组，如果array为null，则返回null
    
    Throws:
    
    java.lang.NullPointerException - 如果array中有元素为null
  - toPrimitive
```
public static boolean[] toPrimitive(java.lang.Boolean[] array)
```
    功能描述：
    将数组转换成相应的基本类型数组。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 要被转换的数组
    
    Returns:
    
    相应的基本类型的数组，如果array为null，则返回null
    
    Throws:
    
    java.lang.NullPointerException - 如果array中有元素为null
  - toPrimitive
```
public static boolean[] toPrimitive(java.lang.Boolean[] array,
                                    boolean valueForNull)
```
    功能描述：
    将数组转换成相应的基本类型数组。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 要被转换的数组
    
    valueForNull - 如果array中有元素为null，则其将被插入到基本类型数组中
    
    Returns:
    
    相应的基本类型的数组，如果array为null，则返回null
  - toObject
```
public static java.lang.Boolean[] toObject(boolean[] array)
```
    功能描述：
    将数组转换成相应的引用类型数组。
    
    如果array为null，则返回null。
    
    Parameters:
    
    array - 要被转换的数组
    
    Returns:
    
    相应的引用类型数组，如果array为null，则返回null
    
    Throws:
    
    java.lang.NullPointerException - 如果array中有元素为null
  - isEmpty
```
public static boolean isEmpty(java.lang.Object[] array)
```
    功能描述：
    判断数组是否为null或者为空数组。
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    如果array为null或者为空数组，返回true，否则返回false
  - isEmpty
```
public static boolean isEmpty(long[] array)
```
    功能描述：
    判断数组是否为null或者为空数组。
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    如果array为null或者为空数组，返回true，否则返回false
  - isEmpty
```
public static boolean isEmpty(int[] array)
```
    功能描述：
    判断数组是否为null或者为空数组。
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    如果array为null或者为空数组，返回true，否则返回false
  - isEmpty
```
public static boolean isEmpty(short[] array)
```
    功能描述：
    判断数组是否为null或者为空数组。
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    如果array为null或者为空数组，返回true，否则返回false
  - isEmpty
```
public static boolean isEmpty(char[] array)
```
    功能描述：
    判断数组是否为null或者为空数组。
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    如果array为null或者为空数组，返回true，否则返回false
  - isEmpty
```
public static boolean isEmpty(byte[] array)
```
    功能描述：
    判断数组是否为null或者为空数组。
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    如果array为null或者为空数组，返回true，否则返回false
  - isEmpty
```
public static boolean isEmpty(double[] array)
```
    功能描述：
    判断数组是否为null或者为空数组。
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    如果array为null或者为空数组，返回true，否则返回false
  - isEmpty
```
public static boolean isEmpty(float[] array)
```
    功能描述：
    判断数组是否为null或者为空数组。
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    如果array为null或者为空数组，返回true，否则返回false
  - isEmpty
```
public static boolean isEmpty(boolean[] array)
```
    功能描述：
    判断数组是否为null或者为空数组。
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    如果array为null或者为空数组，返回true，否则返回false
  - isNotEmpty
```
public static boolean isNotEmpty(java.lang.Object[] array)
```
    功能描述：
    判断数组是否为null或者为空数组。
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    如果array为null或者为空数组，返回false，否则返回true
  - isNotEmpty
```
public static boolean isNotEmpty(long[] array)
```
    功能描述：
    判断数组是否为null或者为空数组。
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    如果array为null或者为空数组，返回false，否则返回true
  - isNotEmpty
```
public static boolean isNotEmpty(int[] array)
```
    功能描述：
    判断数组是否为null或者为空数组。
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    如果array为null或者为空数组，返回false，否则返回true
  - isNotEmpty
```
public static boolean isNotEmpty(short[] array)
```
    功能描述：
    判断数组是否为null或者为空数组。
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    如果array为null或者为空数组，返回false，否则返回true
  - isNotEmpty
```
public static boolean isNotEmpty(char[] array)
```
    功能描述：
    判断数组是否为null或者为空数组。
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    如果array为null或者为空数组，返回false，否则返回true
  - isNotEmpty
```
public static boolean isNotEmpty(byte[] array)
```
    功能描述：
    判断数组是否为null或者为空数组。
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    如果array为null或者为空数组，返回false，否则返回true
  - isNotEmpty
```
public static boolean isNotEmpty(double[] array)
```
    功能描述：
    判断数组是否为null或者为空数组。
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    如果array为null或者为空数组，返回false，否则返回true
  - isNotEmpty
```
public static boolean isNotEmpty(float[] array)
```
    功能描述：
    判断数组是否为null或者为空数组。
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    如果array为null或者为空数组，返回false，否则返回true
  - isNotEmpty
```
public static boolean isNotEmpty(boolean[] array)
```
    功能描述：
    判断数组是否为null或者为空数组。
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    如果array为null或者为空数组，返回false，否则返回true
  - addAll
```
public static java.lang.Object[] addAll(java.lang.Object[] array1,
                                        java.lang.Object[] array2)
```
    功能描述：
    合并两个数组，将结果作为新的数组返回。
    
    合并后的数组包含array1和array2中的所有元素。
```
 ArrayUtil.addAll(null, null)     = null
 ArrayUtil.addAll(array1, null)   = array1的一份拷贝
 ArrayUtil.addAll(null, array2)   = array2的一份拷贝
 ArrayUtil.addAll([], [])         = []
 ArrayUtil.addAll([null], [null]) = [null, null]
 ArrayUtil.addAll(["a", "b", "c"], ["1", "2", "3"]) = ["a", "b", "c", "1", "2", "3"]
 
```
    Parameters:
    
    array1 - 要合并的数组
    
    array2 - 要合并的数组
    
    Returns:
    
    合并后的数组，如果array1和array2都为null，则返回null。
    如果array1不为null，则返回的新的数组的类型和array1的类型相同，否则和array2的类型相同。
  - addAll
```
public static boolean[] addAll(boolean[] array1,
                               boolean[] array2)
```
    功能描述：
    合并两个数组，将结果作为新的数组返回。
    
    合并后的数组包含array1和array2中的所有元素。
```
 ArrayUtil.addAll(null, null)     = null
 ArrayUtil.addAll(array1, null)   = array1的一份拷贝
 ArrayUtil.addAll(null, array2)   = array2的一份拷贝
 ArrayUtil.addAll([], [])         = []
 
```
    Parameters:
    
    array1 - 要合并的数组
    
    array2 - 要合并的数组
    
    Returns:
    
    合并后的数组，如果array1和array2都为null，则返回null。
  - addAll
```
public static char[] addAll(char[] array1,
                            char[] array2)
```
    功能描述：
    合并两个数组，将结果作为新的数组返回。
    
    合并后的数组包含array1和array2中的所有元素。
```
 ArrayUtil.addAll(null, null)     = null
 ArrayUtil.addAll(array1, null)   = array1的一份拷贝
 ArrayUtil.addAll(null, array2)   = array2的一份拷贝
 ArrayUtil.addAll([], [])         = []
 
```
    Parameters:
    
    array1 - 要合并的数组
    
    array2 - 要合并的数组
    
    Returns:
    
    合并后的数组，如果array1和array2都为null，则返回null。
  - addAll
```
public static byte[] addAll(byte[] array1,
                            byte[] array2)
```
    功能描述：
    合并两个数组，将结果作为新的数组返回。
    
    合并后的数组包含array1和array2中的所有元素。
```
 ArrayUtil.addAll(null, null)     = null
 ArrayUtil.addAll(array1, null)   = array1的一份拷贝
 ArrayUtil.addAll(null, array2)   = array2的一份拷贝
 ArrayUtil.addAll([], [])         = []
 
```
    Parameters:
    
    array1 - 要合并的数组
    
    array2 - 要合并的数组
    
    Returns:
    
    合并后的数组，如果array1和array2都为null，则返回null。
  - addAll
```
public static short[] addAll(short[] array1,
                             short[] array2)
```
    功能描述：
    合并两个数组，将结果作为新的数组返回。
    
    合并后的数组包含array1和array2中的所有元素。
```
 ArrayUtil.addAll(null, null)     = null
 ArrayUtil.addAll(array1, null)   = array1的一份拷贝
 ArrayUtil.addAll(null, array2)   = array2的一份拷贝
 ArrayUtil.addAll([], [])         = []
 
```
    Parameters:
    
    array1 - 要合并的数组
    
    array2 - 要合并的数组
    
    Returns:
    
    合并后的数组，如果array1和array2都为null，则返回null。
  - addAll
```
public static int[] addAll(int[] array1,
                           int[] array2)
```
    功能描述：
    合并两个数组，将结果作为新的数组返回。
    
    合并后的数组包含array1和array2中的所有元素。
```
 ArrayUtil.addAll(null, null)     = null
 ArrayUtil.addAll(array1, null)   = array1的一份拷贝
 ArrayUtil.addAll(null, array2)   = array2的一份拷贝
 ArrayUtil.addAll([], [])         = []
 
```
    Parameters:
    
    array1 - 要合并的数组
    
    array2 - 要合并的数组
    
    Returns:
    
    合并后的数组，如果array1和array2都为null，则返回null。
  - addAll
```
public static long[] addAll(long[] array1,
                            long[] array2)
```
    功能描述：
    合并两个数组，将结果作为新的数组返回。
    
    合并后的数组包含array1和array2中的所有元素。
```
 ArrayUtil.addAll(null, null)     = null
 ArrayUtil.addAll(array1, null)   = array1的一份拷贝
 ArrayUtil.addAll(null, array2)   = array2的一份拷贝
 ArrayUtil.addAll([], [])         = []
 
```
    Parameters:
    
    array1 - 要合并的数组
    
    array2 - 要合并的数组
    
    Returns:
    
    合并后的数组，如果array1和array2都为null，则返回null。
  - addAll
```
public static float[] addAll(float[] array1,
                             float[] array2)
```
    功能描述：
    合并两个数组，将结果作为新的数组返回。
    
    合并后的数组包含array1和array2中的所有元素。
```
 ArrayUtil.addAll(null, null)     = null
 ArrayUtil.addAll(array1, null)   = array1的一份拷贝
 ArrayUtil.addAll(null, array2)   = array2的一份拷贝
 ArrayUtil.addAll([], [])         = []
 
```
    Parameters:
    
    array1 - 要合并的数组
    
    array2 - 要合并的数组
    
    Returns:
    
    合并后的数组，如果array1和array2都为null，则返回null。
  - addAll
```
public static double[] addAll(double[] array1,
                              double[] array2)
```
    功能描述：
    合并两个数组，将结果作为新的数组返回。
    
    合并后的数组包含array1和array2中的所有元素。
```
 ArrayUtil.addAll(null, null)     = null
 ArrayUtil.addAll(array1, null)   = array1的一份拷贝
 ArrayUtil.addAll(null, array2)   = array2的一份拷贝
 ArrayUtil.addAll([], [])         = []
 
```
    Parameters:
    
    array1 - 要合并的数组
    
    array2 - 要合并的数组
    
    Returns:
    
    合并后的数组，如果array1和array2都为null，则返回null。
  - add
```
public static java.lang.Object[] add(java.lang.Object[] array,
                                     java.lang.Object element)
```
    功能描述：
    将指定的元素添加到数组的末尾，将结果作为新的数组返回。
    
    新的数组包含array的所有元素和element。
```
 ArrayUtil.add(null, null)      = [null]
 ArrayUtil.add(null, "a")       = ["a"]
 ArrayUtil.add(["a"], null)     = ["a", null]
 ArrayUtil.add(["a"], "b")      = ["a", "b"]
 ArrayUtil.add(["a", "b"], "c") = ["a", "b", "c"]
 
```
    Parameters:
    
    array - 数组
    
    element - 元素
    
    Returns:
    
    新的数组，如果array不为null，则新的数组的类型和array的类型相同，否则和element的类型相同
  - add
```
public static boolean[] add(boolean[] array,
                            boolean element)
```
    功能描述：
    将指定的元素添加到数组的末尾，将结果作为新的数组返回。
    
    新的数组包含array的所有元素和element。
```
 ArrayUtil.add(null, true)          = [true]
 ArrayUtil.add([true], false)       = [true, false]
 ArrayUtil.add([true, false], true) = [true, false, true]
 
```
    Parameters:
    
    array - 数组
    
    element - 元素
    
    Returns:
    
    新的数组
  - add
```
public static byte[] add(byte[] array,
                         byte element)
```
    功能描述：
    将指定的元素添加到数组的末尾，将结果作为新的数组返回。
    
    新的数组包含array的所有元素和element。
```
 ArrayUtil.add(null, 0)   = [0]
 ArrayUtil.add([1], 0)    = [1, 0]
 ArrayUtil.add([1, 0], 1) = [1, 0, 1]
 
```
    Parameters:
    
    array - 数组
    
    element - 元素
    
    Returns:
    
    新的数组
  - add
```
public static char[] add(char[] array,
                         char element)
```
    功能描述：
    将指定的元素添加到数组的末尾，将结果作为新的数组返回。
    
    新的数组包含array的所有元素和element。
```
 ArrayUtil.add(null, '0')       = ['0']
 ArrayUtil.add(['1'], '0')      = ['1', '0']
 ArrayUtil.add(['1', '0'], '1') = ['1', '0', '1']
 
```
    Parameters:
    
    array - 数组
    
    element - 元素
    
    Returns:
    
    新的数组
  - add
```
public static double[] add(double[] array,
                           double element)
```
    功能描述：
    将指定的元素添加到数组的末尾，将结果作为新的数组返回。
    
    新的数组包含array的所有元素和element。
```
 ArrayUtil.add(null, 0)   = [0]
 ArrayUtil.add([1], 0)    = [1, 0]
 ArrayUtil.add([1, 0], 1) = [1, 0, 1]
 
```
    Parameters:
    
    array - 数组
    
    element - 元素
    
    Returns:
    
    新的数组
  - add
```
public static float[] add(float[] array,
                          float element)
```
    功能描述：
    将指定的元素添加到数组的末尾，将结果作为新的数组返回。
    
    新的数组包含array的所有元素和element。
```
 ArrayUtil.add(null, 0)   = [0]
 ArrayUtil.add([1], 0)    = [1, 0]
 ArrayUtil.add([1, 0], 1) = [1, 0, 1]
 
```
    Parameters:
    
    array - 数组
    
    element - 元素
    
    Returns:
    
    新的数组
  - add
```
public static int[] add(int[] array,
                        int element)
```
    功能描述：
    将指定的元素添加到数组的末尾，将结果作为新的数组返回。
    
    新的数组包含array的所有元素和element。
```
 ArrayUtil.add(null, 0)   = [0]
 ArrayUtil.add([1], 0)    = [1, 0]
 ArrayUtil.add([1, 0], 1) = [1, 0, 1]
 
```
    Parameters:
    
    array - 数组
    
    element - 元素
    
    Returns:
    
    新的数组
  - add
```
public static long[] add(long[] array,
                         long element)
```
    功能描述：
    将指定的元素添加到数组的末尾，将结果作为新的数组返回。
    
    新的数组包含array的所有元素和element。
```
 ArrayUtil.add(null, 0)   = [0]
 ArrayUtil.add([1], 0)    = [1, 0]
 ArrayUtil.add([1, 0], 1) = [1, 0, 1]
 
```
    Parameters:
    
    array - 数组
    
    element - 元素
    
    Returns:
    
    新的数组
  - add
```
public static short[] add(short[] array,
                          short element)
```
    功能描述：
    将指定的元素添加到数组的末尾，将结果作为新的数组返回。
    
    新的数组包含array的所有元素和element。
```
 ArrayUtil.add(null, 0)   = [0]
 ArrayUtil.add([1], 0)    = [1, 0]
 ArrayUtil.add([1, 0], 1) = [1, 0, 1]
 
```
    Parameters:
    
    array - 数组
    
    element - 元素
    
    Returns:
    
    新的数组
  - add
```
public static java.lang.Object[] add(java.lang.Object[] array,
                                     int index,
                                     java.lang.Object element)
```
    功能描述：
    将指定的元素添加到数组指定的索引处，将结果作为新的数组返回。
```
 ArrayUtil.add(null, 0, null)      = [null]
 ArrayUtil.add(null, 0, "a")       = ["a"]
 ArrayUtil.add(["a"], 1, null)     = ["a", null]
 ArrayUtil.add(["a"], 1, "b")      = ["a", "b"]
 ArrayUtil.add(["a", "b"], 3, "c") = ["a", "b", "c"]
 
```
    Parameters:
    
    array - 数组
    
    index - 索引
    
    element - 元素
    
    Returns:
    
    新的数组
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - 如果index超出了范围 (index < 0 || index > array.length)
  - add
```
public static boolean[] add(boolean[] array,
                            int index,
                            boolean element)
```
    功能描述：
    将指定的元素添加到数组指定的索引处，将结果作为新的数组返回。
```
 ArrayUtil.add(null, 0, true)          = [true]
 ArrayUtil.add([true], 0, false)       = [false, true]
 ArrayUtil.add([false], 1, true)       = [false, true]
 ArrayUtil.add([true, false], 1, true) = [true, true, false]
 
```
    Parameters:
    
    array - 数组
    
    index - 索引
    
    element - 元素
    
    Returns:
    
    新的数组
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - 如果index超出了范围 (index < 0 || index > array.length)
  - add
```
public static char[] add(char[] array,
                         int index,
                         char element)
```
    功能描述：
    将指定的元素添加到数组指定的索引处，将结果作为新的数组返回。
```
 ArrayUtil.add(null, 0, 'a')            = ['a']
 ArrayUtil.add(['a'], 0, 'b')           = ['b', 'a']
 ArrayUtil.add(['a', 'b'], 0, 'c')      = ['c', 'a', 'b']
 ArrayUtil.add(['a', 'b'], 1, 'k')      = ['a', 'k', 'b']
 ArrayUtil.add(['a', 'b', 'c'], 1, 't') = ['a', 't', 'b', 'c']
 
```
    Parameters:
    
    array - 数组
    
    index - 索引
    
    element - 元素
    
    Returns:
    
    新的数组
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - 如果index超出了范围 (index < 0 || index > array.length)
  - add
```
public static byte[] add(byte[] array,
                         int index,
                         byte element)
```
    功能描述：
    将指定的元素添加到数组指定的索引处，将结果作为新的数组返回。
```
 ArrayUtil.add([1], 0, 2)         = [2, 1]
 ArrayUtil.add([2, 6], 2, 3)      = [2, 6, 3]
 ArrayUtil.add([2, 6], 0, 1)      = [1, 2, 6]
 ArrayUtil.add([2, 6, 3], 2, 1)   = [2, 6, 1, 3]
 
```
    Parameters:
    
    array - 数组
    
    index - 索引
    
    element - 元素
    
    Returns:
    
    新的数组
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - 如果index超出了范围 (index < 0 || index > array.length)
  - add
```
public static short[] add(short[] array,
                          int index,
                          short element)
```
    功能描述：
    将指定的元素添加到数组指定的索引处，将结果作为新的数组返回。
```
 ArrayUtil.add([1], 0, 2)         = [2, 1]
 ArrayUtil.add([2, 6], 2, 3)      = [2, 6, 3]
 ArrayUtil.add([2, 6], 0, 1)      = [1, 2, 6]
 ArrayUtil.add([2, 6, 3], 2, 1)   = [2, 6, 1, 3]
 
```
    Parameters:
    
    array - 数组
    
    index - 索引
    
    element - 元素
    
    Returns:
    
    新的数组
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - 如果index超出了范围 (index < 0 || index > array.length)
  - add
```
public static int[] add(int[] array,
                        int index,
                        int element)
```
    功能描述：
    将指定的元素添加到数组指定的索引处，将结果作为新的数组返回。
```
 ArrayUtil.add([1], 0, 2)         = [2, 1]
 ArrayUtil.add([2, 6], 2, 3)      = [2, 6, 3]
 ArrayUtil.add([2, 6], 0, 1)      = [1, 2, 6]
 ArrayUtil.add([2, 6, 3], 2, 1)   = [2, 6, 1, 3]
 
```
    Parameters:
    
    array - 数组
    
    index - 索引
    
    element - 元素
    
    Returns:
    
    新的数组
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - 如果index超出了范围 (index < 0 || index > array.length)
  - add
```
public static long[] add(long[] array,
                         int index,
                         long element)
```
    功能描述：
    将指定的元素添加到数组指定的索引处，将结果作为新的数组返回。
```
 ArrayUtil.add([1L], 0, 2L)           = [2L, 1L]
 ArrayUtil.add([2L, 6L], 2, 10L)      = [2L, 6L, 10L]
 ArrayUtil.add([2L, 6L], 0, -4L)      = [-4L, 2L, 6L]
 ArrayUtil.add([2L, 6L, 3L], 2, 1L)   = [2L, 6L, 1L, 3L]
 
```
    Parameters:
    
    array - 数组
    
    index - 索引
    
    element - 元素
    
    Returns:
    
    新的数组
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - 如果index超出了范围 (index < 0 || index > array.length)
  - add
```
public static float[] add(float[] array,
                          int index,
                          float element)
```
    功能描述：
    将指定的元素添加到数组指定的索引处，将结果作为新的数组返回。
```
 ArrayUtil.add([1.1f], 0, 2.2f)               = [2.2f, 1.1f]
 ArrayUtil.add([2.3f, 6.4f], 2, 10.5f)        = [2.3f, 6.4f, 10.5f]
 ArrayUtil.add([2.6f, 6.7f], 0, -4.8f)        = [-4.8f, 2.6f, 6.7f]
 ArrayUtil.add([2.9f, 6.0f, 0.3f], 2, 1.0f)   = [2.9f, 6.0f, 1.0f, 0.3f]
 
```
    Parameters:
    
    array - 数组
    
    index - 索引
    
    element - 元素
    
    Returns:
    
    新的数组
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - 如果index超出了范围 (index < 0 || index > array.length)
  - add
```
public static double[] add(double[] array,
                           int index,
                           double element)
```
    功能描述：
    将指定的元素添加到数组指定的索引处，将结果作为新的数组返回。
```
 ArrayUtil.add([1.1], 0, 2.2)              = [2.2, 1.1]
 ArrayUtil.add([2.3, 6.4], 2, 10.5)        = [2.3, 6.4, 10.5]
 ArrayUtil.add([2.6, 6.7], 0, -4.8)        = [-4.8, 2.6, 6.7]
 ArrayUtil.add([2.9, 6.0, 0.3], 2, 1.0)    = [2.9, 6.0, 1.0, 0.3]
 
```
    Parameters:
    
    array - 数组
    
    index - 索引
    
    element - 元素
    
    Returns:
    
    新的数组
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - 如果index超出了范围 (index < 0 || index > array.length)
  - remove
```
public static java.lang.Object[] remove(java.lang.Object[] array,
                                        int index)
```
    功能描述：
    从数组中删除指定索引处的元素，将结果作为新的数组返回。
```
 ArrayUtil.remove(["a"], 0)           = []
 ArrayUtil.remove(["a", "b"], 0)      = ["b"]
 ArrayUtil.remove(["a", "b"], 1)      = ["a"]
 ArrayUtil.remove(["a", "b", "c"], 1) = ["a", "c"]
 
```
    Parameters:
    
    array - 数组
    
    index - 索引
    
    Returns:
    
    新的数组
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - 如果index超出了范围 (index < 0 || index >= array.length)，或者array为null
  - removeElement
```
public static java.lang.Object[] removeElement(java.lang.Object[] array,
                                               java.lang.Object element)
```
    功能描述：
    从数组中删除第一次出现的指定的元素，将结果作为新的数组返回。
    
    如果数组中不存在指定的元素，不做任何操作。
```
 ArrayUtil.removeElement(null, "a")            = null
 ArrayUtil.removeElement([], "a")              = []
 ArrayUtil.removeElement(["a"], "b")           = ["a"]
 ArrayUtil.removeElement(["a", "b"], "a")      = ["b"]
 ArrayUtil.removeElement(["a", "b", "a"], "a") = ["b", "a"]
 
```
    Parameters:
    
    array - 数组
    
    element - 元素
    
    Returns:
    
    新的数组
  - remove
```
public static boolean[] remove(boolean[] array,
                               int index)
```
    功能描述：
    从数组中删除指定索引处的元素，将结果作为新的数组返回。
```
 ArrayUtil.remove([true], 0)              = []
 ArrayUtil.remove([true, false], 0)       = [false]
 ArrayUtil.remove([true, false], 1)       = [true]
 ArrayUtil.remove([true, true, false], 1) = [true, false]
 
```
    Parameters:
    
    array - 数组
    
    index - 索引
    
    Returns:
    
    新的数组
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - 如果index超出了范围 (index < 0 || index >= array.length)，或者array为null
  - removeElement
```
public static boolean[] removeElement(boolean[] array,
                                      boolean element)
```
    功能描述：
    从数组中删除第一次出现的指定元素，将结果作为新的数组返回。
    
    如果数组中不存在指定元素，不做任何操作。
```
 ArrayUtil.removeElement(null, true)                = null
 ArrayUtil.removeElement([], true)                  = []
 ArrayUtil.removeElement([true], false)             = [true]
 ArrayUtil.removeElement([true, false], false)      = [true]
 ArrayUtil.removeElement([true, false, true], true) = [false, true]
 
```
    Parameters:
    
    array - 数组
    
    element - 元素
    
    Returns:
    
    新的数组
  - remove
```
public static byte[] remove(byte[] array,
                            int index)
```
    功能描述：
    从数组中删除指定索引处的元素，将结果作为新的数组返回。
```
 ArrayUtil.remove([1], 0)          = []
 ArrayUtil.remove([1, 0], 0)       = [0]
 ArrayUtil.remove([1, 0], 1)       = [1]
 ArrayUtil.remove([1, 0, 1], 1)    = [1, 1]
 
```
    Parameters:
    
    array - 数组
    
    index - 索引
    
    Returns:
    
    新的数组
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - 如果index超出了范围 (index < 0 || index >= array.length)，或者array为null
  - removeElement
```
public static byte[] removeElement(byte[] array,
                                   byte element)
```
    功能描述：
    从数组中删除第一次出现的指定元素，将结果作为新的数组返回。
    
    如果数组中不存在指定元素，不做任何操作。
```
 ArrayUtil.removeElement(null, 1)        = null
 ArrayUtil.removeElement([], 1)          = []
 ArrayUtil.removeElement([1], 0)         = [1]
 ArrayUtil.removeElement([1, 0], 0)      = [1]
 ArrayUtil.removeElement([1, 0, 1], 1)   = [0, 1]
 
```
    Parameters:
    
    array - 数组
    
    element - 元素
    
    Returns:
    
    新的数组
  - remove
```
public static char[] remove(char[] array,
                            int index)
```
    功能描述：
    从数组中删除指定索引处的元素，将结果作为新的数组返回。
```
 ArrayUtil.remove(['a'], 0)           = []
 ArrayUtil.remove(['a', 'b'], 0)      = ['b']
 ArrayUtil.remove(['a', 'b'], 1)      = ['a']
 ArrayUtil.remove(['a', 'b', 'c'], 1) = ['a', 'c']
 
```
    Parameters:
    
    array - 数组
    
    index - 索引
    
    Returns:
    
    新的数组
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - 如果index超出了范围 (index < 0 || index >= array.length)，或者array为null
  - removeElement
```
public static char[] removeElement(char[] array,
                                   char element)
```
    功能描述：
    从数组中删除第一次出现的指定元素，将结果作为新的数组返回。
    
    如果数组中不存在指定元素，不做任何操作。
```
 ArrayUtil.removeElement(null, 'a')            = null
 ArrayUtil.removeElement([], 'a')              = []
 ArrayUtil.removeElement(['a'], 'b')           = ['a']
 ArrayUtil.removeElement(['a', 'b'], 'a')      = ['b']
 ArrayUtil.removeElement(['a', 'b', 'a'], 'a') = ['b', 'a']
 
```
    Parameters:
    
    array - 数组
    
    element - 元素
    
    Returns:
    
    新的数组
  - remove
```
public static double[] remove(double[] array,
                              int index)
```
    功能描述：
    从数组中删除指定索引处的元素，将结果作为新的数组返回。
```
 ArrayUtil.remove([1.1], 0)           = []
 ArrayUtil.remove([2.5, 6.0], 0)      = [6.0]
 ArrayUtil.remove([2.5, 6.0], 1)      = [2.5]
 ArrayUtil.remove([2.5, 6.0, 3.8], 1) = [2.5, 3.8]
 
```
    Parameters:
    
    array - 数组
    
    index - 索引
    
    Returns:
    
    新的数组
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - 如果index超出了范围 (index < 0 || index >= array.length)，或者array为null
  - removeElement
```
public static double[] removeElement(double[] array,
                                     double element)
```
    功能描述：
    从数组中删除第一次出现的指定元素，将结果作为新的数组返回。
    
    如果数组中不存在指定元素，不做任何操作。
```
 ArrayUtil.removeElement(null, 1.1)            = null
 ArrayUtil.removeElement([], 1.1)              = []
 ArrayUtil.removeElement([1.1], 1.2)           = [1.1]
 ArrayUtil.removeElement([1.1, 2.3], 1.1)      = [2.3]
 ArrayUtil.removeElement([1.1, 2.3, 1.1], 1.1) = [2.3, 1.1]
 
```
    Parameters:
    
    array - 数组
    
    element - 元素
    
    Returns:
    
    新的数组
  - remove
```
public static float[] remove(float[] array,
                             int index)
```
    功能描述：
    从数组中删除指定索引处的元素，将结果作为新的数组返回。
```
 ArrayUtil.remove([1.1], 0)           = []
 ArrayUtil.remove([2.5, 6.0], 0)      = [6.0]
 ArrayUtil.remove([2.5, 6.0], 1)      = [2.5]
 ArrayUtil.remove([2.5, 6.0, 3.8], 1) = [2.5, 3.8]
 
```
    Parameters:
    
    array - 数组
    
    index - 索引
    
    Returns:
    
    新的数组
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - 如果index超出了范围 (index < 0 || index >= array.length)，或者array为null
  - removeElement
```
public static float[] removeElement(float[] array,
                                    float element)
```
    功能描述：
    从数组中删除第一次出现的指定元素，将结果作为新的数组返回。
    
    如果数组中不存在指定元素，不做任何操作。
```
 ArrayUtil.removeElement(null, 1.1)            = null
 ArrayUtil.removeElement([], 1.1)              = []
 ArrayUtil.removeElement([1.1], 1.2)           = [1.1]
 ArrayUtil.removeElement([1.1, 2.3], 1.1)      = [2.3]
 ArrayUtil.removeElement([1.1, 2.3, 1.1], 1.1) = [2.3, 1.1]
 
```
    Parameters:
    
    array - 数组
    
    element - 元素
    
    Returns:
    
    新的数组
  - remove
```
public static int[] remove(int[] array,
                           int index)
```
    功能描述：
    从数组中删除指定索引处的元素，将结果作为新的数组返回。
```
 ArrayUtil.remove([1], 0)         = []
 ArrayUtil.remove([2, 6], 0)      = [6]
 ArrayUtil.remove([2, 6], 1)      = [2]
 ArrayUtil.remove([2, 6, 3], 1)   = [2, 3]
 
```
    Parameters:
    
    array - 数组
    
    index - 索引
    
    Returns:
    
    新的数组
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - 如果index超出了范围 (index < 0 || index >= array.length)，或者array为null
  - removeElement
```
public static int[] removeElement(int[] array,
                                  int element)
```
    功能描述：
    从数组中删除第一次出现的指定元素，将结果作为新的数组返回。
    
    如果数组中不存在指定元素，不做任何操作。
```
 ArrayUtil.removeElement(null, 1)      = null
 ArrayUtil.removeElement([], 1)        = []
 ArrayUtil.removeElement([1], 2)       = [1]
 ArrayUtil.removeElement([1, 3], 1)    = [3]
 ArrayUtil.removeElement([1, 3, 1], 1) = [3, 1]
 
```
    Parameters:
    
    array - 数组
    
    element - 元素
    
    Returns:
    
    新的数组
  - remove
```
public static long[] remove(long[] array,
                            int index)
```
    功能描述：
    从数组中删除指定索引处的元素，将结果作为新的数组返回。
```
 ArrayUtil.remove([1], 0)         = []
 ArrayUtil.remove([2, 6], 0)      = [6]
 ArrayUtil.remove([2, 6], 1)      = [2]
 ArrayUtil.remove([2, 6, 3], 1)   = [2, 3]
 
```
    Parameters:
    
    array - 数组
    
    index - 索引
    
    Returns:
    
    新的数组
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - 如果index超出了范围 (index < 0 || index >= array.length)，或者array为null
  - removeElement
```
public static long[] removeElement(long[] array,
                                   long element)
```
    功能描述：
    从数组中删除第一次出现的指定元素，将结果作为新的数组返回。
    
    如果数组中不存在指定元素，不做任何操作。
```
 ArrayUtil.removeElement(null, 1)      = null
 ArrayUtil.removeElement([], 1)        = []
 ArrayUtil.removeElement([1], 2)       = [1]
 ArrayUtil.removeElement([1, 3], 1)    = [3]
 ArrayUtil.removeElement([1, 3, 1], 1) = [3, 1]
 
```
    Parameters:
    
    array - 数组
    
    element - 元素
    
    Returns:
    
    新的数组
  - remove
```
public static short[] remove(short[] array,
                             int index)
```
    功能描述：
    从数组中删除指定索引处的元素，将结果作为新的数组返回。
```
 ArrayUtil.remove([1], 0)         = []
 ArrayUtil.remove([2, 6], 0)      = [6]
 ArrayUtil.remove([2, 6], 1)      = [2]
 ArrayUtil.remove([2, 6, 3], 1)   = [2, 3]
 
```
    Parameters:
    
    array - 数组
    
    index - 索引
    
    Returns:
    
    新的数组
    
    Throws:
    
    java.lang.IndexOutOfBoundsException - 如果index超出了范围 (index < 0 || index >= array.length)，或者array为null
  - removeElement
```
public static short[] removeElement(short[] array,
                                    short element)
```
    功能描述：
    从数组中删除第一次出现的指定元素，将结果作为新的数组返回。
    
    如果数组中不存在指定元素，不做任何操作。
```
 ArrayUtil.removeElement(null, 1)      = null
 ArrayUtil.removeElement([], 1)        = []
 ArrayUtil.removeElement([1], 2)       = [1]
 ArrayUtil.removeElement([1, 3], 1)    = [3]
 ArrayUtil.removeElement([1, 3, 1], 1) = [3, 1]
 
```
    Parameters:
    
    array - 数组
    
    element - 元素
    
    Returns:
    
    新的数组

Class ArrayUtil

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

EMPTY_OBJECT_ARRAY

EMPTY_CLASS_ARRAY

EMPTY_STRING_ARRAY

EMPTY_LONG_ARRAY

EMPTY_LONG_OBJECT_ARRAY

EMPTY_INT_ARRAY

EMPTY_INTEGER_OBJECT_ARRAY

EMPTY_SHORT_ARRAY

EMPTY_SHORT_OBJECT_ARRAY

EMPTY_BYTE_ARRAY

EMPTY_BYTE_OBJECT_ARRAY

EMPTY_DOUBLE_ARRAY

EMPTY_DOUBLE_OBJECT_ARRAY

EMPTY_FLOAT_ARRAY

EMPTY_FLOAT_OBJECT_ARRAY

EMPTY_BOOLEAN_ARRAY

EMPTY_BOOLEAN_OBJECT_ARRAY

EMPTY_CHAR_ARRAY

EMPTY_CHARACTER_OBJECT_ARRAY

INDEX_NOT_FOUND

Constructor Detail

ArrayUtil

Method Detail

toString

toString

isEquals

clone

clone

clone

clone

clone

clone

clone

clone

clone

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

subarray

subarray

subarray

subarray

subarray

subarray

subarray

subarray

subarray

isSameLength

isSameLength

isSameLength

isSameLength

isSameLength

isSameLength

isSameLength

isSameLength

isSameLength

getLength

isSameType

reverse