ArrayUtil (schedulerX-client 2.1.5 API)

java.lang.Object
- com.alibaba.tmq.client.util.ArrayUtil

```
public class ArrayUtil
extends Object
```
有关数组处理的工具类。这个类中的每个方法都可以“安全”地处理null，而不会抛出NullPointerException。

版本:

$Id: ArrayUtil.java 1479 2006-01-13 05:40:46Z baobao $

作者:

Michael Zhou

字段概要

字段
限定符和类型	字段和说明
`static boolean[]`	`EMPTY_BOOLEAN_ARRAY` 空的`boolean`数组。
`static Boolean[]`	`EMPTY_BOOLEAN_OBJECT_ARRAY` 空的`Boolean`数组。
`static byte[]`	`EMPTY_BYTE_ARRAY` 空的`byte`数组。
`static Byte[]`	`EMPTY_BYTE_OBJECT_ARRAY` 空的`Byte`数组。
`static char[]`	`EMPTY_CHAR_ARRAY` 空的`char`数组。
`static Character[]`	`EMPTY_CHARACTER_OBJECT_ARRAY` 空的`Character`数组。
`static Class[]`	`EMPTY_CLASS_ARRAY` 空的`Class`数组。
`static double[]`	`EMPTY_DOUBLE_ARRAY` 空的`double`数组。
`static Double[]`	`EMPTY_DOUBLE_OBJECT_ARRAY` 空的`Double`数组。
`static float[]`	`EMPTY_FLOAT_ARRAY` 空的`float`数组。
`static Float[]`	`EMPTY_FLOAT_OBJECT_ARRAY` 空的`Float`数组。
`static int[]`	`EMPTY_INT_ARRAY` 空的`int`数组。
`static Integer[]`	`EMPTY_INTEGER_OBJECT_ARRAY` 空的`Integer`数组。
`static long[]`	`EMPTY_LONG_ARRAY` 空的`long`数组。
`static Long[]`	`EMPTY_LONG_OBJECT_ARRAY` 空的`Long`数组。
`static Object[]`	`EMPTY_OBJECT_ARRAY` 空的`Object`数组。
`static short[]`	`EMPTY_SHORT_ARRAY` 空的`short`数组。
`static Short[]`	`EMPTY_SHORT_OBJECT_ARRAY` 空的`Short`数组。
`static String[]`	`EMPTY_STRING_ARRAY` 空的`String`数组。

构造器概要

构造器
构造器和说明

ArrayUtil()

构造器
构造器和说明
`ArrayUtil()`

方法概要

所有方法静态方法具体方法
限定符和类型	方法和说明
`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 Object[]`	`clone(Object[] array)` 复制一个数组。
`static short[]`	`clone(short[] array)` 复制一个数组。
`static boolean`	`contains(boolean[] array, boolean booleanToFind)` 判断指定对象是否存在于指定数组中。
`static boolean`	`contains(boolean[] array, boolean[] arrayToFind)` 判断指定元素序列是否存在于指定数组中。
`static boolean`	`contains(byte[] array, byte byteToFind)` 判断指定对象是否存在于指定数组中。
`static boolean`	`contains(byte[] array, byte[] arrayToFind)` 判断指定元素序列是否存在于指定数组中。
`static boolean`	`contains(char[] array, char charToFind)` 判断指定对象是否存在于指定数组中。
`static boolean`	`contains(char[] array, char[] arrayToFind)` 判断指定元素序列是否存在于指定数组中。
`static boolean`	`contains(double[] array, double doubleToFind)` 判断指定对象是否存在于指定数组中。
`static boolean`	`contains(double[] array, double[] arrayToFind)` 判断指定元素序列是否存在于指定数组中。
`static boolean`	`contains(double[] array, double[] arrayToFind, double tolerance)` 判断指定元素序列是否存在于指定数组中。
`static boolean`	`contains(double[] array, double doubleToFind, double tolerance)` 判断指定对象是否存在于指定数组中。
`static boolean`	`contains(float[] array, float floatToFind)` 判断指定对象是否存在于指定数组中。
`static boolean`	`contains(float[] array, float[] arrayToFind)` 判断指定元素序列是否存在于指定数组中。
`static boolean`	`contains(float[] array, float[] arrayToFind, float tolerance)` 判断指定元素序列是否存在于指定数组中。
`static boolean`	`contains(float[] array, float floatToFind, float tolerance)` 判断指定对象是否存在于指定数组中。
`static boolean`	`contains(int[] array, int intToFind)` 判断指定对象是否存在于指定数组中。
`static boolean`	`contains(int[] array, int[] arrayToFind)` 判断指定元素序列是否存在于指定数组中。
`static boolean`	`contains(long[] array, long longToFind)` 判断指定对象是否存在于指定数组中。
`static boolean`	`contains(long[] array, long[] arrayToFind)` 判断指定元素序列是否存在于指定数组中。
`static boolean`	`contains(Object[] array, Object objectToFind)` 判断指定对象是否存在于指定数组中。
`static boolean`	`contains(Object[] array, Object[] arrayToFind)` 判断指定元素序列是否存在于指定数组中。
`static boolean`	`contains(short[] array, short shortToFind)` 判断指定对象是否存在于指定数组中。
`static boolean`	`contains(short[] array, short[] arrayToFind)` 判断指定元素序列是否存在于指定数组中。
`static boolean[]`	`defaultIfEmpty(boolean[] array)` 如果数组是`null`或空数组`[]`，则返回空数组`[]`，否则返回数组本身。
`static boolean[]`	`defaultIfEmpty(boolean[] array, boolean[] defaultArray)` 如果数组是`null`或空数组`[]`，则返回指定默认数组，否则返回数组本身。
`static byte[]`	`defaultIfEmpty(byte[] array)` 如果数组是`null`或空数组`[]`，则返回空数组`[]`，否则返回数组本身。
`static byte[]`	`defaultIfEmpty(byte[] array, byte[] defaultArray)` 如果数组是`null`或空数组`[]`，则返回指定默认数组，否则返回数组本身。
`static char[]`	`defaultIfEmpty(char[] array)` 如果数组是`null`或空数组`[]`，则返回空数组`[]`，否则返回数组本身。
`static char[]`	`defaultIfEmpty(char[] array, char[] defaultArray)` 如果数组是`null`或空数组`[]`，则返回指定默认数组，否则返回数组本身。
`static double[]`	`defaultIfEmpty(double[] array)` 如果数组是`null`或空数组`[]`，则返回空数组`[]`，否则返回数组本身。
`static double[]`	`defaultIfEmpty(double[] array, double[] defaultArray)` 如果数组是`null`或空数组`[]`，则返回指定默认数组，否则返回数组本身。
`static float[]`	`defaultIfEmpty(float[] array)` 如果数组是`null`或空数组`[]`，则返回空数组`[]`，否则返回数组本身。
`static float[]`	`defaultIfEmpty(float[] array, float[] defaultArray)` 如果数组是`null`或空数组`[]`，则返回指定默认数组，否则返回数组本身。
`static int[]`	`defaultIfEmpty(int[] array)` 如果数组是`null`或空数组`[]`，则返回空数组`[]`，否则返回数组本身。
`static int[]`	`defaultIfEmpty(int[] array, int[] defaultArray)` 如果数组是`null`或空数组`[]`，则返回指定默认数组，否则返回数组本身。
`static long[]`	`defaultIfEmpty(long[] array)` 如果数组是`null`或空数组`[]`，则返回空数组`[]`，否则返回数组本身。
`static long[]`	`defaultIfEmpty(long[] array, long[] defaultArray)` 如果数组是`null`或空数组`[]`，则返回指定默认数组，否则返回数组本身。
`static Object[]`	`defaultIfEmpty(Object[] array)` 如果数组是`null`或空数组`[]`，则返回空数组`[]`，否则返回数组本身。
`static Object[]`	`defaultIfEmpty(Object[] array, Class defaultComponentType)` 如果数组是`null`或空数组`[]`，则返回指定元素类型的空数组，否则返回数组本身。
`static Object[]`	`defaultIfEmpty(Object[] array, Object[] defaultArray)` 如果数组是`null`或空数组`[]`，则返回指定默认数组，否则返回数组本身。
`static short[]`	`defaultIfEmpty(short[] array)` 如果数组是`null`或空数组`[]`，则返回空数组`[]`，否则返回数组本身。
`static short[]`	`defaultIfEmpty(short[] array, short[] defaultArray)` 如果数组是`null`或空数组`[]`，则返回指定默认数组，否则返回数组本身。
`static boolean[]`	`defaultIfNull(boolean[] array)` 如果数组是`null`，则返回空数组`[]`，否则返回数组本身。
`static boolean[]`	`defaultIfNull(boolean[] array, boolean[] defaultArray)` 如果数组是`null`，则返回指定默认数组，否则返回数组本身。
`static byte[]`	`defaultIfNull(byte[] array)` 如果数组是`null`，则返回空数组`[]`，否则返回数组本身。
`static byte[]`	`defaultIfNull(byte[] array, byte[] defaultArray)` 如果数组是`null`，则返回指定默认数组，否则返回数组本身。
`static char[]`	`defaultIfNull(char[] array)` 如果数组是`null`，则返回空数组`[]`，否则返回数组本身。
`static char[]`	`defaultIfNull(char[] array, char[] defaultArray)` 如果数组是`null`，则返回指定默认数组，否则返回数组本身。
`static double[]`	`defaultIfNull(double[] array)` 如果数组是`null`，则返回空数组`[]`，否则返回数组本身。
`static double[]`	`defaultIfNull(double[] array, double[] defaultArray)` 如果数组是`null`，则返回指定默认数组，否则返回数组本身。
`static float[]`	`defaultIfNull(float[] array)` 如果数组是`null`，则返回空数组`[]`，否则返回数组本身。
`static float[]`	`defaultIfNull(float[] array, float[] defaultArray)` 如果数组是`null`，则返回指定默认数组，否则返回数组本身。
`static int[]`	`defaultIfNull(int[] array)` 如果数组是`null`，则返回空数组`[]`，否则返回数组本身。
`static int[]`	`defaultIfNull(int[] array, int[] defaultArray)` 如果数组是`null`，则返回指定默认数组，否则返回数组本身。
`static long[]`	`defaultIfNull(long[] array)` 如果数组是`null`，则返回空数组`[]`，否则返回数组本身。
`static long[]`	`defaultIfNull(long[] array, long[] defaultArray)` 如果数组是`null`，则返回指定默认数组，否则返回数组本身。
`static Object[]`	`defaultIfNull(Object[] array)` 如果数组是`null`，则返回空数组`[]`，否则返回数组本身。
`static Object[]`	`defaultIfNull(Object[] array, Class defaultComponentType)` 如果数组是`null`，则返回指定元素类型的空数组，否则返回数组本身。
`static Object[]`	`defaultIfNull(Object[] array, Object[] defaultArray)` 如果数组是`null`，则返回指定默认数组，否则返回数组本身。
`static short[]`	`defaultIfNull(short[] array)` 如果数组是`null`，则返回空数组`[]`，否则返回数组本身。
`static short[]`	`defaultIfNull(short[] array, short[] defaultArray)` 如果数组是`null`，则返回指定默认数组，否则返回数组本身。
`static boolean`	`equals(Object array1, Object array2)` 递归地比较两个数组是否相同，支持多维数组。
`static int`	`hashCode(Object array)` 取得数组的hash值, 如果数组为`null`, 则返回`0`。
`static int`	`indexOf(boolean[] array, boolean booleanToFind)` 在数组中查找一个元素。
`static int`	`indexOf(boolean[] array, boolean[] arrayToFind)` 在数组中查找一个元素序列。
`static int`	`indexOf(boolean[] array, boolean[] arrayToFind, int startIndex)` 在数组中查找一个元素序列。
`static int`	`indexOf(boolean[] array, boolean booleanToFind, int startIndex)` 在数组中查找一个元素。
`static int`	`indexOf(byte[] array, byte byteToFind)` 在数组中查找一个元素。
`static int`	`indexOf(byte[] array, byte[] arrayToFind)` 在数组中查找一个元素序列。
`static int`	`indexOf(byte[] array, byte[] arrayToFind, int startIndex)` 在数组中查找一个元素序列。
`static int`	`indexOf(byte[] array, byte byteToFind, int startIndex)` 在数组中查找一个元素。
`static int`	`indexOf(char[] array, char charToFind)` 在数组中查找一个元素。
`static int`	`indexOf(char[] array, char[] arrayToFind)` 在数组中查找一个元素序列。
`static int`	`indexOf(char[] array, char[] arrayToFind, int startIndex)` 在数组中查找一个元素序列。
`static int`	`indexOf(char[] array, char charToFind, int startIndex)` 在数组中查找一个元素。
`static int`	`indexOf(double[] array, double doubleToFind)` 在数组中查找一个元素。
`static int`	`indexOf(double[] array, double[] arrayToFind)` 在数组中查找一个元素序列。
`static int`	`indexOf(double[] array, double[] arrayToFind, double tolerance)` 在数组中查找一个元素序列。
`static int`	`indexOf(double[] array, double[] arrayToFind, int startIndex)` 在数组中查找一个元素序列。
`static int`	`indexOf(double[] array, double[] arrayToFind, int startIndex, double tolerance)` 在数组中查找一个元素序列。
`static int`	`indexOf(double[] array, double doubleToFind, double tolerance)` 在数组中查找一个元素。
`static int`	`indexOf(double[] array, double doubleToFind, int startIndex)` 在数组中查找一个元素。
`static int`	`indexOf(double[] array, double doubleToFind, int startIndex, double tolerance)` 在数组中查找一个元素。
`static int`	`indexOf(float[] array, float floatToFind)` 在数组中查找一个元素。
`static int`	`indexOf(float[] array, float[] arrayToFind)` 在数组中查找一个元素序列。
`static int`	`indexOf(float[] array, float[] arrayToFind, float tolerance)` 在数组中查找一个元素序列。
`static int`	`indexOf(float[] array, float[] arrayToFind, int startIndex)` 在数组中查找一个元素序列。
`static int`	`indexOf(float[] array, float[] arrayToFind, int startIndex, float tolerance)` 在数组中查找一个元素序列。
`static int`	`indexOf(float[] array, float floatToFind, float tolerance)` 在数组中查找一个元素。
`static int`	`indexOf(float[] array, float floatToFind, int startIndex)` 在数组中查找一个元素。
`static int`	`indexOf(float[] array, float floatToFind, int startIndex, float tolerance)` 在数组中查找一个元素。
`static int`	`indexOf(int[] array, int intToFind)` 在数组中查找一个元素。
`static int`	`indexOf(int[] array, int[] arrayToFind)` 在数组中查找一个元素序列。
`static int`	`indexOf(int[] array, int[] arrayToFind, int startIndex)` 在数组中查找一个元素序列。
`static int`	`indexOf(int[] array, int intToFind, int startIndex)` 在数组中查找一个元素。
`static int`	`indexOf(long[] array, long longToFind)` 在数组中查找一个元素。
`static int`	`indexOf(long[] array, long[] arrayToFind)` 在数组中查找一个元素序列。
`static int`	`indexOf(long[] array, long[] arrayToFind, int startIndex)` 在数组中查找一个元素序列。
`static int`	`indexOf(long[] array, long longToFind, int startIndex)` 在数组中查找一个元素。
`static int`	`indexOf(Object[] array, Object objectToFind)` 在数组中查找一个元素。
`static int`	`indexOf(Object[] array, Object[] arrayToFind)` 在数组中查找一个元素序列。
`static int`	`indexOf(Object[] array, Object[] arrayToFind, int startIndex)` 在数组中查找一个元素序列。
`static int`	`indexOf(Object[] array, Object objectToFind, int startIndex)` 在数组中查找一个元素。
`static int`	`indexOf(short[] array, short shortToFind)` 在数组中查找一个元素。
`static int`	`indexOf(short[] array, short[] arrayToFind)` 在数组中查找一个元素序列。
`static int`	`indexOf(short[] array, short[] arrayToFind, int startIndex)` 在数组中查找一个元素序列。
`static int`	`indexOf(short[] array, short shortToFind, int startIndex)` 在数组中查找一个元素。
`static boolean`	`isEmpty(boolean[] array)` 检查数组是否为`null`或空数组`[]`。
`static boolean`	`isEmpty(byte[] array)` 检查数组是否为`null`或空数组`[]`。
`static boolean`	`isEmpty(char[] array)` 检查数组是否为`null`或空数组`[]`。
`static boolean`	`isEmpty(double[] array)` 检查数组是否为`null`或空数组`[]`。
`static boolean`	`isEmpty(float[] array)` 检查数组是否为`null`或空数组`[]`。
`static boolean`	`isEmpty(int[] array)` 检查数组是否为`null`或空数组`[]`。
`static boolean`	`isEmpty(long[] array)` 检查数组是否为`null`或空数组`[]`。
`static boolean`	`isEmpty(Object[] array)` 检查数组是否为`null`或空数组`[]`。
`static boolean`	`isEmpty(short[] array)` 检查数组是否为`null`或空数组`[]`。
`static boolean`	`isNotEmpty(boolean[] array)` 检查数组是否不是`null`和空数组`[]`。
`static boolean`	`isNotEmpty(byte[] array)` 检查数组是否不是`null`和空数组`[]`。
`static boolean`	`isNotEmpty(char[] array)` 检查数组是否不是`null`和空数组`[]`。
`static boolean`	`isNotEmpty(double[] array)` 检查数组是否不是`null`和空数组`[]`。
`static boolean`	`isNotEmpty(float[] array)` 检查数组是否不是`null`和空数组`[]`。
`static boolean`	`isNotEmpty(int[] array)` 检查数组是否不是`null`和空数组`[]`。
`static boolean`	`isNotEmpty(long[] array)` 检查数组是否不是`null`和空数组`[]`。
`static boolean`	`isNotEmpty(Object[] array)` 检查数组是否不是`null`和空数组`[]`。
`static boolean`	`isNotEmpty(short[] array)` 检查数组是否不是`null`和空数组`[]`。
`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(Object[] array1, Object[] array2)` 判断两个数组是否具有相同的长度。
`static boolean`	`isSameLength(short[] array1, short[] array2)` 判断两个数组是否具有相同的长度。
`static int`	`lastIndexOf(boolean[] array, boolean booleanToFind)` 在数组中从末尾开始查找一个元素。
`static int`	`lastIndexOf(boolean[] array, boolean[] arrayToFind)` 在数组中从末尾开始查找一个元素序列。
`static int`	`lastIndexOf(boolean[] array, boolean[] arrayToFind, int startIndex)` 在数组中从末尾开始查找一个元素序列。
`static int`	`lastIndexOf(boolean[] array, boolean booleanToFind, int startIndex)` 在数组中从末尾开始查找一个元素。
`static int`	`lastIndexOf(byte[] array, byte byteToFind)` 在数组中从末尾开始查找一个元素。
`static int`	`lastIndexOf(byte[] array, byte[] arrayToFind)` 在数组中从末尾开始查找一个元素序列。
`static int`	`lastIndexOf(byte[] array, byte[] arrayToFind, int startIndex)` 在数组中从末尾开始查找一个元素序列。
`static int`	`lastIndexOf(byte[] array, byte byteToFind, int startIndex)` 在数组中从末尾开始查找一个元素。
`static int`	`lastIndexOf(char[] array, char charToFind)` 在数组中从末尾开始查找一个元素。
`static int`	`lastIndexOf(char[] array, char[] arrayToFind)` 在数组中从末尾开始查找一个元素序列。
`static int`	`lastIndexOf(char[] array, char[] arrayToFind, int startIndex)` 在数组中从末尾开始查找一个元素序列。
`static int`	`lastIndexOf(char[] array, char charToFind, int startIndex)` 在数组中从末尾开始查找一个元素。
`static int`	`lastIndexOf(double[] array, double doubleToFind)` 在数组中从末尾开始查找一个元素。
`static int`	`lastIndexOf(double[] array, double[] arrayToFind)` 在数组中从末尾开始查找一个元素序列。
`static int`	`lastIndexOf(double[] array, double[] arrayToFind, double tolerance)` 在数组中从末尾开始查找一个元素序列。
`static int`	`lastIndexOf(double[] array, double[] arrayToFind, int startIndex)` 在数组中从末尾开始查找一个元素序列。
`static int`	`lastIndexOf(double[] array, double[] arrayToFind, int startIndex, double tolerance)` 在数组中从末尾开始查找一个元素序列。
`static int`	`lastIndexOf(double[] array, double doubleToFind, double tolerance)` 在数组中从末尾开始查找一个元素。
`static int`	`lastIndexOf(double[] array, double doubleToFind, int startIndex)` 在数组中从末尾开始查找一个元素。
`static int`	`lastIndexOf(double[] array, double doubleToFind, int startIndex, double tolerance)` 在数组中从末尾开始查找一个元素。
`static int`	`lastIndexOf(float[] array, float floatToFind)` 在数组中从末尾开始查找一个元素。
`static int`	`lastIndexOf(float[] array, float[] arrayToFind)` 在数组中从末尾开始查找一个元素序列。
`static int`	`lastIndexOf(float[] array, float[] arrayToFind, float tolerance)` 在数组中从末尾开始查找一个元素序列。
`static int`	`lastIndexOf(float[] array, float[] arrayToFind, int startIndex)` 在数组中从末尾开始查找一个元素序列。
`static int`	`lastIndexOf(float[] array, float[] arrayToFind, int startIndex, float tolerance)` 在数组中从末尾开始查找一个元素序列。
`static int`	`lastIndexOf(float[] array, float floatToFind, float tolerance)` 在数组中从末尾开始查找一个元素。
`static int`	`lastIndexOf(float[] array, float floatToFind, int startIndex)` 在数组中从末尾开始查找一个元素。
`static int`	`lastIndexOf(float[] array, float floatToFind, int startIndex, float tolerance)` 在数组中从末尾开始查找一个元素。
`static int`	`lastIndexOf(int[] array, int intToFind)` 在数组中从末尾开始查找一个元素。
`static int`	`lastIndexOf(int[] array, int[] arrayToFind)` 在数组中从末尾开始查找一个元素序列。
`static int`	`lastIndexOf(int[] array, int[] arrayToFind, int startIndex)` 在数组中从末尾开始查找一个元素序列。
`static int`	`lastIndexOf(int[] array, int intToFind, int startIndex)` 在数组中从末尾开始查找一个元素。
`static int`	`lastIndexOf(long[] array, long longToFind)` 在数组中从末尾开始查找一个元素。
`static int`	`lastIndexOf(long[] array, long[] arrayToFind)` 在数组中从末尾开始查找一个元素序列。
`static int`	`lastIndexOf(long[] array, long[] arrayToFind, int startIndex)` 在数组中从末尾开始查找一个元素序列。
`static int`	`lastIndexOf(long[] array, long longToFind, int startIndex)` 在数组中从末尾开始查找一个元素。
`static int`	`lastIndexOf(Object[] array, Object objectToFind)` 在数组中从末尾开始查找一个元素。
`static int`	`lastIndexOf(Object[] array, Object[] arrayToFind)` 在数组中从末尾开始查找一个元素序列。
`static int`	`lastIndexOf(Object[] array, Object[] arrayToFind, int startIndex)` 在数组中从末尾开始查找一个元素序列。
`static int`	`lastIndexOf(Object[] array, Object objectToFind, int startIndex)` 在数组中从末尾开始查找一个元素。
`static int`	`lastIndexOf(short[] array, short shortToFind)` 在数组中从末尾开始查找一个元素。
`static int`	`lastIndexOf(short[] array, short[] arrayToFind)` 在数组中从末尾开始查找一个元素序列。
`static int`	`lastIndexOf(short[] array, short[] arrayToFind, int startIndex)` 在数组中从末尾开始查找一个元素序列。
`static int`	`lastIndexOf(short[] array, short shortToFind, int startIndex)` 在数组中从末尾开始查找一个元素。
`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(Object[] array)` 反转数组的元素顺序。
`static void`	`reverse(short[] array)` 反转数组的元素顺序。
`static List`	`toFixedList(Object[] array)` 将数组映射成固定长度的`List`，当改变这个`List`中的值时。
`static List`	`toList(Object array)` 将数组转换成`List`。
`static List`	`toList(Object array, List list)` 将数组转换成`List`。
`static Map`	`toMap(Object[] array)` 将数组转换成`Map`。
`static Map`	`toMap(Object[] array, Map map)` 将数组转换成`Map`。
`static String`	`toString(Object array)` 将数组转换成易于阅读的字符串表示。
`static String`	`toString(Object array, String nullArrayStr)` 将数组转换成易于阅读的字符串表示。
`static String`	`toString(Object array, String nullArrayStr, String nullElementStr)` 将数组转换成易于阅读的字符串表示。

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- 字段详细资料
  - EMPTY_OBJECT_ARRAY
```
public static final Object[] EMPTY_OBJECT_ARRAY
```
    空的Object数组。
  - EMPTY_CLASS_ARRAY
```
public static final Class[] EMPTY_CLASS_ARRAY
```
    空的Class数组。
  - EMPTY_STRING_ARRAY
```
public static final String[] EMPTY_STRING_ARRAY
```
    空的String数组。
  - EMPTY_LONG_ARRAY
```
public static final long[] EMPTY_LONG_ARRAY
```
    空的long数组。
  - EMPTY_LONG_OBJECT_ARRAY
```
public static final Long[] EMPTY_LONG_OBJECT_ARRAY
```
    空的Long数组。
  - EMPTY_INT_ARRAY
```
public static final int[] EMPTY_INT_ARRAY
```
    空的int数组。
  - EMPTY_INTEGER_OBJECT_ARRAY
```
public static final Integer[] EMPTY_INTEGER_OBJECT_ARRAY
```
    空的Integer数组。
  - EMPTY_SHORT_ARRAY
```
public static final short[] EMPTY_SHORT_ARRAY
```
    空的short数组。
  - EMPTY_SHORT_OBJECT_ARRAY
```
public static final Short[] EMPTY_SHORT_OBJECT_ARRAY
```
    空的Short数组。
  - EMPTY_BYTE_ARRAY
```
public static final byte[] EMPTY_BYTE_ARRAY
```
    空的byte数组。
  - EMPTY_BYTE_OBJECT_ARRAY
```
public static final Byte[] EMPTY_BYTE_OBJECT_ARRAY
```
    空的Byte数组。
  - EMPTY_DOUBLE_ARRAY
```
public static final double[] EMPTY_DOUBLE_ARRAY
```
    空的double数组。
  - EMPTY_DOUBLE_OBJECT_ARRAY
```
public static final Double[] EMPTY_DOUBLE_OBJECT_ARRAY
```
    空的Double数组。
  - EMPTY_FLOAT_ARRAY
```
public static final float[] EMPTY_FLOAT_ARRAY
```
    空的float数组。
  - EMPTY_FLOAT_OBJECT_ARRAY
```
public static final Float[] EMPTY_FLOAT_OBJECT_ARRAY
```
    空的Float数组。
  - EMPTY_BOOLEAN_ARRAY
```
public static final boolean[] EMPTY_BOOLEAN_ARRAY
```
    空的boolean数组。
  - EMPTY_BOOLEAN_OBJECT_ARRAY
```
public static final Boolean[] EMPTY_BOOLEAN_OBJECT_ARRAY
```
    空的Boolean数组。
  - EMPTY_CHAR_ARRAY
```
public static final char[] EMPTY_CHAR_ARRAY
```
    空的char数组。
  - EMPTY_CHARACTER_OBJECT_ARRAY
```
public static final Character[] EMPTY_CHARACTER_OBJECT_ARRAY
```
    空的Character数组。
- 构造器详细资料
  - ArrayUtil
```
public ArrayUtil()
```
- 方法详细资料
  - isEmpty
```
public static boolean isEmpty(Object[] array)
```
    检查数组是否为null或空数组[]。
```
 ArrayUtil.isEmpty(null)              = true
 ArrayUtil.isEmpty(new String[0])     = true
 ArrayUtil.isEmpty(new String[10])    = false
 
```
    array 要检查的数组如果为空, 则返回true
  - isEmpty
```
public static boolean isEmpty(long[] array)
```
    检查数组是否为null或空数组[]。
```
 ArrayUtil.isEmpty(null)              = true
 ArrayUtil.isEmpty(new long[0])     = true
 ArrayUtil.isEmpty(new long[10])    = false
 
```
    array 要检查的数组如果为空, 则返回true
  - isEmpty
```
public static boolean isEmpty(int[] array)
```
    检查数组是否为null或空数组[]。
```
 ArrayUtil.isEmpty(null)              = true
 ArrayUtil.isEmpty(new int[0])     = true
 ArrayUtil.isEmpty(new int[10])    = false
 
```
    array 要检查的数组如果为空, 则返回true
  - isEmpty
```
public static boolean isEmpty(short[] array)
```
    检查数组是否为null或空数组[]。
```
 ArrayUtil.isEmpty(null)              = true
 ArrayUtil.isEmpty(new short[0])     = true
 ArrayUtil.isEmpty(new short[10])    = false
 
```
    array 要检查的数组如果为空, 则返回true
  - isEmpty
```
public static boolean isEmpty(byte[] array)
```
    检查数组是否为null或空数组[]。
```
 ArrayUtil.isEmpty(null)              = true
 ArrayUtil.isEmpty(new byte[0])     = true
 ArrayUtil.isEmpty(new byte[10])    = false
 
```
    array 要检查的数组如果为空, 则返回true
  - isEmpty
```
public static boolean isEmpty(double[] array)
```
    检查数组是否为null或空数组[]。
```
 ArrayUtil.isEmpty(null)              = true
 ArrayUtil.isEmpty(new double[0])     = true
 ArrayUtil.isEmpty(new double[10])    = false
 
```
    array 要检查的数组如果为空, 则返回true
  - isEmpty
```
public static boolean isEmpty(float[] array)
```
    检查数组是否为null或空数组[]。
```
 ArrayUtil.isEmpty(null)              = true
 ArrayUtil.isEmpty(new float[0])     = true
 ArrayUtil.isEmpty(new float[10])    = false
 
```
    array 要检查的数组如果为空, 则返回true
  - isEmpty
```
public static boolean isEmpty(boolean[] array)
```
    检查数组是否为null或空数组[]。
```
 ArrayUtil.isEmpty(null)              = true
 ArrayUtil.isEmpty(new boolean[0])     = true
 ArrayUtil.isEmpty(new boolean[10])    = false
 
```
    array 要检查的数组如果为空, 则返回true
  - isEmpty
```
public static boolean isEmpty(char[] array)
```
    检查数组是否为null或空数组[]。
```
 ArrayUtil.isEmpty(null)              = true
 ArrayUtil.isEmpty(new char[0])     = true
 ArrayUtil.isEmpty(new char[10])    = false
 
```
    array 要检查的数组如果为空, 则返回true
  - isNotEmpty
```
public static boolean isNotEmpty(Object[] array)
```
    检查数组是否不是null和空数组[]。
```
 ArrayUtil.isEmpty(null)              = false
 ArrayUtil.isEmpty(new String[0])     = false
 ArrayUtil.isEmpty(new String[10])    = true
 
```
    array 要检查的数组如果不为空, 则返回true
  - isNotEmpty
```
public static boolean isNotEmpty(long[] array)
```
    检查数组是否不是null和空数组[]。
```
 ArrayUtil.isEmpty(null)              = false
 ArrayUtil.isEmpty(new long[0])     = false
 ArrayUtil.isEmpty(new long[10])    = true
 
```
    array 要检查的数组如果不为空, 则返回true
  - isNotEmpty
```
public static boolean isNotEmpty(int[] array)
```
    检查数组是否不是null和空数组[]。
```
 ArrayUtil.isEmpty(null)              = false
 ArrayUtil.isEmpty(new int[0])     = false
 ArrayUtil.isEmpty(new int[10])    = true
 
```
    array 要检查的数组如果不为空, 则返回true
  - isNotEmpty
```
public static boolean isNotEmpty(short[] array)
```
    检查数组是否不是null和空数组[]。
```
 ArrayUtil.isEmpty(null)              = false
 ArrayUtil.isEmpty(new short[0])     = false
 ArrayUtil.isEmpty(new short[10])    = true
 
```
    array 要检查的数组如果不为空, 则返回true
  - isNotEmpty
```
public static boolean isNotEmpty(byte[] array)
```
    检查数组是否不是null和空数组[]。
```
 ArrayUtil.isEmpty(null)              = false
 ArrayUtil.isEmpty(new byte[0])     = false
 ArrayUtil.isEmpty(new byte[10])    = true
 
```
    array 要检查的数组如果不为空, 则返回true
  - isNotEmpty
```
public static boolean isNotEmpty(double[] array)
```
    检查数组是否不是null和空数组[]。
```
 ArrayUtil.isEmpty(null)              = false
 ArrayUtil.isEmpty(new double[0])     = false
 ArrayUtil.isEmpty(new double[10])    = true
 
```
    array 要检查的数组如果不为空, 则返回true
  - isNotEmpty
```
public static boolean isNotEmpty(float[] array)
```
    检查数组是否不是null和空数组[]。
```
 ArrayUtil.isEmpty(null)              = false
 ArrayUtil.isEmpty(new float[0])     = false
 ArrayUtil.isEmpty(new float[10])    = true
 
```
    array 要检查的数组如果不为空, 则返回true
  - isNotEmpty
```
public static boolean isNotEmpty(boolean[] array)
```
    检查数组是否不是null和空数组[]。
```
 ArrayUtil.isEmpty(null)              = false
 ArrayUtil.isEmpty(new boolean[0])     = false
 ArrayUtil.isEmpty(new boolean[10])    = true
 
```
    array 要检查的数组如果不为空, 则返回true
  - isNotEmpty
```
public static boolean isNotEmpty(char[] array)
```
    检查数组是否不是null和空数组[]。
```
 ArrayUtil.isEmpty(null)              = false
 ArrayUtil.isEmpty(new char[0])     = false
 ArrayUtil.isEmpty(new char[10])    = true
 
```
    array 要检查的数组如果不为空, 则返回true
  - defaultIfNull
```
public static Object[] defaultIfNull(Object[] array)
```
    如果数组是null，则返回空数组[]，否则返回数组本身。
```
 ArrayUtil.defaultIfNull(null)           = []
 ArrayUtil.defaultIfNull(new String[0])  = 数组本身
 ArrayUtil.defaultIfNull(new String[10]) = 数组本身
 
```
    array 要转换的数组数组本身或空数组[]
  - defaultIfNull
```
public static long[] defaultIfNull(long[] array)
```
    如果数组是null，则返回空数组[]，否则返回数组本身。
```
 ArrayUtil.defaultIfNull(null)           = []
 ArrayUtil.defaultIfNull(new long[0])  = 数组本身
 ArrayUtil.defaultIfNull(new long[10]) = 数组本身
 
```
    array 要转换的数组数组本身或空数组[]
  - defaultIfNull
```
public static int[] defaultIfNull(int[] array)
```
    如果数组是null，则返回空数组[]，否则返回数组本身。
```
 ArrayUtil.defaultIfNull(null)           = []
 ArrayUtil.defaultIfNull(new int[0])  = 数组本身
 ArrayUtil.defaultIfNull(new int[10]) = 数组本身
 
```
    array 要转换的数组数组本身或空数组[]
  - defaultIfNull
```
public static short[] defaultIfNull(short[] array)
```
    如果数组是null，则返回空数组[]，否则返回数组本身。
```
 ArrayUtil.defaultIfNull(null)           = []
 ArrayUtil.defaultIfNull(new short[0])  = 数组本身
 ArrayUtil.defaultIfNull(new short[10]) = 数组本身
 
```
    array 要转换的数组数组本身或空数组[]
  - defaultIfNull
```
public static byte[] defaultIfNull(byte[] array)
```
    如果数组是null，则返回空数组[]，否则返回数组本身。
```
 ArrayUtil.defaultIfNull(null)           = []
 ArrayUtil.defaultIfNull(new byte[0])  = 数组本身
 ArrayUtil.defaultIfNull(new byte[10]) = 数组本身
 
```
    array 要转换的数组数组本身或空数组[]
  - defaultIfNull
```
public static double[] defaultIfNull(double[] array)
```
    如果数组是null，则返回空数组[]，否则返回数组本身。
```
 ArrayUtil.defaultIfNull(null)           = []
 ArrayUtil.defaultIfNull(new double[0])  = 数组本身
 ArrayUtil.defaultIfNull(new double[10]) = 数组本身
 
```
    array 要转换的数组数组本身或空数组[]
  - defaultIfNull
```
public static float[] defaultIfNull(float[] array)
```
    如果数组是null，则返回空数组[]，否则返回数组本身。
```
 ArrayUtil.defaultIfNull(null)           = []
 ArrayUtil.defaultIfNull(new float[0])  = 数组本身
 ArrayUtil.defaultIfNull(new float[10]) = 数组本身
 
```
    array 要转换的数组数组本身或空数组[]
  - defaultIfNull
```
public static boolean[] defaultIfNull(boolean[] array)
```
    如果数组是null，则返回空数组[]，否则返回数组本身。
```
 ArrayUtil.defaultIfNull(null)           = []
 ArrayUtil.defaultIfNull(new boolean[0])  = 数组本身
 ArrayUtil.defaultIfNull(new boolean[10]) = 数组本身
 
```
    array 要转换的数组数组本身或空数组[]
  - defaultIfNull
```
public static char[] defaultIfNull(char[] array)
```
    如果数组是null，则返回空数组[]，否则返回数组本身。
```
 ArrayUtil.defaultIfNull(null)           = []
 ArrayUtil.defaultIfNull(new char[0])  = 数组本身
 ArrayUtil.defaultIfNull(new char[10]) = 数组本身
 
```
    array 要转换的数组数组本身或空数组[]
  - defaultIfNull
```
public static Object[] defaultIfNull(Object[] array,
                                     Object[] defaultArray)
```
    如果数组是null，则返回指定默认数组，否则返回数组本身。
```
 ArrayUtil.defaultIfNull(null, defaultArray)           = defaultArray
 ArrayUtil.defaultIfNull(new String[0], defaultArray)  = 数组本身
 ArrayUtil.defaultIfNull(new String[10], defaultArray) = 数组本身
 
```
    array 要转换的数组 defaultArray 默认数组数组本身或指定的默认数组
  - defaultIfNull
```
public static long[] defaultIfNull(long[] array,
                                   long[] defaultArray)
```
    如果数组是null，则返回指定默认数组，否则返回数组本身。
```
 ArrayUtil.defaultIfNull(null, defaultArray)         = defaultArray
 ArrayUtil.defaultIfNull(new long[0], defaultArray)  = 数组本身
 ArrayUtil.defaultIfNull(new long[10], defaultArray) = 数组本身
 
```
    array 要转换的数组 defaultArray 默认数组数组本身或指定的默认数组
  - defaultIfNull
```
public static int[] defaultIfNull(int[] array,
                                  int[] defaultArray)
```
    如果数组是null，则返回指定默认数组，否则返回数组本身。
```
 ArrayUtil.defaultIfNull(null, defaultArray)        = defaultArray
 ArrayUtil.defaultIfNull(new int[0], defaultArray)  = 数组本身
 ArrayUtil.defaultIfNull(new int[10], defaultArray) = 数组本身
 
```
    array 要转换的数组 defaultArray 默认数组数组本身或指定的默认数组
  - defaultIfNull
```
public static short[] defaultIfNull(short[] array,
                                    short[] defaultArray)
```
    如果数组是null，则返回指定默认数组，否则返回数组本身。
```
 ArrayUtil.defaultIfNull(null, defaultArray)          = defaultArray
 ArrayUtil.defaultIfNull(new short[0], defaultArray)  = 数组本身
 ArrayUtil.defaultIfNull(new short[10], defaultArray) = 数组本身
 
```
    array 要转换的数组 defaultArray 默认数组数组本身或指定的默认数组
  - defaultIfNull
```
public static byte[] defaultIfNull(byte[] array,
                                   byte[] defaultArray)
```
    如果数组是null，则返回指定默认数组，否则返回数组本身。
```
 ArrayUtil.defaultIfNull(null, defaultArray)         = defaultArray
 ArrayUtil.defaultIfNull(new byte[0], defaultArray)  = 数组本身
 ArrayUtil.defaultIfNull(new byte[10], defaultArray) = 数组本身
 
```
    array 要转换的数组 defaultArray 默认数组数组本身或指定的默认数组
  - defaultIfNull
```
public static double[] defaultIfNull(double[] array,
                                     double[] defaultArray)
```
    如果数组是null，则返回指定默认数组，否则返回数组本身。
```
 ArrayUtil.defaultIfNull(null, defaultArray)         = defaultArray
 ArrayUtil.defaultIfNull(new double[0], defaultArray)  = 数组本身
 ArrayUtil.defaultIfNull(new double[10], defaultArray) = 数组本身
 
```
    array 要转换的数组 defaultArray 默认数组数组本身或指定的默认数组
  - defaultIfNull
```
public static float[] defaultIfNull(float[] array,
                                    float[] defaultArray)
```
    如果数组是null，则返回指定默认数组，否则返回数组本身。
```
 ArrayUtil.defaultIfNull(null, defaultArray)          = defaultArray
 ArrayUtil.defaultIfNull(new float[0], defaultArray)  = 数组本身
 ArrayUtil.defaultIfNull(new float[10], defaultArray) = 数组本身
 
```
    array 要转换的数组 defaultArray 默认数组数组本身或指定的默认数组
  - defaultIfNull
```
public static boolean[] defaultIfNull(boolean[] array,
                                      boolean[] defaultArray)
```
    如果数组是null，则返回指定默认数组，否则返回数组本身。
```
 ArrayUtil.defaultIfNull(null, defaultArray)            = defaultArray
 ArrayUtil.defaultIfNull(new boolean[0], defaultArray)  = 数组本身
 ArrayUtil.defaultIfNull(new boolean[10], defaultArray) = 数组本身
 
```
    array 要转换的数组 defaultArray 默认数组数组本身或指定的默认数组
  - defaultIfNull
```
public static char[] defaultIfNull(char[] array,
                                   char[] defaultArray)
```
    如果数组是null，则返回指定默认数组，否则返回数组本身。
```
 ArrayUtil.defaultIfNull(null, defaultArray)         = defaultArray
 ArrayUtil.defaultIfNull(new char[0], defaultArray)  = 数组本身
 ArrayUtil.defaultIfNull(new char[10], defaultArray) = 数组本身
 
```
    array 要转换的数组 defaultArray 默认数组数组本身或指定的默认数组
  - defaultIfNull
```
public static Object[] defaultIfNull(Object[] array,
                                     Class defaultComponentType)
```
    如果数组是null，则返回指定元素类型的空数组，否则返回数组本身。
```
 ArrayUtil.defaultIfNull(null, String.class)           = new String[0]
 ArrayUtil.defaultIfNull(new String[0], String.class)  = 数组本身
 ArrayUtil.defaultIfNull(new String[10], String.class) = 数组本身
 
```
    array 要转换的数组 defaultComponentType 默认数组的元素类型数组本身或指定类型的空数组
  - defaultIfEmpty
```
public static Object[] defaultIfEmpty(Object[] array)
```
    如果数组是null或空数组[]，则返回空数组[]，否则返回数组本身。此方法实际上和defaultIfNull(Object[])等效。
```
 ArrayUtil.defaultIfEmpty(null)           = []
 ArrayUtil.defaultIfEmpty(new String[0])  = 数组本身
 ArrayUtil.defaultIfEmpty(new String[10]) = 数组本身
 
```
    array 要转换的数组数组本身或空数组[]
  - defaultIfEmpty
```
public static long[] defaultIfEmpty(long[] array)
```
    如果数组是null或空数组[]，则返回空数组[]，否则返回数组本身。此方法实际上和defaultIfNull(Object[])等效。
```
 ArrayUtil.defaultIfEmpty(null)           = []
 ArrayUtil.defaultIfEmpty(new long[0])    = 数组本身
 ArrayUtil.defaultIfEmpty(new long[10])   = 数组本身
 
```
    array 要转换的数组数组本身或空数组[]
  - defaultIfEmpty
```
public static int[] defaultIfEmpty(int[] array)
```
    如果数组是null或空数组[]，则返回空数组[]，否则返回数组本身。此方法实际上和defaultIfNull(Object[])等效。
```
 ArrayUtil.defaultIfEmpty(null)          = []
 ArrayUtil.defaultIfEmpty(new int[0])    = 数组本身
 ArrayUtil.defaultIfEmpty(new int[10])   = 数组本身
 
```
    array 要转换的数组数组本身或空数组[]
  - defaultIfEmpty
```
public static short[] defaultIfEmpty(short[] array)
```
    如果数组是null或空数组[]，则返回空数组[]，否则返回数组本身。此方法实际上和defaultIfNull(Object[])等效。
```
 ArrayUtil.defaultIfEmpty(null)               = []
 ArrayUtil.defaultIfEmpty(new short[0])    = 数组本身
 ArrayUtil.defaultIfEmpty(new short[10])   = 数组本身
 
```
    array 要转换的数组数组本身或空数组[]
  - defaultIfEmpty
```
public static byte[] defaultIfEmpty(byte[] array)
```
    如果数组是null或空数组[]，则返回空数组[]，否则返回数组本身。此方法实际上和defaultIfNull(Object[])等效。
```
 ArrayUtil.defaultIfEmpty(null)           = []
 ArrayUtil.defaultIfEmpty(new byte[0])    = 数组本身
 ArrayUtil.defaultIfEmpty(new byte[10])   = 数组本身
 
```
    array 要转换的数组数组本身或空数组[]
  - defaultIfEmpty
```
public static double[] defaultIfEmpty(double[] array)
```
    如果数组是null或空数组[]，则返回空数组[]，否则返回数组本身。此方法实际上和defaultIfNull(Object[])等效。
```
 ArrayUtil.defaultIfEmpty(null)               = []
 ArrayUtil.defaultIfEmpty(new double[0])    = 数组本身
 ArrayUtil.defaultIfEmpty(new double[10])   = 数组本身
 
```
    array 要转换的数组数组本身或空数组[]
  - defaultIfEmpty
```
public static float[] defaultIfEmpty(float[] array)
```
    如果数组是null或空数组[]，则返回空数组[]，否则返回数组本身。此方法实际上和defaultIfNull(Object[])等效。
```
 ArrayUtil.defaultIfEmpty(null)               = []
 ArrayUtil.defaultIfEmpty(new float[0])    = 数组本身
 ArrayUtil.defaultIfEmpty(new float[10])   = 数组本身
 
```
    array 要转换的数组数组本身或空数组[]
  - defaultIfEmpty
```
public static boolean[] defaultIfEmpty(boolean[] array)
```
    如果数组是null或空数组[]，则返回空数组[]，否则返回数组本身。此方法实际上和defaultIfNull(Object[])等效。
```
 ArrayUtil.defaultIfEmpty(null)               = []
 ArrayUtil.defaultIfEmpty(new boolean[0])    = 数组本身
 ArrayUtil.defaultIfEmpty(new boolean[10])   = 数组本身
 
```
    array 要转换的数组数组本身或空数组[]
  - defaultIfEmpty
```
public static char[] defaultIfEmpty(char[] array)
```
    如果数组是null或空数组[]，则返回空数组[]，否则返回数组本身。此方法实际上和defaultIfNull(Object[])等效。
```
 ArrayUtil.defaultIfEmpty(null)           = []
 ArrayUtil.defaultIfEmpty(new char[0])    = 数组本身
 ArrayUtil.defaultIfEmpty(new char[10])   = 数组本身
 
```
    array 要转换的数组数组本身或空数组[]
  - defaultIfEmpty
```
public static Object[] defaultIfEmpty(Object[] array,
                                      Object[] defaultArray)
```
    如果数组是null或空数组[]，则返回指定默认数组，否则返回数组本身。
```
 ArrayUtil.defaultIfEmpty(null, defaultArray)           = defaultArray
 ArrayUtil.defaultIfEmpty(new String[0], defaultArray)  = defaultArray
 ArrayUtil.defaultIfEmpty(new String[10], defaultArray) = 数组本身
 
```
    array 要转换的数组 defaultArray 默认数组数组本身或指定的默认数组
  - defaultIfEmpty
```
public static long[] defaultIfEmpty(long[] array,
                                    long[] defaultArray)
```
    如果数组是null或空数组[]，则返回指定默认数组，否则返回数组本身。
```
 ArrayUtil.defaultIfEmpty(null, defaultArray)           = defaultArray
 ArrayUtil.defaultIfEmpty(new long[0], defaultArray)    = defaultArray
 ArrayUtil.defaultIfEmpty(new long[10], defaultArray)   = 数组本身
 
```
    array 要转换的数组 defaultArray 默认数组数组本身或指定的默认数组
  - defaultIfEmpty
```
public static int[] defaultIfEmpty(int[] array,
                                   int[] defaultArray)
```
    如果数组是null或空数组[]，则返回指定默认数组，否则返回数组本身。
```
 ArrayUtil.defaultIfEmpty(null, defaultArray)           = defaultArray
 ArrayUtil.defaultIfEmpty(new int[0], defaultArray)     = defaultArray
 ArrayUtil.defaultIfEmpty(new int[10], defaultArray)    = 数组本身
 
```
    array 要转换的数组 defaultArray 默认数组数组本身或指定的默认数组
  - defaultIfEmpty
```
public static short[] defaultIfEmpty(short[] array,
                                     short[] defaultArray)
```
    如果数组是null或空数组[]，则返回指定默认数组，否则返回数组本身。
```
 ArrayUtil.defaultIfEmpty(null, defaultArray)           = defaultArray
 ArrayUtil.defaultIfEmpty(new short[0], defaultArray)   = defaultArray
 ArrayUtil.defaultIfEmpty(new short[10], defaultArray)  = 数组本身
 
```
    array 要转换的数组 defaultArray 默认数组数组本身或指定的默认数组
  - defaultIfEmpty
```
public static byte[] defaultIfEmpty(byte[] array,
                                    byte[] defaultArray)
```
    如果数组是null或空数组[]，则返回指定默认数组，否则返回数组本身。
```
 ArrayUtil.defaultIfEmpty(null, defaultArray)           = defaultArray
 ArrayUtil.defaultIfEmpty(new byte[0], defaultArray)    = defaultArray
 ArrayUtil.defaultIfEmpty(new byte[10], defaultArray)   = 数组本身
 
```
    array 要转换的数组 defaultArray 默认数组数组本身或指定的默认数组
  - defaultIfEmpty
```
public static double[] defaultIfEmpty(double[] array,
                                      double[] defaultArray)
```
    如果数组是null或空数组[]，则返回指定默认数组，否则返回数组本身。
```
 ArrayUtil.defaultIfEmpty(null, defaultArray)           = defaultArray
 ArrayUtil.defaultIfEmpty(new double[0], defaultArray)  = defaultArray
 ArrayUtil.defaultIfEmpty(new double[10], defaultArray) = 数组本身
 
```
    array 要转换的数组 defaultArray 默认数组数组本身或指定的默认数组
  - defaultIfEmpty
```
public static float[] defaultIfEmpty(float[] array,
                                     float[] defaultArray)
```
    如果数组是null或空数组[]，则返回指定默认数组，否则返回数组本身。
```
 ArrayUtil.defaultIfEmpty(null, defaultArray)           = defaultArray
 ArrayUtil.defaultIfEmpty(new float[0], defaultArray)   = defaultArray
 ArrayUtil.defaultIfEmpty(new float[10], defaultArray)  = 数组本身
 
```
    array 要转换的数组 defaultArray 默认数组数组本身或指定的默认数组
  - defaultIfEmpty
```
public static boolean[] defaultIfEmpty(boolean[] array,
                                       boolean[] defaultArray)
```
    如果数组是null或空数组[]，则返回指定默认数组，否则返回数组本身。
```
 ArrayUtil.defaultIfEmpty(null, defaultArray)              = defaultArray
 ArrayUtil.defaultIfEmpty(new boolean[0], defaultArray)    = defaultArray
 ArrayUtil.defaultIfEmpty(new boolean[10], defaultArray)   = 数组本身
 
```
    array 要转换的数组 defaultArray 默认数组数组本身或指定的默认数组
  - defaultIfEmpty
```
public static char[] defaultIfEmpty(char[] array,
                                    char[] defaultArray)
```
    如果数组是null或空数组[]，则返回指定默认数组，否则返回数组本身。
```
 ArrayUtil.defaultIfEmpty(null, defaultArray)           = defaultArray
 ArrayUtil.defaultIfEmpty(new char[0], defaultArray)    = defaultArray
 ArrayUtil.defaultIfEmpty(new char[10], defaultArray)   = 数组本身
 
```
    array 要转换的数组 defaultArray 默认数组数组本身或指定的默认数组
  - defaultIfEmpty
```
public static Object[] defaultIfEmpty(Object[] array,
                                      Class defaultComponentType)
```
    如果数组是null或空数组[]，则返回指定元素类型的空数组，否则返回数组本身。
```
 ArrayUtil.defaultIfNull(null, String.class)           = new String[0]
 ArrayUtil.defaultIfNull(new String[0], String.class)  = new String[0]
 ArrayUtil.defaultIfNull(new String[10], String.class) = 数组本身
 
```
    array 要转换的数组 defaultComponentType 默认数组的元素类型数组本身或指定类型的空数组
  - equals
```
public static boolean equals(Object array1,
                             Object array2)
```
    递归地比较两个数组是否相同，支持多维数组。如果比较的对象不是数组，则此方法的结果同ObjectUtil.equals。 array1 数组1 array2 数组2 如果相等, 则返回true
  - hashCode
```
public static int hashCode(Object array)
```
    取得数组的hash值, 如果数组为null, 则返回0。如果对象不是数组，则此方法的结果同ObjectUtil.hashCode。 array 数组 hash值
  - toFixedList
```
public static List toFixedList(Object[] array)
```
    将数组映射成固定长度的List，当改变这个List中的值时。数组中的相应值也被改变。如果输入数组为null，则返回null。该方法内部调用java.util.Arrays.asList方法所返回的列表为指定数组的映像（固定长度），因此性能和内存占用上比toList方法更优。这个方法常被用于初始化，例如：
```
 List myList = ArrayUtil.toFixedList(new String[] { "aaa", "bbb", "ccc" });
 
```
    array 要转换的数组以数组本身为映射的list
  - toList
```
public static List toList(Object array)
```
    将数组转换成List。如果输入数组为null，则返回null。该方法返回的列表为指定数组的复本，而java.util.Arrays.asList方法所返回的列表为指定数组的映像（固定长度）。这个方法常被用于初始化，例如：
```
 List myList      = ArrayUtil.toList(new String[] { "aaa", "bbb", "ccc" });
 List singleList  = ArrayUtil.toList("hello");     // 返回单个元素的列表["hello"]
 
```
    array 要转换的数组被创建的list
  - toList
```
public static List toList(Object array,
                          List list)
```
    将数组转换成List。如果输入数组为null，则返回null。该方法返回的列表为指定数组的复本，而java.util.Arrays.asList方法所返回的列表为指定数组的映像（固定长度）。这个方法常被用于初始化，例如：
```
 List myList      = ArrayUtil.toList(new String[] { "aaa", "bbb", "ccc" }, new ArrayList());
 List singleList  = ArrayUtil.toList("hello", new ArrayList());     // 返回单个元素的列表["hello"]
 
```
    array 要转换的数组 list 要填充的列表，如果是null，则创建之被创建或填充的list
  - toMap
```
public static Map toMap(Object[] array)
```
    将数组转换成Map。数组的元素必须是Map.Entry或元素个数多于2的子数组。如果输入数组为null，则返回null。这个方法常被用于初始化，例如：
```
 Map colorMap = ArrayUtil.toMap(new String[][] {
     {"RED", "#FF0000"},
     {"GREEN", "#00FF00"},
     {"BLUE", "#0000FF"}});
 
```
    array 要转换的数组被创建的map IllegalArgumentException 如果有一个子数组元素个数小于2或不是Map.Entry实例
  - toMap
```
public static Map toMap(Object[] array,
                        Map map)
```
    将数组转换成Map。数组的元素必须是Map.Entry或元素个数多于2的子数组。如果输入数组为null，则返回null。这个方法常被用于初始化，例如：
```
 Map colorMap = ArrayUtil.toMap(new String[][] {{
     {"RED", "#FF0000"},
     {"GREEN", "#00FF00"},
     {"BLUE", "#0000FF"}}, new HashMap());
 
```
    array 要转换的数组 map 要填充的map，如果为null则自动创建之被创建或填充的map IllegalArgumentException 如果有一个子数组元素个数小于2或不是Map.Entry实例
  - clone
```
public static Object[] clone(Object[] array)
```
    复制一个数组。如果数组为null，则返回null。此方法只进行“浅复制”，也就是说，数组中的对象本身不会被复制。另外，此方法也不处理多维数组。 array 要复制的数组数组的复本，如果原始数组为null，则返回null
  - clone
```
public static long[] clone(long[] array)
```
    复制一个数组。如果数组为null，则返回null。此方法也不处理多维数组。 array 要复制的数组数组的复本，如果原始数组为null，则返回null
  - clone
```
public static int[] clone(int[] array)
```
    复制一个数组。如果数组为null，则返回null。此方法也不处理多维数组。 array 要复制的数组数组的复本，如果原始数组为null，则返回null
  - clone
```
public static short[] clone(short[] array)
```
    复制一个数组。如果数组为null，则返回null。此方法也不处理多维数组。 array 要复制的数组数组的复本，如果原始数组为null，则返回null
  - clone
```
public static byte[] clone(byte[] array)
```
    复制一个数组。如果数组为null，则返回null。此方法也不处理多维数组。 array 要复制的数组数组的复本，如果原始数组为null，则返回null
  - clone
```
public static double[] clone(double[] array)
```
    复制一个数组。如果数组为null，则返回null。此方法也不处理多维数组。 array 要复制的数组数组的复本，如果原始数组为null，则返回null
  - clone
```
public static float[] clone(float[] array)
```
    复制一个数组。如果数组为null，则返回null。此方法也不处理多维数组。 array 要复制的数组数组的复本，如果原始数组为null，则返回null
  - clone
```
public static boolean[] clone(boolean[] array)
```
    复制一个数组。如果数组为null，则返回null。此方法也不处理多维数组。 array 要复制的数组数组的复本，如果原始数组为null，则返回null
  - clone
```
public static char[] clone(char[] array)
```
    复制一个数组。如果数组为null，则返回null。此方法也不处理多维数组。 array 要复制的数组数组的复本，如果原始数组为null，则返回null
  - isSameLength
```
public static boolean isSameLength(Object[] array1,
                                   Object[] array2)
```
    判断两个数组是否具有相同的长度。如果数组为null则被看作长度为0。 array1 数组1 array2 数组2 如果两个数组长度相同，则返回true
  - isSameLength
```
public static boolean isSameLength(long[] array1,
                                   long[] array2)
```
    判断两个数组是否具有相同的长度。如果数组为null则被看作长度为0。 array1 数组1 array2 数组2 如果两个数组长度相同，则返回true
  - isSameLength
```
public static boolean isSameLength(int[] array1,
                                   int[] array2)
```
    判断两个数组是否具有相同的长度。如果数组为null则被看作长度为0。 array1 数组1 array2 数组2 如果两个数组长度相同，则返回true
  - isSameLength
```
public static boolean isSameLength(short[] array1,
                                   short[] array2)
```
    判断两个数组是否具有相同的长度。如果数组为null则被看作长度为0。 array1 数组1 array2 数组2 如果两个数组长度相同，则返回true
  - isSameLength
```
public static boolean isSameLength(byte[] array1,
                                   byte[] array2)
```
    判断两个数组是否具有相同的长度。如果数组为null则被看作长度为0。 array1 数组1 array2 数组2 如果两个数组长度相同，则返回true
  - isSameLength
```
public static boolean isSameLength(double[] array1,
                                   double[] array2)
```
    判断两个数组是否具有相同的长度。如果数组为null则被看作长度为0。 array1 数组1 array2 数组2 如果两个数组长度相同，则返回true
  - isSameLength
```
public static boolean isSameLength(float[] array1,
                                   float[] array2)
```
    判断两个数组是否具有相同的长度。如果数组为null则被看作长度为0。 array1 数组1 array2 数组2 如果两个数组长度相同，则返回true
  - isSameLength
```
public static boolean isSameLength(boolean[] array1,
                                   boolean[] array2)
```
    判断两个数组是否具有相同的长度。如果数组为null则被看作长度为0。 array1 数组1 array2 数组2 如果两个数组长度相同，则返回true
  - isSameLength
```
public static boolean isSameLength(char[] array1,
                                   char[] array2)
```
    判断两个数组是否具有相同的长度。如果数组为null则被看作长度为0。 array1 数组1 array2 数组2 如果两个数组长度相同，则返回true
  - reverse
```
public static void reverse(Object[] array)
```
    反转数组的元素顺序。如果数组为null，则什么也不做。 array 要反转的数组
  - reverse
```
public static void reverse(long[] array)
```
    反转数组的元素顺序。如果数组为null，则什么也不做。 array 要反转的数组
  - reverse
```
public static void reverse(int[] array)
```
    反转数组的元素顺序。如果数组为null，则什么也不做。 array 要反转的数组
  - reverse
```
public static void reverse(short[] array)
```
    反转数组的元素顺序。如果数组为null，则什么也不做。 array 要反转的数组
  - reverse
```
public static void reverse(byte[] array)
```
    反转数组的元素顺序。如果数组为null，则什么也不做。 array 要反转的数组
  - reverse
```
public static void reverse(double[] array)
```
    反转数组的元素顺序。如果数组为null，则什么也不做。 array 要反转的数组
  - reverse
```
public static void reverse(float[] array)
```
    反转数组的元素顺序。如果数组为null，则什么也不做。 array 要反转的数组
  - reverse
```
public static void reverse(boolean[] array)
```
    反转数组的元素顺序。如果数组为null，则什么也不做。 array 要反转的数组
  - reverse
```
public static void reverse(char[] array)
```
    反转数组的元素顺序。如果数组为null，则什么也不做。 array 要反转的数组
  - indexOf
```
public static int indexOf(Object[] array,
                          Object objectToFind)
```
    在数组中查找一个元素。如果未找到或数组为null则返回-1。 array 要扫描的数组 objectToFind 要查找的元素该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - indexOf
```
public static int indexOf(Object[] array,
                          Object[] arrayToFind)
```
    在数组中查找一个元素序列。如果未找到或数组为null则返回-1。 array 要扫描的数组 arrayToFind 要查找的元素序列该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - indexOf
```
public static int indexOf(Object[] array,
                          Object objectToFind,
                          int startIndex)
```
    在数组中查找一个元素。如果未找到或数组为null则返回-1。起始索引小于0则看作0，超出数组长度的起始索引则返回-1。 array 要扫描的数组 objectToFind 要查找的元素 startIndex 起始索引该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - indexOf
```
public static int indexOf(Object[] array,
                          Object[] arrayToFind,
                          int startIndex)
```
    在数组中查找一个元素序列。如果未找到或数组为null则返回-1。起始索引小于0则看作0，超出数组长度的起始索引则返回-1。 array 要扫描的数组 arrayToFind 要查找的元素序列 startIndex 起始索引该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(Object[] array,
                              Object objectToFind)
```
    在数组中从末尾开始查找一个元素。如果未找到或数组为null则返回-1。 array 要扫描的数组 objectToFind 要查找的元素该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(Object[] array,
                              Object[] arrayToFind)
```
    在数组中从末尾开始查找一个元素序列。如果未找到或数组为null则返回-1。 array 要扫描的数组 arrayToFind 要查找的元素序列该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(Object[] array,
                              Object objectToFind,
                              int startIndex)
```
    在数组中从末尾开始查找一个元素。如果未找到或数组为null则返回-1。起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。 array 要扫描的数组 objectToFind 要查找的元素 startIndex 起始索引该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(Object[] array,
                              Object[] arrayToFind,
                              int startIndex)
```
    在数组中从末尾开始查找一个元素序列。如果未找到或数组为null则返回-1。起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。 array 要扫描的数组 arrayToFind 要查找的元素序列 startIndex 起始索引该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - contains
```
public static boolean contains(Object[] array,
                               Object objectToFind)
```
    判断指定对象是否存在于指定数组中。如果数组为null则返回false。 array 要扫描的数组 objectToFind 要查找的元素如果找到则返回true
  - contains
```
public static boolean contains(Object[] array,
                               Object[] arrayToFind)
```
    判断指定元素序列是否存在于指定数组中。如果数组为null则返回false。 array 要扫描的数组 arrayToFind 要查找的元素序列如果找到则返回true
  - indexOf
```
public static int indexOf(long[] array,
                          long longToFind)
```
    在数组中查找一个元素。如果未找到或数组为null则返回-1。 array 要扫描的数组 longToFind 要查找的元素该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - indexOf
```
public static int indexOf(long[] array,
                          long[] arrayToFind)
```
    在数组中查找一个元素序列。如果未找到或数组为null则返回-1。 array 要扫描的数组 arrayToFind 要查找的元素序列该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - indexOf
```
public static int indexOf(long[] array,
                          long longToFind,
                          int startIndex)
```
    在数组中查找一个元素。如果未找到或数组为null则返回-1。起始索引小于0则看作0，超出数组长度的起始索引则返回-1。 array 要扫描的数组 longToFind 要查找的元素 startIndex 起始索引该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - indexOf
```
public static int indexOf(long[] array,
                          long[] arrayToFind,
                          int startIndex)
```
    在数组中查找一个元素序列。如果未找到或数组为null则返回-1。起始索引小于0则看作0，超出数组长度的起始索引则返回-1。 array 要扫描的数组 arrayToFind 要查找的元素序列 startIndex 起始索引该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(long[] array,
                              long longToFind)
```
    在数组中从末尾开始查找一个元素。如果未找到或数组为null则返回-1。 array 要扫描的数组 longToFind 要查找的元素该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(long[] array,
                              long[] arrayToFind)
```
    在数组中从末尾开始查找一个元素序列。如果未找到或数组为null则返回-1。 array 要扫描的数组 arrayToFind 要查找的元素序列该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(long[] array,
                              long longToFind,
                              int startIndex)
```
    在数组中从末尾开始查找一个元素。如果未找到或数组为null则返回-1。起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。 array 要扫描的数组 longToFind 要查找的元素 startIndex 起始索引该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(long[] array,
                              long[] arrayToFind,
                              int startIndex)
```
    在数组中从末尾开始查找一个元素序列。如果未找到或数组为null则返回-1。起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。 array 要扫描的数组 arrayToFind 要查找的元素序列 startIndex 起始索引该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - contains
```
public static boolean contains(long[] array,
                               long longToFind)
```
    判断指定对象是否存在于指定数组中。如果数组为null则返回false。 array 要扫描的数组 longToFind 要查找的元素如果找到则返回true
  - contains
```
public static boolean contains(long[] array,
                               long[] arrayToFind)
```
    判断指定元素序列是否存在于指定数组中。如果数组为null则返回false。 array 要扫描的数组 arrayToFind 要查找的元素序列如果找到则返回true
  - indexOf
```
public static int indexOf(int[] array,
                          int intToFind)
```
    在数组中查找一个元素。如果未找到或数组为null则返回-1。 array 要扫描的数组 intToFind 要查找的元素该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - indexOf
```
public static int indexOf(int[] array,
                          int[] arrayToFind)
```
    在数组中查找一个元素序列。如果未找到或数组为null则返回-1。 array 要扫描的数组 arrayToFind 要查找的元素序列该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - indexOf
```
public static int indexOf(int[] array,
                          int intToFind,
                          int startIndex)
```
    在数组中查找一个元素。如果未找到或数组为null则返回-1。起始索引小于0则看作0，超出数组长度的起始索引则返回-1。 array 要扫描的数组 intToFind 要查找的元素 startIndex 起始索引该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - indexOf
```
public static int indexOf(int[] array,
                          int[] arrayToFind,
                          int startIndex)
```
    在数组中查找一个元素序列。如果未找到或数组为null则返回-1。起始索引小于0则看作0，超出数组长度的起始索引则返回-1。 array 要扫描的数组 arrayToFind 要查找的元素序列 startIndex 起始索引该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(int[] array,
                              int intToFind)
```
    在数组中从末尾开始查找一个元素。如果未找到或数组为null则返回-1。 array 要扫描的数组 intToFind 要查找的元素该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(int[] array,
                              int[] arrayToFind)
```
    在数组中从末尾开始查找一个元素序列。如果未找到或数组为null则返回-1。 array 要扫描的数组 arrayToFind 要查找的元素序列该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(int[] array,
                              int intToFind,
                              int startIndex)
```
    在数组中从末尾开始查找一个元素。如果未找到或数组为null则返回-1。起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。 array 要扫描的数组 intToFind 要查找的元素 startIndex 起始索引该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(int[] array,
                              int[] arrayToFind,
                              int startIndex)
```
    在数组中从末尾开始查找一个元素序列。如果未找到或数组为null则返回-1。起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。 array 要扫描的数组 arrayToFind 要查找的元素序列 startIndex 起始索引该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - contains
```
public static boolean contains(int[] array,
                               int intToFind)
```
    判断指定对象是否存在于指定数组中。如果数组为null则返回false。 array 要扫描的数组 intToFind 要查找的元素如果找到则返回true
  - contains
```
public static boolean contains(int[] array,
                               int[] arrayToFind)
```
    判断指定元素序列是否存在于指定数组中。如果数组为null则返回false。 array 要扫描的数组 arrayToFind 要查找的元素序列如果找到则返回true
  - indexOf
```
public static int indexOf(short[] array,
                          short shortToFind)
```
    在数组中查找一个元素。如果未找到或数组为null则返回-1。 array 要扫描的数组 shortToFind 要查找的元素该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - indexOf
```
public static int indexOf(short[] array,
                          short[] arrayToFind)
```
    在数组中查找一个元素序列。如果未找到或数组为null则返回-1。 array 要扫描的数组 arrayToFind 要查找的元素序列该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - indexOf
```
public static int indexOf(short[] array,
                          short shortToFind,
                          int startIndex)
```
    在数组中查找一个元素。如果未找到或数组为null则返回-1。起始索引小于0则看作0，超出数组长度的起始索引则返回-1。 array 要扫描的数组 shortToFind 要查找的元素 startIndex 起始索引该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - indexOf
```
public static int indexOf(short[] array,
                          short[] arrayToFind,
                          int startIndex)
```
    在数组中查找一个元素序列。如果未找到或数组为null则返回-1。起始索引小于0则看作0，超出数组长度的起始索引则返回-1。 array 要扫描的数组 arrayToFind 要查找的元素序列 startIndex 起始索引该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(short[] array,
                              short shortToFind)
```
    在数组中从末尾开始查找一个元素。如果未找到或数组为null则返回-1。 array 要扫描的数组 shortToFind 要查找的元素该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(short[] array,
                              short[] arrayToFind)
```
    在数组中从末尾开始查找一个元素序列。如果未找到或数组为null则返回-1。 array 要扫描的数组 arrayToFind 要查找的元素序列该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(short[] array,
                              short shortToFind,
                              int startIndex)
```
    在数组中从末尾开始查找一个元素。如果未找到或数组为null则返回-1。起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。 array 要扫描的数组 shortToFind 要查找的元素 startIndex 起始索引该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(short[] array,
                              short[] arrayToFind,
                              int startIndex)
```
    在数组中从末尾开始查找一个元素序列。如果未找到或数组为null则返回-1。起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。 array 要扫描的数组 arrayToFind 要查找的元素序列 startIndex 起始索引该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - contains
```
public static boolean contains(short[] array,
                               short shortToFind)
```
    判断指定对象是否存在于指定数组中。如果数组为null则返回false。 array 要扫描的数组 shortToFind 要查找的元素如果找到则返回true
  - contains
```
public static boolean contains(short[] array,
                               short[] arrayToFind)
```
    判断指定元素序列是否存在于指定数组中。如果数组为null则返回false。 array 要扫描的数组 arrayToFind 要查找的元素序列如果找到则返回true
  - indexOf
```
public static int indexOf(byte[] array,
                          byte byteToFind)
```
    在数组中查找一个元素。如果未找到或数组为null则返回-1。 array 要扫描的数组 byteToFind 要查找的元素该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - indexOf
```
public static int indexOf(byte[] array,
                          byte[] arrayToFind)
```
    在数组中查找一个元素序列。如果未找到或数组为null则返回-1。 array 要扫描的数组 arrayToFind 要查找的元素序列该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - indexOf
```
public static int indexOf(byte[] array,
                          byte byteToFind,
                          int startIndex)
```
    在数组中查找一个元素。如果未找到或数组为null则返回-1。起始索引小于0则看作0，超出数组长度的起始索引则返回-1。 array 要扫描的数组 byteToFind 要查找的元素 startIndex 起始索引该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - indexOf
```
public static int indexOf(byte[] array,
                          byte[] arrayToFind,
                          int startIndex)
```
    在数组中查找一个元素序列。如果未找到或数组为null则返回-1。起始索引小于0则看作0，超出数组长度的起始索引则返回-1。 array 要扫描的数组 arrayToFind 要查找的元素序列 startIndex 起始索引该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(byte[] array,
                              byte byteToFind)
```
    在数组中从末尾开始查找一个元素。如果未找到或数组为null则返回-1。 array 要扫描的数组 byteToFind 要查找的元素该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(byte[] array,
                              byte[] arrayToFind)
```
    在数组中从末尾开始查找一个元素序列。如果未找到或数组为null则返回-1。 array 要扫描的数组 arrayToFind 要查找的元素序列该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(byte[] array,
                              byte byteToFind,
                              int startIndex)
```
    在数组中从末尾开始查找一个元素。如果未找到或数组为null则返回-1。起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。 array 要扫描的数组 byteToFind 要查找的元素 startIndex 起始索引该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(byte[] array,
                              byte[] arrayToFind,
                              int startIndex)
```
    在数组中从末尾开始查找一个元素序列。如果未找到或数组为null则返回-1。起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。 array 要扫描的数组 arrayToFind 要查找的元素序列 startIndex 起始索引该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - contains
```
public static boolean contains(byte[] array,
                               byte byteToFind)
```
    判断指定对象是否存在于指定数组中。如果数组为null则返回false。 array 要扫描的数组 byteToFind 要查找的元素如果找到则返回true
  - contains
```
public static boolean contains(byte[] array,
                               byte[] arrayToFind)
```
    判断指定元素序列是否存在于指定数组中。如果数组为null则返回false。 array 要扫描的数组 arrayToFind 要查找的元素序列如果找到则返回true
  - indexOf
```
public static int indexOf(double[] array,
                          double doubleToFind)
```
    在数组中查找一个元素。如果未找到或数组为null则返回-1。 array 要扫描的数组 doubleToFind 要查找的元素该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - indexOf
```
public static int indexOf(double[] array,
                          double doubleToFind,
                          double tolerance)
```
    在数组中查找一个元素。如果未找到或数组为null则返回-1。 array 要扫描的数组 doubleToFind 要查找的元素 tolerance 误差该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - indexOf
```
public static int indexOf(double[] array,
                          double[] arrayToFind)
```
    在数组中查找一个元素序列。如果未找到或数组为null则返回-1。 array 要扫描的数组 arrayToFind 要查找的元素序列该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - indexOf
```
public static int indexOf(double[] array,
                          double[] arrayToFind,
                          double tolerance)
```
    在数组中查找一个元素序列。如果未找到或数组为null则返回-1。 array 要扫描的数组 arrayToFind 要查找的元素序列 tolerance 误差该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - indexOf
```
public static int indexOf(double[] array,
                          double doubleToFind,
                          int startIndex)
```
    在数组中查找一个元素。如果未找到或数组为null则返回-1。起始索引小于0则看作0，超出数组长度的起始索引则返回-1。 array 要扫描的数组 doubleToFind 要查找的元素 startIndex 起始索引该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - indexOf
```
public static int indexOf(double[] array,
                          double doubleToFind,
                          int startIndex,
                          double tolerance)
```
    在数组中查找一个元素。如果未找到或数组为null则返回-1。起始索引小于0则看作0，超出数组长度的起始索引则返回-1。 array 要扫描的数组 doubleToFind 要查找的元素 startIndex 起始索引 tolerance 误差该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - indexOf
```
public static int indexOf(double[] array,
                          double[] arrayToFind,
                          int startIndex)
```
    在数组中查找一个元素序列。如果未找到或数组为null则返回-1。起始索引小于0则看作0，超出数组长度的起始索引则返回-1。 array 要扫描的数组 arrayToFind 要查找的元素序列 startIndex 起始索引该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - indexOf
```
public static int indexOf(double[] array,
                          double[] arrayToFind,
                          int startIndex,
                          double tolerance)
```
    在数组中查找一个元素序列。如果未找到或数组为null则返回-1。起始索引小于0则看作0，超出数组长度的起始索引则返回-1。 array 要扫描的数组 arrayToFind 要查找的元素序列 startIndex 起始索引 tolerance 误差该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(double[] array,
                              double doubleToFind)
```
    在数组中从末尾开始查找一个元素。如果未找到或数组为null则返回-1。 array 要扫描的数组 doubleToFind 要查找的元素该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(double[] array,
                              double doubleToFind,
                              double tolerance)
```
    在数组中从末尾开始查找一个元素。如果未找到或数组为null则返回-1。 array 要扫描的数组 doubleToFind 要查找的元素 tolerance 误差该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(double[] array,
                              double[] arrayToFind)
```
    在数组中从末尾开始查找一个元素序列。如果未找到或数组为null则返回-1。 array 要扫描的数组 arrayToFind 要查找的元素序列该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(double[] array,
                              double[] arrayToFind,
                              double tolerance)
```
    在数组中从末尾开始查找一个元素序列。如果未找到或数组为null则返回-1。 array 要扫描的数组 arrayToFind 要查找的元素序列 tolerance 误差该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(double[] array,
                              double doubleToFind,
                              int startIndex)
```
    在数组中从末尾开始查找一个元素。如果未找到或数组为null则返回-1。起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。 array 要扫描的数组 doubleToFind 要查找的元素 startIndex 起始索引该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(double[] array,
                              double doubleToFind,
                              int startIndex,
                              double tolerance)
```
    在数组中从末尾开始查找一个元素。如果未找到或数组为null则返回-1。起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。 array 要扫描的数组 doubleToFind 要查找的元素 startIndex 起始索引 tolerance 误差该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(double[] array,
                              double[] arrayToFind,
                              int startIndex)
```
    在数组中从末尾开始查找一个元素序列。如果未找到或数组为null则返回-1。起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。 array 要扫描的数组 arrayToFind 要查找的元素序列 startIndex 起始索引该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(double[] array,
                              double[] arrayToFind,
                              int startIndex,
                              double tolerance)
```
    在数组中从末尾开始查找一个元素序列。如果未找到或数组为null则返回-1。起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。 array 要扫描的数组 arrayToFind 要查找的元素序列 startIndex 起始索引 tolerance 误差该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - contains
```
public static boolean contains(double[] array,
                               double doubleToFind)
```
    判断指定对象是否存在于指定数组中。如果数组为null则返回false。 array 要扫描的数组 doubleToFind 要查找的元素如果找到则返回true
  - contains
```
public static boolean contains(double[] array,
                               double doubleToFind,
                               double tolerance)
```
    判断指定对象是否存在于指定数组中。如果数组为null则返回false。 array 要扫描的数组 doubleToFind 要查找的元素 tolerance 误差如果找到则返回true
  - contains
```
public static boolean contains(double[] array,
                               double[] arrayToFind)
```
    判断指定元素序列是否存在于指定数组中。如果数组为null则返回false。 array 要扫描的数组 arrayToFind 要查找的元素序列如果找到则返回true
  - contains
```
public static boolean contains(double[] array,
                               double[] arrayToFind,
                               double tolerance)
```
    判断指定元素序列是否存在于指定数组中。如果数组为null则返回false。 array 要扫描的数组 arrayToFind 要查找的元素序列 tolerance 误差如果找到则返回true
  - indexOf
```
public static int indexOf(float[] array,
                          float floatToFind)
```
    在数组中查找一个元素。如果未找到或数组为null则返回-1。 array 要扫描的数组 floatToFind 要查找的元素该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - indexOf
```
public static int indexOf(float[] array,
                          float floatToFind,
                          float tolerance)
```
    在数组中查找一个元素。如果未找到或数组为null则返回-1。 array 要扫描的数组 floatToFind 要查找的元素 tolerance 误差该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - indexOf
```
public static int indexOf(float[] array,
                          float[] arrayToFind)
```
    在数组中查找一个元素序列。如果未找到或数组为null则返回-1。 array 要扫描的数组 arrayToFind 要查找的元素序列该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - indexOf
```
public static int indexOf(float[] array,
                          float[] arrayToFind,
                          float tolerance)
```
    在数组中查找一个元素序列。如果未找到或数组为null则返回-1。 array 要扫描的数组 arrayToFind 要查找的元素序列 tolerance 误差该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - indexOf
```
public static int indexOf(float[] array,
                          float floatToFind,
                          int startIndex)
```
    在数组中查找一个元素。如果未找到或数组为null则返回-1。起始索引小于0则看作0，超出数组长度的起始索引则返回-1。 array 要扫描的数组 floatToFind 要查找的元素 startIndex 起始索引该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - indexOf
```
public static int indexOf(float[] array,
                          float floatToFind,
                          int startIndex,
                          float tolerance)
```
    在数组中查找一个元素。如果未找到或数组为null则返回-1。起始索引小于0则看作0，超出数组长度的起始索引则返回-1。 array 要扫描的数组 floatToFind 要查找的元素 startIndex 起始索引 tolerance 误差该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - indexOf
```
public static int indexOf(float[] array,
                          float[] arrayToFind,
                          int startIndex)
```
    在数组中查找一个元素序列。如果未找到或数组为null则返回-1。起始索引小于0则看作0，超出数组长度的起始索引则返回-1。 array 要扫描的数组 arrayToFind 要查找的元素序列 startIndex 起始索引该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - indexOf
```
public static int indexOf(float[] array,
                          float[] arrayToFind,
                          int startIndex,
                          float tolerance)
```
    在数组中查找一个元素序列。如果未找到或数组为null则返回-1。起始索引小于0则看作0，超出数组长度的起始索引则返回-1。 array 要扫描的数组 arrayToFind 要查找的元素序列 startIndex 起始索引 tolerance 误差该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(float[] array,
                              float floatToFind)
```
    在数组中从末尾开始查找一个元素。如果未找到或数组为null则返回-1。 array 要扫描的数组 floatToFind 要查找的元素该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(float[] array,
                              float floatToFind,
                              float tolerance)
```
    在数组中从末尾开始查找一个元素。如果未找到或数组为null则返回-1。 array 要扫描的数组 floatToFind 要查找的元素 tolerance 误差该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(float[] array,
                              float[] arrayToFind)
```
    在数组中从末尾开始查找一个元素序列。如果未找到或数组为null则返回-1。 array 要扫描的数组 arrayToFind 要查找的元素序列该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(float[] array,
                              float[] arrayToFind,
                              float tolerance)
```
    在数组中从末尾开始查找一个元素序列。如果未找到或数组为null则返回-1。 array 要扫描的数组 arrayToFind 要查找的元素序列 tolerance 误差该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(float[] array,
                              float floatToFind,
                              int startIndex)
```
    在数组中从末尾开始查找一个元素。如果未找到或数组为null则返回-1。起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。 array 要扫描的数组 floatToFind 要查找的元素 startIndex 起始索引该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(float[] array,
                              float floatToFind,
                              int startIndex,
                              float tolerance)
```
    在数组中从末尾开始查找一个元素。如果未找到或数组为null则返回-1。起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。 array 要扫描的数组 floatToFind 要查找的元素 startIndex 起始索引 tolerance 误差该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(float[] array,
                              float[] arrayToFind,
                              int startIndex)
```
    在数组中从末尾开始查找一个元素序列。如果未找到或数组为null则返回-1。起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。 array 要扫描的数组 arrayToFind 要查找的元素序列 startIndex 起始索引该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(float[] array,
                              float[] arrayToFind,
                              int startIndex,
                              float tolerance)
```
    在数组中从末尾开始查找一个元素序列。如果未找到或数组为null则返回-1。起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。 array 要扫描的数组 arrayToFind 要查找的元素序列 startIndex 起始索引 tolerance 误差该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - contains
```
public static boolean contains(float[] array,
                               float floatToFind)
```
    判断指定对象是否存在于指定数组中。如果数组为null则返回false。 array 要扫描的数组 floatToFind 要查找的元素如果找到则返回true
  - contains
```
public static boolean contains(float[] array,
                               float floatToFind,
                               float tolerance)
```
    判断指定对象是否存在于指定数组中。如果数组为null则返回false。 array 要扫描的数组 floatToFind 要查找的元素 tolerance 误差如果找到则返回true
  - contains
```
public static boolean contains(float[] array,
                               float[] arrayToFind)
```
    判断指定元素序列是否存在于指定数组中。如果数组为null则返回false。 array 要扫描的数组 arrayToFind 要查找的元素序列如果找到则返回true
  - contains
```
public static boolean contains(float[] array,
                               float[] arrayToFind,
                               float tolerance)
```
    判断指定元素序列是否存在于指定数组中。如果数组为null则返回false。 array 要扫描的数组 arrayToFind 要查找的元素序列 tolerance 误差如果找到则返回true
  - indexOf
```
public static int indexOf(boolean[] array,
                          boolean booleanToFind)
```
    在数组中查找一个元素。如果未找到或数组为null则返回-1。 array 要扫描的数组 booleanToFind 要查找的元素该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - indexOf
```
public static int indexOf(boolean[] array,
                          boolean[] arrayToFind)
```
    在数组中查找一个元素序列。如果未找到或数组为null则返回-1。 array 要扫描的数组 arrayToFind 要查找的元素序列该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - indexOf
```
public static int indexOf(boolean[] array,
                          boolean booleanToFind,
                          int startIndex)
```
    在数组中查找一个元素。如果未找到或数组为null则返回-1。起始索引小于0则看作0，超出数组长度的起始索引则返回-1。 array 要扫描的数组 booleanToFind 要查找的元素 startIndex 起始索引该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - indexOf
```
public static int indexOf(boolean[] array,
                          boolean[] arrayToFind,
                          int startIndex)
```
    在数组中查找一个元素序列。如果未找到或数组为null则返回-1。起始索引小于0则看作0，超出数组长度的起始索引则返回-1。 array 要扫描的数组 arrayToFind 要查找的元素序列 startIndex 起始索引该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(boolean[] array,
                              boolean booleanToFind)
```
    在数组中从末尾开始查找一个元素。如果未找到或数组为null则返回-1。 array 要扫描的数组 booleanToFind 要查找的元素该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(boolean[] array,
                              boolean[] arrayToFind)
```
    在数组中从末尾开始查找一个元素序列。如果未找到或数组为null则返回-1。 array 要扫描的数组 arrayToFind 要查找的元素序列该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(boolean[] array,
                              boolean booleanToFind,
                              int startIndex)
```
    在数组中从末尾开始查找一个元素。如果未找到或数组为null则返回-1。起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。 array 要扫描的数组 booleanToFind 要查找的元素 startIndex 起始索引该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(boolean[] array,
                              boolean[] arrayToFind,
                              int startIndex)
```
    在数组中从末尾开始查找一个元素序列。如果未找到或数组为null则返回-1。起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。 array 要扫描的数组 arrayToFind 要查找的元素序列 startIndex 起始索引该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - contains
```
public static boolean contains(boolean[] array,
                               boolean booleanToFind)
```
    判断指定对象是否存在于指定数组中。如果数组为null则返回false。 array 要扫描的数组 booleanToFind 要查找的元素如果找到则返回true
  - contains
```
public static boolean contains(boolean[] array,
                               boolean[] arrayToFind)
```
    判断指定元素序列是否存在于指定数组中。如果数组为null则返回false。 array 要扫描的数组 arrayToFind 要查找的元素序列如果找到则返回true
  - indexOf
```
public static int indexOf(char[] array,
                          char charToFind)
```
    在数组中查找一个元素。如果未找到或数组为null则返回-1。 array 要扫描的数组 charToFind 要查找的元素该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - indexOf
```
public static int indexOf(char[] array,
                          char[] arrayToFind)
```
    在数组中查找一个元素序列。如果未找到或数组为null则返回-1。 array 要扫描的数组 arrayToFind 要查找的元素序列该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - indexOf
```
public static int indexOf(char[] array,
                          char charToFind,
                          int startIndex)
```
    在数组中查找一个元素。如果未找到或数组为null则返回-1。起始索引小于0则看作0，超出数组长度的起始索引则返回-1。 array 要扫描的数组 charToFind 要查找的元素 startIndex 起始索引该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - indexOf
```
public static int indexOf(char[] array,
                          char[] arrayToFind,
                          int startIndex)
```
    在数组中查找一个元素序列。如果未找到或数组为null则返回-1。起始索引小于0则看作0，超出数组长度的起始索引则返回-1。 array 要扫描的数组 arrayToFind 要查找的元素序列 startIndex 起始索引该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(char[] array,
                              char charToFind)
```
    在数组中从末尾开始查找一个元素。如果未找到或数组为null则返回-1。 array 要扫描的数组 charToFind 要查找的元素该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(char[] array,
                              char[] arrayToFind)
```
    在数组中从末尾开始查找一个元素序列。如果未找到或数组为null则返回-1。 array 要扫描的数组 arrayToFind 要查找的元素序列该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(char[] array,
                              char charToFind,
                              int startIndex)
```
    在数组中从末尾开始查找一个元素。如果未找到或数组为null则返回-1。起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。 array 要扫描的数组 charToFind 要查找的元素 startIndex 起始索引该元素在数组中的序号，如果数组为null或未找到，则返回-1。
  - lastIndexOf
```
public static int lastIndexOf(char[] array,
                              char[] arrayToFind,
                              int startIndex)
```
    在数组中从末尾开始查找一个元素序列。如果未找到或数组为null则返回-1。起始索引小于0则返回-1，超出数组长度的起始索引则从数组末尾开始找。 array 要扫描的数组 arrayToFind 要查找的元素序列 startIndex 起始索引该元素序列在数组中的序号，如果数组为null或未找到，则返回-1。
  - contains
```
public static boolean contains(char[] array,
                               char charToFind)
```
    判断指定对象是否存在于指定数组中。如果数组为null则返回false。 array 要扫描的数组 charToFind 要查找的元素如果找到则返回true
  - contains
```
public static boolean contains(char[] array,
                               char[] arrayToFind)
```
    判断指定元素序列是否存在于指定数组中。如果数组为null则返回false。 array 要扫描的数组 arrayToFind 要查找的元素序列如果找到则返回true
  - toString
```
public static String toString(Object array)
```
    将数组转换成易于阅读的字符串表示。 array 要转换的数组字符串表示，"[]"表示空数组或null
  - toString
```
public static String toString(Object array,
                              String nullArrayStr)
```
    将数组转换成易于阅读的字符串表示。 array 要转换的数组 nullArrayStr 如果数组是null，则返回此字符串字符串表示，或返回指定字符串表示null
  - toString
```
public static String toString(Object array,
                              String nullArrayStr,
                              String nullElementStr)
```
    将数组转换成易于阅读的字符串表示。如果数组是null则返回指定字符串，支持多维数组。如果数组元素为null，则显示指定字符串。
```
 ArrayUtil.toString(null, "null", "NULL")                              = "null"
 ArrayUtil.toString(new int[] {1, 2, 3}, "null", "NULL")               = "[1, 2, 3]"
 ArrayUtil.toString(new boolean[] {true, false, true}, "null", "NULL") = "[true, false, true]"
 ArrayUtil.toString(new Object[] {
                       {1, 2, 3},  // 嵌套数组
                       hello,      // 嵌套非数组
                       null,       // 嵌套null
                       {},         // 嵌套空数组
                       {2, 3, 4}   // 嵌套数组
                    }, "null", "NULL")                                 = "[[1, 2, 3], hello, NULL, [], [2, 3, 4]]"
 
```
    array 要转换的数组 nullArrayStr 如果数组是null，则返回此字符串 nullElementStr 如果数组中的元素为null，则返回此字符串字符串表示，或返回指定字符串表示null

类 ArrayUtil

字段概要

构造器概要

方法概要

从类继承的方法 java.lang.Object

字段详细资料

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

构造器详细资料

ArrayUtil

方法详细资料

isEmpty

isEmpty

isEmpty

isEmpty

isEmpty

isEmpty

isEmpty

isEmpty

isEmpty

isNotEmpty

isNotEmpty

isNotEmpty

isNotEmpty

isNotEmpty

isNotEmpty

isNotEmpty

isNotEmpty

isNotEmpty

defaultIfNull

defaultIfNull

defaultIfNull

defaultIfNull

defaultIfNull

defaultIfNull

defaultIfNull

defaultIfNull

defaultIfNull

defaultIfNull

defaultIfNull

defaultIfNull

defaultIfNull

defaultIfNull

defaultIfNull

defaultIfNull

defaultIfNull

defaultIfNull

defaultIfNull

defaultIfEmpty

defaultIfEmpty

defaultIfEmpty

defaultIfEmpty

defaultIfEmpty

defaultIfEmpty

defaultIfEmpty

defaultIfEmpty

defaultIfEmpty

defaultIfEmpty

defaultIfEmpty

defaultIfEmpty

defaultIfEmpty

defaultIfEmpty

defaultIfEmpty