ArrayKit (blade-kit 1.0.5 API)

java.lang.Object
- blade.kit.ArrayKit

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

本工具类是对JDK Arrays的补充。

从以下版本开始:

1.0

作者:

biezhi

构造器概要

构造器
构造器和说明

ArrayKit()

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

方法概要

All Methods Static Methods Concrete Methods
限定符和类型	方法和说明
`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 short[]`	`addAll(short[] array1, short[] array2)`
`static <T> T[]`	`addAll(T[] array1, T[] array2)`
`static <T> Iterable<T>`	`arrayAsIterable(Class<T> componentType, Object array)` 将数组转换成Iterable列表。
`static byte[]`	`booleanToByte(boolean[] values)`
`static char[]`	`booleanToChar(boolean[] values)`
`static double[]`	`booleanToDouble(boolean[] values)`
`static float[]`	`booleanToFloat(boolean[] values)`
`static int[]`	`booleanToInt(boolean[] values)`
`static long[]`	`booleanToLong(boolean[] values)`
`static short[]`	`booleanToShort(boolean[] values)`
`static String[]`	`booleanToString(boolean[] values)`
`static boolean[]`	`byteToBoolean(byte[] values)`
`static char[]`	`byteToChar(byte[] values)`
`static double[]`	`byteToDouble(byte[] values)`
`static float[]`	`byteToFloat(byte[] values)`
`static int[]`	`byteToInt(byte[] values)`
`static long[]`	`byteToLong(byte[] values)`
`static short[]`	`byteToShort(byte[] values)`
`static String[]`	`byteToString(byte[] values)`
`static boolean[]`	`charToBoolean(char[] values)`
`static byte[]`	`charToByte(char[] values)`
`static double[]`	`charToDouble(char[] values)`
`static float[]`	`charToFloat(char[] values)`
`static int[]`	`charToInt(char[] values)`
`static long[]`	`charToLong(char[] values)`
`static short[]`	`charToShort(char[] values)`
`static String[]`	`charToString(char[] values)`
`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 short[]`	`clone(short[] array)` 复制一个数组。
`static <T> T[]`	`clone(T[] 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 <T> T[]`	`create(int length, Class<T> type)`
`static <T,S extends T> T`	`defaultIfEmpty(T array, S defaultValue)` 如果数组是null或空数组[]，则返回指定数组默认值。
`static boolean[]`	`doubleToBoolean(double[] values)`
`static byte[]`	`doubleToByte(double[] values)`
`static char[]`	`doubleToChar(double[] values)`
`static float[]`	`doubleToFloat(double[] values)`
`static int[]`	`doubleToInt(double[] values)`
`static long[]`	`doubleToLong(double[] values)`
`static short[]`	`doubleToShort(double[] values)`
`static String[]`	`doubleToString(double[] values)`
`static boolean[]`	`floatToBoolean(float[] values)`
`static byte[]`	`floatToByte(float[] values)`
`static char[]`	`floatToChar(float[] values)`
`static double[]`	`floatToDouble(float[] values)`
`static int[]`	`floatToInt(float[] values)`
`static long[]`	`floatToLong(float[] values)`
`static short[]`	`floatToShort(float[] values)`
`static String[]`	`floatToString(float[] values)`
`static int`	`getLength(Object array)`
`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[]`	`intToBoolean(int[] values)`
`static byte[]`	`intToByte(int[] values)`
`static char[]`	`intToChar(int[] values)`
`static double[]`	`intToDouble(int[] values)`
`static float[]`	`intToFloat(int[] values)`
`static long[]`	`intToLong(int[] values)`
`static short[]`	`intToShort(int[] values)`
`static String[]`	`intToString(int[] values)`
`static <T> boolean`	`isCompatible(T[] arrayA, T[] arrayB)` 判断两个数组的相容性, 如果一个被另一个包含，即为相容
`static boolean`	`isEmpty(Object array)` 检查数组是否为null或空数组[]。
`static boolean`	`isNotEmpty(Object 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 int`	`length(Object array)` 取得数组的长度。
`static boolean[]`	`longToBoolean(long[] values)`
`static byte[]`	`longToByte(long[] values)`
`static char[]`	`longToChar(long[] values)`
`static double[]`	`longToDouble(long[] values)`
`static float[]`	`longToFloat(long[] values)`
`static int[]`	`longToInt(long[] values)`
`static short[]`	`longToShort(long[] values)`
`static String[]`	`longToString(long[] values)`
`static boolean[]`	`remove(boolean[] array, int index)`
`static boolean[]`	`remove(boolean[] buffer, int offset, int length)`
`static byte[]`	`remove(byte[] array, int index)`
`static byte[]`	`remove(byte[] buffer, int offset, int length)`
`static char[]`	`remove(char[] array, int index)`
`static char[]`	`remove(char[] buffer, int offset, int length)`
`static double[]`	`remove(double[] array, int index)`
`static double[]`	`remove(double[] buffer, int offset, int length)`
`static float[]`	`remove(float[] array, int index)`
`static float[]`	`remove(float[] buffer, int offset, int length)`
`static int[]`	`remove(int[] array, int index)`
`static int[]`	`remove(int[] buffer, int offset, int length)`
`static long[]`	`remove(long[] array, int index)`
`static long[]`	`remove(long[] buffer, int offset, int length)`
`static short[]`	`remove(short[] array, int index)`
`static short[]`	`remove(short[] buffer, int offset, int length)`
`static String[]`	`remove(String[] buffer, int offset, int length)`
`static <T> T[]`	`remove(T[] array, int index)`
`static <T> T[]`	`remove(T[] buffer, int offset, int length)`
`static <T> T[]`	`remove(T[] buffer, int offset, int length, Class<?> componentType)`
`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 Object[]`	`removeElement(Object[] array, Object element)`
`static short[]`	`removeElement(short[] array, short element)`
`static boolean[]`	`resize(boolean[] buffer, int newSize)`
`static byte[]`	`resize(byte[] buffer, int newSize)`
`static char[]`	`resize(char[] buffer, int newSize)`
`static double[]`	`resize(double[] buffer, int newSize)`
`static float[]`	`resize(float[] buffer, int newSize)`
`static int[]`	`resize(int[] buffer, int newSize)`
`static long[]`	`resize(long[] buffer, int newSize)`
`static short[]`	`resize(short[] buffer, int newSize)`
`static String[]`	`resize(String[] buffer, int newSize)`
`static <T> T[]`	`resize(T[] buffer, int newSize)`
`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 boolean[]`	`shortToBoolean(short[] values)`
`static byte[]`	`shortToByte(short[] values)`
`static char[]`	`shortToChar(short[] values)`
`static double[]`	`shortToDouble(short[] values)`
`static float[]`	`shortToFloat(short[] values)`
`static int[]`	`shortToInt(short[] values)`
`static long[]`	`shortToLong(short[] values)`
`static String[]`	`shortToString(short[] values)`
`static boolean[]`	`subarray(boolean[] buffer, int offset, int length)`
`static byte[]`	`subarray(byte[] buffer, int offset, int length)`
`static char[]`	`subarray(char[] buffer, int offset, int length)`
`static double[]`	`subarray(double[] buffer, int offset, int length)`
`static float[]`	`subarray(float[] buffer, int offset, int length)`
`static int[]`	`subarray(int[] buffer, int offset, int length)`
`static long[]`	`subarray(long[] buffer, int offset, int length)`
`static short[]`	`subarray(short[] buffer, int offset, int length)`
`static String[]`	`subarray(String[] buffer, int offset, int length)`
`static <T> T[]`	`subarray(T[] buffer, int offset, int length)`
`static <T> T[]`	`subarray(T[] buffer, int offset, int length, Class<T> componentType)`
`static <K,V> Map<K,V>`	`toMap(Object[][] keyValueArray, Class<K> keyType, Class<V> valueType)` 将数组转换成Map。
`static <K,V> Map<K,V>`	`toMap(Object[][] keyValueArray, Class<K> keyType, Class<V> valueType, Map<K,V> map)` 将数组转换成Map。
`static String`	`toString(Object array)` 将数组转换成易于阅读的字符串表示。
`static String`	`toString(Object array, String nullArrayStr)` 将数组转换成易于阅读的字符串表示。
`static String`	`toString(Object array, String nullArrayStr, String nullElementStr)` 将数组转换成易于阅读的字符串表示。
`static String[]`	`toStringArray(boolean[] array)`
`static String[]`	`toStringArray(byte[] array)`
`static String[]`	`toStringArray(char[] array)`
`static String[]`	`toStringArray(double[] array)`
`static String[]`	`toStringArray(float[] array)`
`static String[]`	`toStringArray(int[] array)`
`static String[]`	`toStringArray(long[] array)`
`static String[]`	`toStringArray(Object value)`
`static String[]`	`toStringArray(Object[] array)`
`static String[]`	`toStringArray(short[] array)`
`static String[]`	`toStringArray(String[] array)`

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

- 构造器详细资料
  - ArrayKit
```
public ArrayKit()
```
- 方法详细资料
  - length
```
public static int length(Object array)
```
    取得数组的长度。FIXME，先这样
    此方法比Array.getLength()要快得多。
    
    参数:
    
    array - 要检查的数组
    
    返回:
    
    如果为空，或者非数组，则返回0。
  - isEmpty
```
public static boolean isEmpty(Object array)
```
    检查数组是否为null或空数组[]。
```
 ArrayUtil.isEmpty(null)              = true
 ArrayUtil.isEmpty(new int[0])        = true
 ArrayUtil.isEmpty(new int[10])       = false
 
```
    参数:
    
    array - 要检查的数组
    
    返回:
    
    如果为空, 则返回true
  - isNotEmpty
```
public static boolean isNotEmpty(Object array)
```
    检查数组是否为null或空数组[]。
```
 ArrayUtil.isNotEmpty(null)              = false
 ArrayUtil.isNotEmpty(new int[0])        = false
 ArrayUtil.isNotEmpty(new int[10])       = true
 
```
    参数:
    
    array - 要检查的数组
    
    返回:
    
    如果不为空, 则返回true
  - defaultIfEmpty
```
public static <T,S extends T> T defaultIfEmpty(T array,
                                               S defaultValue)
```
    如果数组是null或空数组[]，则返回指定数组默认值。
```
 ArrayUtil.defaultIfEmpty(null, defaultArray)           = defaultArray
 ArrayUtil.defaultIfEmpty(new String[0], defaultArray)  = 数组本身
 ArrayUtil.defaultIfEmpty(new String[10], defaultArray) = 数组本身
 
```
    参数:
    
    array - 要转换的数组
    
    defaultArray - 默认数组
    
    返回:
    
    数组本身或默认数组
  - arrayAsIterable
```
public static <T> Iterable<T> arrayAsIterable(Class<T> componentType,
                                              Object array)
```
    将数组转换成Iterable列表。
    如果输入数组为null，则视作空数组。
    
    该方法返回的Iterable对象是轻量而高效的，不会产生复制数组的开销。你可以使用 CollectionUtil.createArrayList(asIterable(componentType, array))或 CollectionUtil.createLinkedList(asIterable(componentType, array)) 来进一步将 Iterable 转换成指定类型的 List对象。
    
    参数:
    
    componentType - Iterable元素的类型，必须和数组类型兼容。例如对于 int[] 数组， componentType 必须为 Integer.class。
    
    array - 要转换的数组
    
    返回:
    
    被创建的Iterable对象
  - toMap
```
public static <K,V> Map<K,V> toMap(Object[][] keyValueArray,
                                   Class<K> keyType,
                                   Class<V> valueType)
```
    将数组转换成Map。数组的元素必须是元素个数多于2的子数组。
```
 Map colorMap = ArrayUtil.toMap(new String[][] {{
     {"RED", 0xFF0000},
     {"GREEN", 0x00FF00},
     {"BLUE", 0x0000FF}}, String.class, Integer.class);
 
```
    参数:
    
    keyValueArray - 要转换的数组
    
    keyType - key的类型，数组元素keyValueArray[n][0]的类型必须与之兼容
    
    valueType - value的类型，数组元素keyValueArray[n][1]的类型必须与之兼容
    
    返回:
    
    被创建的map
  - toMap
```
public static <K,V> Map<K,V> toMap(Object[][] keyValueArray,
                                   Class<K> keyType,
                                   Class<V> valueType,
                                   Map<K,V> map)
```
    将数组转换成Map。数组的元素必须是元素个数多于2的子数组。
```
 Map colorMap = ArrayUtil.toMap(new String[][] {{
     {"RED", 0xFF0000},
     {"GREEN", 0x00FF00},
     {"BLUE", 0x0000FF}}, String.class, Integer.class, map);
 
```
    参数:
    
    keyValueArray - 要转换的数组
    
    keyType - key的类型，数组元素keyValueArray[n][0]的类型必须与之兼容
    
    valueType - value的类型，数组元素keyValueArray[n][1]的类型必须与之兼容
    
    map - 要填充的map，如果为null则自动创建之
    
    返回:
    
    被创建或填充的map
  - 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
  - clone
```
public static <T> T[] clone(T[] 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
  - addAll
```
public static <T> T[] addAll(T[] array1,
                             T[] array2)
```
  - addAll
```
public static boolean[] addAll(boolean[] array1,
                               boolean[] array2)
```
  - addAll
```
public static char[] addAll(char[] array1,
                            char[] array2)
```
  - addAll
```
public static byte[] addAll(byte[] array1,
                            byte[] array2)
```
  - addAll
```
public static short[] addAll(short[] array1,
                             short[] array2)
```
  - addAll
```
public static int[] addAll(int[] array1,
                           int[] array2)
```
  - addAll
```
public static long[] addAll(long[] array1,
                            long[] array2)
```
  - addAll
```
public static float[] addAll(float[] array1,
                             float[] array2)
```
  - addAll
```
public static double[] addAll(double[] array1,
                              double[] array2)
```
  - toString
```
public static String toString(Object array)
```
    将数组转换成易于阅读的字符串表示。
    如果数组是null则返回[]，支持多维数组。如果数组元素为null ，则显示<null>。
```
 ArrayUtil.toString(null)                              = "[]"
 ArrayUtil.toString(new int[] {1, 2, 3})               = "[1, 2, 3]"
 ArrayUtil.toString(new boolean[] {true, false, true}) = "[true, false, true]"
 ArrayUtil.toString(new Object[] {
                       {1, 2, 3},  // 嵌套数组
                       hello,      // 嵌套非数组
                       null,       // 嵌套null
                       {},         // 嵌套空数组
                       {2, 3, 4}   // 嵌套数组
                    })                                 = "[[1, 2, 3], hello, <null>, [], [2, 3, 4]]"
 
```
    参数:
    
    array - 要转换的数组
    
    返回:
    
    字符串表示，"[]"表示空数组或null
  - toString
```
public static String toString(Object array,
                              String nullArrayStr)
```
    将数组转换成易于阅读的字符串表示。
    如果数组是null则返回指定字符串，支持多维数组。如果数组元素为null，则显示 <null>。
```
 ArrayUtil.toString(null, "null")                              = "null"
 ArrayUtil.toString(new int[] {1, 2, 3}, "null")               = "[1, 2, 3]"
 ArrayUtil.toString(new boolean[] {true, false, true}, "null") = "[true, false, true]"
 ArrayUtil.toString(new Object[] {
                       {1, 2, 3},  // 嵌套数组
                       hello,      // 嵌套非数组
                       null,       // 嵌套null
                       {},         // 嵌套空数组
                       {2, 3, 4}   // 嵌套数组
                    }, "null")                                 = "[[1, 2, 3], hello, <null>, [], [2, 3, 4]]"
 
```
    参数:
    
    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
  - isCompatible
```
public static <T> boolean isCompatible(T[] arrayA,
                                       T[] arrayB)
```
    判断两个数组的相容性, 如果一个被另一个包含，即为相容
    
    类型参数:
    
    T -
    
    参数:
    
    arrayA - 数组A
    
    arrayB - 数组B
    
    返回:
    
    如果相容则返回true，否则返回false
  - resize
```
public static <T> T[] resize(T[] buffer,
                             int newSize)
```
  - resize
```
public static String[] resize(String[] buffer,
                              int newSize)
```
  - resize
```
public static byte[] resize(byte[] buffer,
                            int newSize)
```
  - resize
```
public static char[] resize(char[] buffer,
                            int newSize)
```
  - resize
```
public static short[] resize(short[] buffer,
                             int newSize)
```
  - resize
```
public static int[] resize(int[] buffer,
                           int newSize)
```
  - resize
```
public static long[] resize(long[] buffer,
                            int newSize)
```
  - resize
```
public static float[] resize(float[] buffer,
                             int newSize)
```
  - resize
```
public static double[] resize(double[] buffer,
                              int newSize)
```
  - resize
```
public static boolean[] resize(boolean[] buffer,
                               int newSize)
```
  - toStringArray
```
public static String[] toStringArray(Object[] array)
```
  - toStringArray
```
public static String[] toStringArray(String[] array)
```
  - toStringArray
```
public static String[] toStringArray(byte[] array)
```
  - toStringArray
```
public static String[] toStringArray(char[] array)
```
  - toStringArray
```
public static String[] toStringArray(short[] array)
```
  - toStringArray
```
public static String[] toStringArray(int[] array)
```
  - toStringArray
```
public static String[] toStringArray(long[] array)
```
  - toStringArray
```
public static String[] toStringArray(float[] array)
```
  - toStringArray
```
public static String[] toStringArray(double[] array)
```
  - toStringArray
```
public static String[] toStringArray(boolean[] array)
```
  - toStringArray
```
public static String[] toStringArray(Object value)
```
  - charToBoolean
```
public static boolean[] charToBoolean(char[] values)
```
  - intToBoolean
```
public static boolean[] intToBoolean(int[] values)
```
  - longToBoolean
```
public static boolean[] longToBoolean(long[] values)
```
  - doubleToBoolean
```
public static boolean[] doubleToBoolean(double[] values)
```
  - floatToBoolean
```
public static boolean[] floatToBoolean(float[] values)
```
  - byteToBoolean
```
public static boolean[] byteToBoolean(byte[] values)
```
  - shortToBoolean
```
public static boolean[] shortToBoolean(short[] values)
```
  - charToByte
```
public static byte[] charToByte(char[] values)
```
  - intToByte
```
public static byte[] intToByte(int[] values)
```
  - longToByte
```
public static byte[] longToByte(long[] values)
```
  - doubleToByte
```
public static byte[] doubleToByte(double[] values)
```
  - floatToByte
```
public static byte[] floatToByte(float[] values)
```
  - shortToByte
```
public static byte[] shortToByte(short[] values)
```
  - booleanToByte
```
public static byte[] booleanToByte(boolean[] values)
```
  - intToChar
```
public static char[] intToChar(int[] values)
```
  - longToChar
```
public static char[] longToChar(long[] values)
```
  - doubleToChar
```
public static char[] doubleToChar(double[] values)
```
  - floatToChar
```
public static char[] floatToChar(float[] values)
```
  - shortToChar
```
public static char[] shortToChar(short[] values)
```
  - booleanToChar
```
public static char[] booleanToChar(boolean[] values)
```
  - byteToChar
```
public static char[] byteToChar(byte[] values)
```
  - intToDouble
```
public static double[] intToDouble(int[] values)
```
  - longToDouble
```
public static double[] longToDouble(long[] values)
```
  - charToDouble
```
public static double[] charToDouble(char[] values)
```
  - floatToDouble
```
public static double[] floatToDouble(float[] values)
```
  - shortToDouble
```
public static double[] shortToDouble(short[] values)
```
  - booleanToDouble
```
public static double[] booleanToDouble(boolean[] values)
```
  - byteToDouble
```
public static double[] byteToDouble(byte[] values)
```
  - intToFloat
```
public static float[] intToFloat(int[] values)
```
  - longToFloat
```
public static float[] longToFloat(long[] values)
```
  - charToFloat
```
public static float[] charToFloat(char[] values)
```
  - doubleToFloat
```
public static float[] doubleToFloat(double[] values)
```
  - shortToFloat
```
public static float[] shortToFloat(short[] values)
```
  - booleanToFloat
```
public static float[] booleanToFloat(boolean[] values)
```
  - byteToFloat
```
public static float[] byteToFloat(byte[] values)
```
  - floatToInt
```
public static int[] floatToInt(float[] values)
```
  - longToInt
```
public static int[] longToInt(long[] values)
```
  - charToInt
```
public static int[] charToInt(char[] values)
```
  - doubleToInt
```
public static int[] doubleToInt(double[] values)
```
  - shortToInt
```
public static int[] shortToInt(short[] values)
```
  - booleanToInt
```
public static int[] booleanToInt(boolean[] values)
```
  - byteToInt
```
public static int[] byteToInt(byte[] values)
```
  - floatToLong
```
public static long[] floatToLong(float[] values)
```
  - intToLong
```
public static long[] intToLong(int[] values)
```
  - charToLong
```
public static long[] charToLong(char[] values)
```
  - doubleToLong
```
public static long[] doubleToLong(double[] values)
```
  - shortToLong
```
public static long[] shortToLong(short[] values)
```
  - booleanToLong
```
public static long[] booleanToLong(boolean[] values)
```
  - byteToLong
```
public static long[] byteToLong(byte[] values)
```
  - floatToShort
```
public static short[] floatToShort(float[] values)
```
  - intToShort
```
public static short[] intToShort(int[] values)
```
  - charToShort
```
public static short[] charToShort(char[] values)
```
  - doubleToShort
```
public static short[] doubleToShort(double[] values)
```
  - longToShort
```
public static short[] longToShort(long[] values)
```
  - booleanToShort
```
public static short[] booleanToShort(boolean[] values)
```
  - byteToShort
```
public static short[] byteToShort(byte[] values)
```
  - floatToString
```
public static String[] floatToString(float[] values)
```
  - intToString
```
public static String[] intToString(int[] values)
```
  - charToString
```
public static String[] charToString(char[] values)
```
  - doubleToString
```
public static String[] doubleToString(double[] values)
```
  - longToString
```
public static String[] longToString(long[] values)
```
  - booleanToString
```
public static String[] booleanToString(boolean[] values)
```
  - byteToString
```
public static String[] byteToString(byte[] values)
```
  - shortToString
```
public static String[] shortToString(short[] values)
```
  - create
```
public static <T> T[] create(int length,
                             Class<T> type)
```
  - subarray
```
public static <T> T[] subarray(T[] buffer,
                               int offset,
                               int length)
```
  - subarray
```
public static <T> T[] subarray(T[] buffer,
                               int offset,
                               int length,
                               Class<T> componentType)
```
  - subarray
```
public static String[] subarray(String[] buffer,
                                int offset,
                                int length)
```
  - subarray
```
public static byte[] subarray(byte[] buffer,
                              int offset,
                              int length)
```
  - subarray
```
public static char[] subarray(char[] buffer,
                              int offset,
                              int length)
```
  - subarray
```
public static short[] subarray(short[] buffer,
                               int offset,
                               int length)
```
  - subarray
```
public static int[] subarray(int[] buffer,
                             int offset,
                             int length)
```
  - subarray
```
public static long[] subarray(long[] buffer,
                              int offset,
                              int length)
```
  - subarray
```
public static float[] subarray(float[] buffer,
                               int offset,
                               int length)
```
  - subarray
```
public static double[] subarray(double[] buffer,
                                int offset,
                                int length)
```
  - subarray
```
public static boolean[] subarray(boolean[] buffer,
                                 int offset,
                                 int length)
```
  - remove
```
public static <T> T[] remove(T[] array,
                             int index)
```
  - removeElement
```
public static Object[] removeElement(Object[] array,
                                     Object element)
```
  - remove
```
public static boolean[] remove(boolean[] array,
                               int index)
```
  - removeElement
```
public static boolean[] removeElement(boolean[] array,
                                      boolean element)
```
  - remove
```
public static byte[] remove(byte[] array,
                            int index)
```
  - removeElement
```
public static byte[] removeElement(byte[] array,
                                   byte element)
```
  - remove
```
public static char[] remove(char[] array,
                            int index)
```
  - removeElement
```
public static char[] removeElement(char[] array,
                                   char element)
```
  - remove
```
public static double[] remove(double[] array,
                              int index)
```
  - removeElement
```
public static double[] removeElement(double[] array,
                                     double element)
```
  - remove
```
public static float[] remove(float[] array,
                             int index)
```
  - removeElement
```
public static float[] removeElement(float[] array,
                                    float element)
```
  - remove
```
public static int[] remove(int[] array,
                           int index)
```
  - removeElement
```
public static int[] removeElement(int[] array,
                                  int element)
```
  - remove
```
public static long[] remove(long[] array,
                            int index)
```
  - removeElement
```
public static long[] removeElement(long[] array,
                                   long element)
```
  - remove
```
public static short[] remove(short[] array,
                             int index)
```
  - removeElement
```
public static short[] removeElement(short[] array,
                                    short element)
```
  - remove
```
public static <T> T[] remove(T[] buffer,
                             int offset,
                             int length)
```
  - remove
```
public static <T> T[] remove(T[] buffer,
                             int offset,
                             int length,
                             Class<?> componentType)
```
  - remove
```
public static String[] remove(String[] buffer,
                              int offset,
                              int length)
```
  - remove
```
public static byte[] remove(byte[] buffer,
                            int offset,
                            int length)
```
  - remove
```
public static char[] remove(char[] buffer,
                            int offset,
                            int length)
```
  - remove
```
public static short[] remove(short[] buffer,
                             int offset,
                             int length)
```
  - remove
```
public static int[] remove(int[] buffer,
                           int offset,
                           int length)
```
  - remove
```
public static long[] remove(long[] buffer,
                            int offset,
                            int length)
```
  - remove
```
public static float[] remove(float[] buffer,
                             int offset,
                             int length)
```
  - remove
```
public static double[] remove(double[] buffer,
                              int offset,
                              int length)
```
  - remove
```
public static boolean[] remove(boolean[] buffer,
                               int offset,
                               int length)
```
  - getLength
```
public static int getLength(Object array)
```

类 ArrayKit

构造器概要

方法概要

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

构造器详细资料

ArrayKit

方法详细资料

length

isEmpty

isNotEmpty

defaultIfEmpty

arrayAsIterable

toMap

toMap

isSameLength

isSameLength

isSameLength

isSameLength

isSameLength

isSameLength

isSameLength

isSameLength

isSameLength

reverse

reverse

reverse

reverse

reverse

reverse

reverse

reverse

reverse

indexOf

indexOf

indexOf

indexOf

lastIndexOf

lastIndexOf

lastIndexOf

lastIndexOf

contains

contains

indexOf

indexOf

indexOf

indexOf

lastIndexOf

lastIndexOf

lastIndexOf

lastIndexOf

contains

contains

indexOf

indexOf

indexOf

indexOf

lastIndexOf

lastIndexOf

lastIndexOf

lastIndexOf

contains

contains

indexOf

indexOf

indexOf

indexOf

lastIndexOf

lastIndexOf

lastIndexOf

lastIndexOf

contains

contains

indexOf

indexOf

indexOf

indexOf

lastIndexOf

lastIndexOf

lastIndexOf

lastIndexOf