ArrayKit (bus-core 6.0.2 API)

java.lang.Object
- org.aoju.bus.core.toolkit.ArrayKit

```
public class ArrayKit
extends Object
```
数组工具类

Since:

JDK 1.8+

Version:

6.0.2

Author:

Kimi Liu

Constructor Summary

Constructors
Constructor and Description

ArrayKit()

Constructors
Constructor and Description
`ArrayKit()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static boolean[]`	`add(boolean[] array, boolean element)` 复制给定数组并在新数组的末尾添加给定元素.
`static boolean[]`	`add(boolean[] array, int index, boolean element)` 复制给定数组并在新数组的末尾添加给定元素.
`static byte[]`	`add(byte[] array, byte element)` 复制给定数组并在新数组的末尾添加给定元素.
`static byte[]`	`add(byte[] array, int index, byte element)` 复制给定数组并在新数组的末尾添加给定元素.
`static char[]`	`add(char[] array, char element)` 复制给定数组并在新数组的末尾添加给定元素.
`static char[]`	`add(char[] array, int index, char element)` 复制给定数组并在新数组的末尾添加给定元素.
`static double[]`	`add(double[] array, double element)` 复制给定数组并在新数组的末尾添加给定元素.
`static double[]`	`add(double[] array, int index, double element)` 复制给定数组并在新数组的末尾添加给定元素.
`static float[]`	`add(float[] array, float element)` 复制给定数组并在新数组的末尾添加给定元素.
`static float[]`	`add(float[] array, int index, float element)` 复制给定数组并在新数组的末尾添加给定元素.
`static int[]`	`add(int[] array, int element)` 复制给定数组并在新数组的末尾添加给定元素.
`static int[]`	`add(int[] array, int index, int element)` 复制给定数组并在新数组的末尾添加给定元素.
`static long[]`	`add(long[] array, int index, long element)` 复制给定数组并在新数组的末尾添加给定元素.
`static long[]`	`add(long[] array, long element)` 复制给定数组并在新数组的末尾添加给定元素.
`static short[]`	`add(short[] array, int index, short element)` 复制给定数组并在新数组的末尾添加给定元素.
`static short[]`	`add(short[] array, short element)` 复制给定数组并在新数组的末尾添加给定元素.
`static <T> T[]`	`add(T[] array, int index, T element)` 复制给定数组并在新数组的末尾添加给定元素.
`static <T> T[]`	`add(T[] array, T element)` 复制给定数组并在新数组的末尾添加给定元素.
`static boolean[]`	`addAll(boolean[]... arrays)` 将给定数组的所有元素添加到新数组中忽略null数组,新数组包含`arrays`的所有元素
`static byte[]`	`addAll(byte[]... arrays)` 将给定数组的所有元素添加到新数组中忽略null数组,新数组包含`arrays`的所有元素
`static char[]`	`addAll(char[]... arrays)` 将给定数组的所有元素添加到新数组中忽略null数组,新数组包含`arrays`的所有元素
`static double[]`	`addAll(double[]... arrays)` 将给定数组的所有元素添加到新数组中忽略null数组,新数组包含`arrays`的所有元素
`static float[]`	`addAll(float[]... arrays)` 将给定数组的所有元素添加到新数组中忽略null数组,新数组包含`arrays`的所有元素
`static int[]`	`addAll(int[]... arrays)` 将给定数组的所有元素添加到新数组中忽略null数组,新数组包含`arrays`的所有元素
`static long[]`	`addAll(long[]... arrays)` 将给定数组的所有元素添加到新数组中忽略null数组,新数组包含`arrays`的所有元素
`static short[]`	`addAll(short[]... arrays)` 将给定数组的所有元素添加到新数组中忽略null数组,新数组包含`arrays`的所有元素
`static <T> T[]`	`addAll(T[]... arrays)` 将给定数组的所有元素添加到新数组中忽略null数组,新数组包含`arrays`的所有元素
`static <T> Object`	`append(Object array, T... newElements)` 将新元素添加到已有数组中添加新元素会生成一个新的数组，不影响原数组
`static <T> T[]`	`append(T[] buffer, T... newElements)` 将新元素添加到已有数组中添加新元素会生成一个新的数组，不影响原数组
`static Object[]`	`cast(Class<?> type, Object arrayObj)` 强转数组类型强制转换的前提是数组元素类型可被强制转换强制转换后会生成一个新数组
`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 obj)` 克隆数组,如果非数组返回null
`static <T> T[]`	`clone(T[] array)` 克隆数组
`static boolean`	`contains(boolean[] array, boolean value)` 数组中是否包含元素
`static boolean`	`contains(byte[] array, byte value)` 数组中是否包含元素
`static boolean`	`contains(char[] array, char value)` 数组中是否包含元素
`static boolean`	`contains(double[] array, double value)` 数组中是否包含元素
`static boolean`	`contains(double[] array, double value, double tolerance)` 返回数组中指定元素所在位置,未找到返回`INDEX_NOT_FOUND`
`static boolean`	`contains(float[] array, float value)` 数组中是否包含元素
`static boolean`	`contains(int[] array, int value)` 数组中是否包含元素
`static boolean`	`contains(long[] array, long value)` 数组中是否包含元素
`static boolean`	`contains(Object[] array, Object value)` 数组中是否包含元素
`static boolean`	`contains(short[] array, short value)` 数组中是否包含元素
`static boolean`	`containsIgnoreCase(CharSequence[] array, CharSequence value)` 数组中是否包含元素,忽略大小写
`static Object`	`copy(Object src, int srcPos, Object dest, int destPos, int length)` 包装 `System.arraycopy(Object, int, Object, int, int)` 数组复制
`static Object`	`copy(Object src, Object dest, int length)` 包装 `System.arraycopy(Object, int, Object, int, int)` 数组复制,缘数组和目标数组都是从位置0开始复制
`static <T> T[]`	`filter(T[] array, Editor<T> editor)` 过滤过滤过程通过传入的Editor实现来返回需要的元素内容,这个Editor实现可以实现以下功能：
`static <T> T[]`	`filter(T[] array, Filter<T> filter)` 过滤过滤过程通过传入的Filter实现来过滤返回需要的元素内容,这个Editor实现可以实现以下功能：
`static <T> T`	`firstNonNull(T... array)` 返回数组中第一个非空元素
`static Optional<Object>`	`firstNotNull(Object[] objects)` 找到第一个不为 null 的元素
`static <T> T[]`	`get(Object array, int... indexes)` 获取数组中指定多个下标元素值,组成新数组
`static <T> T`	`get(Object array, int index)` 获取数组对象中指定index的值,支持负数,例如-1表示倒数第一个值
`static Class<?>`	`getArrayType(Class<?> componentType)` 根据数组元素类型,获取数组的类型方法是通过创建一个空数组从而获取其类型
`static Class<?>`	`getComponentType(Class<?> arrayClass)` 获取数组对象的元素类型
`static Class<?>`	`getComponentType(Object array)` 获取数组对象的元素类型
`static int`	`getLength(Object array)` 返回指定数组的长度
`static boolean`	`hasEmpty(Object... args)` 是否存在`null`或空对象，通过`ObjectKit.isEmpty(Object)` 判断元素
`static int`	`hashCode(Object array)` 获得一个数组哈希码,用于正确处理多维数组多维基元数组也可以用该方法正确处理
`static <T> boolean`	`hasNull(T... array)` 是否包含`null`元素
`static int`	`indexOf(boolean[] array, boolean value)` 返回数组中指定元素所在位置,未找到返回`INDEX_NOT_FOUND`
`static int`	`indexOf(boolean[] array, boolean value, int index)` 返回数组中指定元素所在位置,未找到返回`INDEX_NOT_FOUND`
`static int`	`indexOf(byte[] array, byte value)` 返回数组中指定元素所在位置,未找到返回`INDEX_NOT_FOUND`
`static int`	`indexOf(byte[] array, byte value, int index)` 返回数组中指定元素所在位置,未找到返回`INDEX_NOT_FOUND`
`static int`	`indexOf(char[] array, char value)` 返回数组中指定元素所在位置,未找到返回`INDEX_NOT_FOUND`
`static int`	`indexOf(char[] array, char value, int index)` 返回数组中指定元素所在位置,未找到返回`INDEX_NOT_FOUND`
`static int`	`indexOf(double[] array, double value)` 返回数组中指定元素所在位置,未找到返回`INDEX_NOT_FOUND`
`static int`	`indexOf(double[] array, double value, double tolerance)` 返回数组中指定元素所在位置,未找到返回`INDEX_NOT_FOUND`
`static int`	`indexOf(double[] array, double value, int index)` 返回数组中指定元素所在位置,未找到返回`INDEX_NOT_FOUND`
`static int`	`indexOf(double[] array, double value, int index, double tolerance)` 返回数组中指定元素所在位置,未找到返回`INDEX_NOT_FOUND`
`static int`	`indexOf(float[] array, float value)` 返回数组中指定元素所在位置,未找到返回`INDEX_NOT_FOUND`
`static int`	`indexOf(float[] array, float value, int index)` 返回数组中指定元素所在位置,未找到返回`INDEX_NOT_FOUND`
`static int`	`indexOf(int[] array, int value)` 返回数组中指定元素所在位置,未找到返回`INDEX_NOT_FOUND`
`static int`	`indexOf(int[] array, int value, int index)` 返回数组中指定元素所在位置,未找到返回`INDEX_NOT_FOUND`
`static int`	`indexOf(long[] array, long value)` 返回数组中指定元素所在位置,未找到返回`INDEX_NOT_FOUND`
`static int`	`indexOf(long[] array, long value, int index)` 返回数组中指定元素所在位置,未找到返回`INDEX_NOT_FOUND`
`static int`	`indexOf(Object[] array, Object value)` 返回数组中指定元素所在位置,未找到返回`INDEX_NOT_FOUND`
`static int`	`indexOf(Object[] array, Object value, int index)` 返回数组中指定元素所在位置,未找到返回`INDEX_NOT_FOUND`
`static int`	`indexOf(short[] array, short value)` 返回数组中指定元素所在位置,未找到返回`INDEX_NOT_FOUND`
`static int`	`indexOf(short[] array, short value, int index)` 返回数组中指定元素所在位置,未找到返回`INDEX_NOT_FOUND`
`static int`	`indexOfIgnoreCase(CharSequence[] array, CharSequence value)` 返回数组中指定元素所在位置,忽略大小写,未找到返回`INDEX_NOT_FOUND`
`static boolean[]`	`insert(int index, boolean[] array, boolean... values)` 将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时，它总是一个新的数组
`static byte[]`	`insert(int index, byte[] array, byte... values)` 将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时，它总是一个新的数组
`static char[]`	`insert(int index, char[] array, char... values)` 将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时，它总是一个新的数组
`static double[]`	`insert(int index, double[] array, double... values)` 将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时，它总是一个新的数组
`static float[]`	`insert(int index, float[] array, float... values)` 将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时，它总是一个新的数组
`static int[]`	`insert(int index, int[] array, int... values)` 将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时，它总是一个新的数组
`static long[]`	`insert(int index, long[] array, long... values)` 将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时，它总是一个新的数组
`static short[]`	`insert(int index, short[] array, short... values)` 将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时，它总是一个新的数组
`static <T> T[]`	`insert(int index, T[] array, T... values)` 将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时，它总是一个新的数组
`static <T> Object`	`insert(Object array, int index, T... newElements)` 将新元素插入到到已有数组中的某个位置添加新元素会生成一个新的数组，不影响原数组如果插入位置为为负数，从原数组从后向前计数，若大于原数组长度，则空白处用null填充
`static <T> T[]`	`insert(T[] buffer, int index, T... newElements)` 将新元素插入到到已有数组中的某个位置添加新元素会生成一个新的数组，不影响原数组如果插入位置为为负数，从原数组从后向前计数，若大于原数组长度，则空白处用null填充
`static boolean`	`isAllEmpty(Object... args)` 是否存都为`null`或空对象，通过`ObjectKit.isEmpty(Object)` 判断元素
`static boolean`	`isAllNotEmpty(Object... args)` 是否存都不为`null`或空对象，通过`ObjectKit.isEmpty(Object)` 判断元素
`static boolean`	`isArray(Object obj)` 对象是否为数组对象
`static <T> boolean`	`isArrayIndexValid(T[] array, int index)` 返回是否可以在给定索引处安全地访问给定数组
`static boolean`	`isEmpty(boolean[] array)` 数组是否为空
`static boolean`	`isEmpty(byte[] array)` 数组是否为空
`static boolean`	`isEmpty(char[] array)` 数组是否为空
`static boolean`	`isEmpty(double[] array)` 数组是否为空
`static boolean`	`isEmpty(float[] array)` 数组是否为空
`static boolean`	`isEmpty(int[] array)` 数组是否为空
`static boolean`	`isEmpty(long[] array)` 数组是否为空
`static boolean`	`isEmpty(Object array)` 数组是否为空此方法会匹配单一对象,如果此对象为`null`则返回true 如果此对象为非数组,理解为此对象为数组的第一个元素,则返回false 如果此对象为数组对象,数组长度大于0情况下返回false,否则返回true
`static boolean`	`isEmpty(short[] array)` 数组是否为空
`static <T> boolean`	`isEmpty(T[] array)` 数组是否为空
`static boolean`	`isNotEmpty(boolean[] array)` 数组是否为非空
`static boolean`	`isNotEmpty(byte[] array)` 数组是否为非空
`static boolean`	`isNotEmpty(char[] array)` 数组是否为非空
`static boolean`	`isNotEmpty(double[] array)` 数组是否为非空
`static boolean`	`isNotEmpty(float[] array)` 数组是否为非空
`static boolean`	`isNotEmpty(int[] array)` 数组是否为非空
`static boolean`	`isNotEmpty(long[] array)` 数组是否为非空
`static boolean`	`isNotEmpty(short[] array)` 数组是否为非空
`static <T> boolean`	`isNotEmpty(T[] array)` 数组是否为非空此方法会匹配单一对象,如果此对象为`null`则返回false 如果此对象为非数组,理解为此对象为数组的第一个元素,则返回true 如果此对象为数组对象,数组长度大于0情况下返回true,否则返回false
`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 boolean`	`isSameType(Object array1, Object array2)` 检查两个数组是否为同一类型
`static boolean`	`isSorted(boolean[] array)` 该方法检查提供的数组是否按照提供的`Comparator`排序.
`static boolean`	`isSorted(byte[] array)` 该方法检查提供的数组是否按照提供的`Comparator`排序.
`static boolean`	`isSorted(char[] array)` 该方法检查提供的数组是否按照提供的`Comparator`排序.
`static boolean`	`isSorted(double[] array)` 该方法检查提供的数组是否按照提供的`Comparator`排序.
`static boolean`	`isSorted(float[] array)` 该方法检查提供的数组是否按照提供的`Comparator`排序.
`static boolean`	`isSorted(int[] array)` 该方法检查提供的数组是否按照提供的`Comparator`排序.
`static boolean`	`isSorted(long[] array)` 该方法检查提供的数组是否按照提供的`Comparator`排序.
`static boolean`	`isSorted(short[] array)` 该方法检查提供的数组是否按照提供的`Comparator`排序.
`static <T extends Comparable<? super T>> boolean`	`isSorted(T[] array)` 该方法检查提供的数组是否按照类的`compareTo`方法排序.
`static <T> boolean`	`isSorted(T[] array, Comparator<T> comparator)` 该方法检查提供的数组是否按照提供的`Comparator`排序.
`static String`	`join(boolean[] array, CharSequence conjunction)` 以 conjunction 为分隔符将数组转换为字符串
`static String`	`join(byte[] array, CharSequence conjunction)` 以 conjunction 为分隔符将数组转换为字符串
`static String`	`join(char[] array, CharSequence conjunction)` 以 conjunction 为分隔符将数组转换为字符串
`static String`	`join(double[] array, CharSequence conjunction)` 以 conjunction 为分隔符将数组转换为字符串
`static String`	`join(float[] array, CharSequence conjunction)` 以 conjunction 为分隔符将数组转换为字符串
`static String`	`join(int[] array, CharSequence conjunction)` 以 conjunction 为分隔符将数组转换为字符串
`static String`	`join(long[] array, CharSequence conjunction)` 以 conjunction 为分隔符将数组转换为字符串
`static String`	`join(Object array, CharSequence conjunction)` 以 conjunction 为分隔符将数组转换为字符串
`static String`	`join(short[] array, CharSequence conjunction)` 以 conjunction 为分隔符将数组转换为字符串
`static <T> String`	`join(T[] array, CharSequence conjunction)` 以 conjunction 为分隔符将数组转换为字符串
`static <T> String`	`join(T[] array, CharSequence conjunction, Editor<T> editor)` 以 conjunction 为分隔符将数组转换为字符串
`static <T> String`	`join(T[] array, CharSequence conjunction, String prefix, String suffix)` 以 conjunction 为分隔符将数组转换为字符串
`static int`	`lastIndexOf(boolean[] array, boolean value)` 返回数组中指定元素所在最后的位置,未找到返回`INDEX_NOT_FOUND`
`static int`	`lastIndexOf(boolean[] array, boolean value, int index)` 返回数组中指定元素所在最后的位置,未找到返回`INDEX_NOT_FOUND`
`static int`	`lastIndexOf(byte[] array, byte value)` 返回数组中指定元素所在最后的位置,未找到返回`INDEX_NOT_FOUND`
`static int`	`lastIndexOf(byte[] array, byte value, int index)` 返回数组中指定元素所在最后的位置,未找到返回`INDEX_NOT_FOUND`
`static int`	`lastIndexOf(char[] array, char value)` 返回数组中指定元素所在最后的位置,未找到返回`INDEX_NOT_FOUND`
`static int`	`lastIndexOf(char[] array, char value, int index)` 返回数组中指定元素所在最后的位置,未找到返回`INDEX_NOT_FOUND`
`static int`	`lastIndexOf(double[] array, double value)` 返回数组中指定元素所在最后的位置,未找到返回`INDEX_NOT_FOUND`
`static int`	`lastIndexOf(double[] array, double value, double tolerance)` 返回数组中指定元素所在最后的位置,未找到返回`INDEX_NOT_FOUND`
`static int`	`lastIndexOf(double[] array, double value, int index)` 返回数组中指定元素所在最后的位置,未找到返回`INDEX_NOT_FOUND`
`static int`	`lastIndexOf(double[] array, double value, int index, double tolerance)` 返回数组中指定元素所在最后的位置,未找到返回`INDEX_NOT_FOUND`
`static int`	`lastIndexOf(float[] array, float value)` 返回数组中指定元素所在最后的位置,未找到返回`INDEX_NOT_FOUND`
`static int`	`lastIndexOf(float[] array, float value, int index)` 返回数组中指定元素所在最后的位置,未找到返回`INDEX_NOT_FOUND`
`static int`	`lastIndexOf(int[] array, int value)` 返回数组中指定元素所在最后的位置,未找到返回`INDEX_NOT_FOUND`
`static int`	`lastIndexOf(int[] array, int value, int index)` 返回数组中指定元素所在最后的位置,未找到返回`INDEX_NOT_FOUND`
`static int`	`lastIndexOf(long[] array, long value)` 返回数组中指定元素所在最后的位置,未找到返回`INDEX_NOT_FOUND`
`static int`	`lastIndexOf(long[] array, long value, int index)` 返回数组中指定元素所在最后的位置,未找到返回`INDEX_NOT_FOUND`
`static int`	`lastIndexOf(Object[] array, Object value)` 返回数组中指定元素所在最后的位置,未找到返回`INDEX_NOT_FOUND`
`static int`	`lastIndexOf(Object[] array, Object value, int index)` 返回数组中指定元素所在最后的位置,未找到返回`INDEX_NOT_FOUND`
`static int`	`lastIndexOf(short[] array, short value)` 返回数组中指定元素所在最后的位置,未找到返回`INDEX_NOT_FOUND`
`static int`	`lastIndexOf(short[] array, short value, int index)` 返回数组中指定元素所在最后的位置,未找到返回`INDEX_NOT_FOUND`
`static byte`	`max(byte... numberArray)` 取最大值
`static char`	`max(char... numberArray)` 取最大值
`static double`	`max(double... numberArray)` 取最大值
`static float`	`max(float... numberArray)` 取最大值
`static int`	`max(int... numberArray)` 取最大值
`static long`	`max(long... numberArray)` 取最大值
`static short`	`max(short... numberArray)` 取最大值
`static <T extends Comparable<? super T>> T`	`max(T[] numberArray)` 取最大值
`static <T extends Comparable<? super T>> T`	`max(T[] numberArray, Comparator<T> comparator)` 取最大值
`static byte`	`min(byte... numberArray)` 取最小值
`static char`	`min(char... numberArray)` 取最小值
`static double`	`min(double... numberArray)` 取最小值
`static float`	`min(float... numberArray)` 取最小值
`static int`	`min(int... numberArray)` 取最小值
`static long`	`min(long... numberArray)` 取最小值
`static short`	`min(short... numberArray)` 取最小值
`static <T extends Comparable<? super T>> T`	`min(T[] numberArray)` 取最小值
`static <T> T[]`	`newArray(Class<?> componentType, int newSize)` 新建一个空数组
`static Object[]`	`newArray(Class<?> type, Object arrayObj)` 强转数组类型强制转换的前提是数组元素类型可被强制转换强制转换后会生成一个新数组
`static <T> T[]`	`newArray(int newSize)` 新建一个空数组
`static boolean[]`	`nullToEmpty(boolean[] array)` 输入数组返回一个空数组或原始数组
`static Boolean[]`	`nullToEmpty(Boolean[] array)` 输入数组返回一个空数组或原始数组
`static byte[]`	`nullToEmpty(byte[] array)` 输入数组返回一个空数组或原始数组
`static Byte[]`	`nullToEmpty(Byte[] array)` 输入数组返回一个空数组或原始数组
`static char[]`	`nullToEmpty(char[] array)` 输入数组返回一个空数组或原始数组
`static Character[]`	`nullToEmpty(Character[] array)` 输入数组返回一个空数组或原始数组
`static Class<?>[]`	`nullToEmpty(Class<?>[] array)` 输入数组返回一个空数组或原始数组
`static double[]`	`nullToEmpty(double[] array)` 输入数组返回一个空数组或原始数组
`static Double[]`	`nullToEmpty(Double[] array)` 输入数组返回一个空数组或原始数组
`static float[]`	`nullToEmpty(float[] array)` 输入数组返回一个空数组或原始数组
`static Float[]`	`nullToEmpty(Float[] array)` 输入数组返回一个空数组或原始数组
`static int[]`	`nullToEmpty(int[] array)` 输入数组返回一个空数组或原始数组
`static Integer[]`	`nullToEmpty(Integer[] array)` 输入数组返回一个空数组或原始数组
`static long[]`	`nullToEmpty(long[] array)` 输入数组返回一个空数组或原始数组
`static Long[]`	`nullToEmpty(Long[] array)` 输入数组返回一个空数组或原始数组
`static Object[]`	`nullToEmpty(Object[] array)` 输入数组返回一个空数组或原始数组
`static short[]`	`nullToEmpty(short[] array)` 输入数组返回一个空数组或原始数组
`static Short[]`	`nullToEmpty(Short[] array)` 输入数组返回一个空数组或原始数组
`static String[]`	`nullToEmpty(String[] array)` 输入数组返回一个空数组或原始数组
`static <T> T[]`	`nullToEmpty(T[] array, Class<T[]> type)` 输入数组返回一个空数组或原始数组
`static int[]`	`range(int excludedEnd)` 生成一个从0开始的数字列表
`static int[]`	`range(int includedStart, int excludedEnd)` 生成一个数字列表自动判定正序反序
`static int[]`	`range(int includedStart, int excludedEnd, int step)` 生成一个数字列表自动判定正序反序
`static boolean[]`	`remove(boolean[] array, int index)` 从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素如果是`null`，则会抛出IndexOutOfBoundsException，无法指定有效的索引
`static byte[]`	`remove(byte[] array, int index)` 从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素如果是`null`，则会抛出IndexOutOfBoundsException，无法指定有效的索引
`static char[]`	`remove(char[] array, int index)` 从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素如果是`null`，则会抛出IndexOutOfBoundsException，无法指定有效的索引
`static double[]`	`remove(double[] array, int index)` 从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素如果是`null`，则会抛出IndexOutOfBoundsException，无法指定有效的索引
`static float[]`	`remove(float[] array, int index)` 从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素如果是`null`，则会抛出IndexOutOfBoundsException，无法指定有效的索引
`static int[]`	`remove(int[] array, int index)` 从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素如果是`null`，则会抛出IndexOutOfBoundsException，无法指定有效的索引
`static long[]`	`remove(long[] array, int index)` 从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素如果是`null`，则会抛出IndexOutOfBoundsException，无法指定有效的索引
`static short[]`	`remove(short[] array, int index)` 从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素如果是`null`，则会抛出IndexOutOfBoundsException，无法指定有效的索引
`static <T> T[]`	`remove(T[] array)` 去重数组中的元素，去重后生成新的数组，原数组不变此方法通过`LinkedHashSet` 去重
`static <T> T[]`	`remove(T[] array, int index)` 从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素如果是`null`，则会抛出IndexOutOfBoundsException，无法指定有效的索引
`static boolean[]`	`removeAll(boolean[] array, int... indices)` 从指定数组中移除指定位置的元素。所有剩余的元素都向左移动返回数组的组件类型始终与输入数组的组件类型相同此方法返回一个新数组，该数组具有与输入数组相同的元素
`static byte[]`	`removeAll(byte[] array, int... indices)` 从指定数组中移除指定位置的元素。所有剩余的元素都向左移动返回数组的组件类型始终与输入数组的组件类型相同此方法返回一个新数组，该数组具有与输入数组相同的元素
`static char[]`	`removeAll(char[] array, int... indices)` 从指定数组中移除指定位置的元素。所有剩余的元素都向左移动返回数组的组件类型始终与输入数组的组件类型相同此方法返回一个新数组，该数组具有与输入数组相同的元素
`static double[]`	`removeAll(double[] array, int... indices)` 从指定数组中移除指定位置的元素。所有剩余的元素都向左移动返回数组的组件类型始终与输入数组的组件类型相同此方法返回一个新数组，该数组具有与输入数组相同的元素
`static float[]`	`removeAll(float[] array, int... indices)` 从指定数组中移除指定位置的元素。所有剩余的元素都向左移动返回数组的组件类型始终与输入数组的组件类型相同此方法返回一个新数组，该数组具有与输入数组相同的元素
`static int[]`	`removeAll(int[] array, int... indices)` 从指定数组中移除指定位置的元素。所有剩余的元素都向左移动返回数组的组件类型始终与输入数组的组件类型相同此方法返回一个新数组，该数组具有与输入数组相同的元素
`static long[]`	`removeAll(long[] array, int... indices)` 从指定数组中移除指定位置的元素。所有剩余的元素都向左移动返回数组的组件类型始终与输入数组的组件类型相同此方法返回一个新数组，该数组具有与输入数组相同的元素
`static short[]`	`removeAll(short[] array, int... indices)` 从指定数组中移除指定位置的元素。所有剩余的元素都向左移动返回数组的组件类型始终与输入数组的组件类型相同此方法返回一个新数组，该数组具有与输入数组相同的元素
`static <T> T[]`	`removeAll(T[] array, int... indices)` 从指定数组中移除指定位置的元素。所有剩余的元素都向左移动返回数组的组件类型始终与输入数组的组件类型相同此方法返回一个新数组，该数组具有与输入数组相同的元素
`static boolean[]`	`removeAllOccurences(boolean[] array, boolean element)` 从指定的布尔数组中移除指定元素.
`static byte[]`	`removeAllOccurences(byte[] array, byte element)` 从指定的布尔数组中移除指定元素.
`static char[]`	`removeAllOccurences(char[] array, char element)` 从指定的布尔数组中移除指定元素.
`static double[]`	`removeAllOccurences(double[] array, double element)` 从指定的布尔数组中移除指定元素.
`static float[]`	`removeAllOccurences(float[] array, float element)` 从指定的布尔数组中移除指定元素.
`static int[]`	`removeAllOccurences(int[] array, int element)` 从指定的布尔数组中移除指定元素.
`static long[]`	`removeAllOccurences(long[] array, long element)` 从指定的布尔数组中移除指定元素.
`static short[]`	`removeAllOccurences(short[] array, short element)` 从指定的布尔数组中移除指定元素.
`static <T> T[]`	`removeAllOccurences(T[] array, T element)` 从指定的布尔数组中移除指定元素.
`static boolean[]`	`removeElement(boolean[] array, boolean element)` 从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素如果是`null`，则会抛出IndexOutOfBoundsException，无法指定有效的索引
`static byte[]`	`removeElement(byte[] array, byte element)` 从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素如果是`null`，则会抛出IndexOutOfBoundsException，无法指定有效的索引
`static char[]`	`removeElement(char[] array, char element)` 从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素如果是`null`，则会抛出IndexOutOfBoundsException，无法指定有效的索引
`static double[]`	`removeElement(double[] array, double element)` 从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素如果是`null`，则会抛出IndexOutOfBoundsException，无法指定有效的索引
`static float[]`	`removeElement(float[] array, float element)` 从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素如果是`null`，则会抛出IndexOutOfBoundsException，无法指定有效的索引
`static int[]`	`removeElement(int[] array, int element)` 从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素如果是`null`，则会抛出IndexOutOfBoundsException，无法指定有效的索引
`static long[]`	`removeElement(long[] array, long element)` 从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素如果是`null`，则会抛出IndexOutOfBoundsException，无法指定有效的索引
`static short[]`	`removeElement(short[] array, short element)` 从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素如果是`null`，则会抛出IndexOutOfBoundsException，无法指定有效的索引
`static <T> T[]`	`removeElement(T[] array, Object element)` 从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素如果是`null`，则会抛出IndexOutOfBoundsException，无法指定有效的索引
`static boolean[]`	`removeElements(boolean[] array, boolean... values)` 从指定数组中移除指定数量*的指定元素。所有后续元素都左移对于指定的要删除的元素，其数量大于原始数组中包含的数量，除了删除现有的匹配项外，不会发生任何更改.
`static byte[]`	`removeElements(byte[] array, byte... values)` 从指定数组中移除指定数量*的指定元素。所有后续元素都左移对于指定的要删除的元素，其数量大于原始数组中包含的数量，除了删除现有的匹配项外，不会发生任何更改返回数组的组件类型始终与输入数组的组件类型相同.
`static char[]`	`removeElements(char[] array, char... values)` 从指定数组中移除指定数量*的指定元素。所有后续元素都左移对于指定的要删除的元素，其数量大于原始数组中包含的数量，除了删除现有的匹配项外，不会发生任何更改.
`static double[]`	`removeElements(double[] array, double... values)` 从指定数组中移除指定数量*的指定元素。所有后续元素都左移对于指定的要删除的元素，其数量大于原始数组中包含的数量，除了删除现有的匹配项外，不会发生任何更改.
`static float[]`	`removeElements(float[] array, float... values)` 从指定数组中移除指定数量*的指定元素。所有后续元素都左移对于指定的要删除的元素，其数量大于原始数组中包含的数量，除了删除现有的匹配项外，不会发生任何更改返回数组的组件类型始终与输入数组的组件类型相同
`static int[]`	`removeElements(int[] array, int... values)` 从指定数组中移除指定数量*的指定元素。所有后续元素都左移.
`static long[]`	`removeElements(long[] array, long... values)` 从指定数组中移除指定数量*的指定元素。所有后续元素都左移对于指定的要删除的元素，其数量大于原始数组中包含的数量，除了删除现有的匹配项外，不会发生任何更改返回数组的组件类型始终与输入数组的组件类型相同
`static short[]`	`removeElements(short[] array, short... values)` 从指定数组中移除指定数量*的指定元素。所有后续元素都左移对于指定的要删除的元素，其数量大于原始数组中包含的数量，除了删除现有的匹配项外，不会发生任何更改.
`static <T> T[]`	`removeElements(T[] array, T... values)` 从指定数组中移除指定数量*的指定元素。所有后续元素都左移对于指定的要删除的元素，其数量大于原始数组中包含的数量，除了删除现有的匹配项外，不会发生任何更改返回数组的组件类型始终与输入数组的组件类型相同.
`static byte[]`	`resize(byte[] bytes, int newSize)` 生成一个新的重新设置大小的数组调整大小后拷贝原数组到新数组下扩大则占位前N个位置,其它位置补充0,缩小则截断
`static <T> T[]`	`resize(T[] buffer, int newSize)` 生成一个新的重新设置大小的数组新数组的类型为原数组的类型,调整大小后拷贝原数组到新数组下扩大则占位前N个位置,缩小则截断
`static <T> T[]`	`resize(T[] buffer, int newSize, Class<?> componentType)` 生成一个新的重新设置大小的数组调整大小后拷贝原数组到新数组下扩大则占位前N个位置,缩小则截断
`static void`	`reverse(boolean[] array)` 反转数组,会变更原数组
`static void`	`reverse(boolean[] array, int startIndex, int endIndex)`
`static void`	`reverse(byte[] array)` 反转数组,会变更原数组
`static void`	`reverse(byte[] array, int startIndex, int endIndex)` 反转数组,会变更原数组
`static void`	`reverse(char[] array)` 反转数组,会变更原数组
`static void`	`reverse(char[] array, int startIndex, int endIndex)` 反转数组,会变更原数组
`static void`	`reverse(double[] array)` 反转数组,会变更原数组
`static void`	`reverse(double[] array, int startIndex, int endIndex)` 反转数组,会变更原数组
`static void`	`reverse(float[] array)` 反转数组,会变更原数组
`static void`	`reverse(float[] array, int startIndex, int endIndex)` 反转数组,会变更原数组
`static void`	`reverse(int[] array)` 反转数组,会变更原数组
`static void`	`reverse(int[] array, int startIndex, int endIndex)` 反转数组,会变更原数组
`static void`	`reverse(long[] array)` 反转数组,会变更原数组
`static void`	`reverse(long[] array, int startIndex, int endIndex)` 反转数组,会变更原数组
`static void`	`reverse(Object[] array)` 反转数组,会变更原数组
`static void`	`reverse(Object[] array, int startIndex, int endIndex)` 反转数组,会变更原数组
`static void`	`reverse(short[] array)` 反转数组,会变更原数组
`static void`	`reverse(short[] array, int startIndex, int endIndex)` 反转数组,会变更原数组
`static Object`	`setOrAppend(Object array, int index, Object value)` 将元素值设置为数组的某个位置,当给定的index大于数组长度,则追加
`static <T> T[]`	`setOrAppend(T[] buffer, int index, T value)` 将元素值设置为数组的某个位置,当给定的index大于数组长度,则追加
`static void`	`shift(boolean[] array, int offset)` 改变数组的顺序
`static void`	`shift(boolean[] array, int startIndex, int endIndex, int offset)` 改变数组的顺序
`static void`	`shift(byte[] array, int offset)` 改变数组的顺序
`static void`	`shift(byte[] array, int startIndex, int endIndex, int offset)` 改变数组的顺序
`static void`	`shift(char[] array, int offset)` 改变数组的顺序
`static void`	`shift(char[] array, int startIndex, int endIndex, int offset)` 改变数组的顺序
`static void`	`shift(double[] array, int offset)` 改变数组的顺序
`static void`	`shift(double[] array, int startIndex, int endIndex, int offset)` 改变数组的顺序
`static void`	`shift(float[] array, int offset)` 改变数组的顺序
`static void`	`shift(float[] array, int startIndex, int endIndex, int offset)` 改变数组的顺序
`static void`	`shift(int[] array, int offset)` 移位给定int数组的顺序
`static void`	`shift(int[] array, int startIndex, int endIndex, int offset)` 改变数组的顺序
`static void`	`shift(long[] array, int offset)` 移位给定长数组的顺序
`static void`	`shift(long[] array, int startIndex, int endIndex, int offset)` 改变数组的顺序
`static void`	`shift(Object[] array, int offset)` 移位给定数组的顺序
`static void`	`shift(Object[] array, int startIndex, int endIndex, int offset)` 改变数组的顺序
`static void`	`shift(short[] array, int offset)` 改变数组的顺序
`static void`	`shift(short[] array, int startIndex, int endIndex, int offset)` 改变数组的顺序
`static void`	`shuffle(boolean[] array)` 使用Fisher-Yates算法随机遍历指定数组的元素.
`static void`	`shuffle(boolean[] array, Random random)` 使用Fisher-Yates算法随机遍历指定数组的元素.
`static void`	`shuffle(byte[] array)` 使用Fisher-Yates算法随机遍历指定数组的元素.
`static void`	`shuffle(byte[] array, Random random)` 使用Fisher-Yates算法随机遍历指定数组的元素.
`static void`	`shuffle(char[] array)` 使用Fisher-Yates算法随机遍历指定数组的元素.
`static void`	`shuffle(char[] array, Random random)` 使用Fisher-Yates算法随机遍历指定数组的元素.
`static void`	`shuffle(double[] array)` 使用Fisher-Yates算法随机遍历指定数组的元素.
`static void`	`shuffle(double[] array, Random random)` 使用Fisher-Yates算法随机遍历指定数组的元素.
`static void`	`shuffle(float[] array)` 使用Fisher-Yates算法随机遍历指定数组的元素.
`static void`	`shuffle(float[] array, Random random)` 使用Fisher-Yates算法随机遍历指定数组的元素.
`static void`	`shuffle(int[] array)` 使用Fisher-Yates算法随机遍历指定数组的元素.
`static void`	`shuffle(int[] array, Random random)` 使用Fisher-Yates算法随机遍历指定数组的元素.
`static void`	`shuffle(long[] array)` 使用Fisher-Yates算法随机遍历指定数组的元素.
`static void`	`shuffle(long[] array, Random random)` 使用Fisher-Yates算法随机遍历指定数组的元素.
`static void`	`shuffle(Object[] array)` 使用Fisher-Yates算法随机遍历指定数组的元素.
`static void`	`shuffle(Object[] array, Random random)` 使用Fisher-Yates算法随机遍历指定数组的元素.
`static void`	`shuffle(short[] array)` 使用Fisher-Yates算法随机遍历指定数组的元素.
`static void`	`shuffle(short[] array, Random random)` 使用Fisher-Yates算法随机遍历指定数组的元素.
`static boolean[]`	`sub(boolean[] array, int start, int end)` 获取子数组
`static byte[]`	`sub(byte[] array, int start, int end)` 获取子数组
`static char[]`	`sub(char[] array, int start, int end)` 获取子数组
`static double[]`	`sub(double[] array, int start, int end)` 获取子数组
`static float[]`	`sub(float[] array, int start, int end)` 获取子数组
`static int[]`	`sub(int[] array, int start, int end)` 获取子数组
`static long[]`	`sub(long[] array, int start, int end)` 获取子数组
`static Object[]`	`sub(Object array, int start, int end)` 获取子数组
`static Object[]`	`sub(Object array, int start, int end, int step)` 获取子数组
`static short[]`	`sub(short[] array, int start, int end)` 获取子数组
`static <T> T[]`	`sub(T[] array, int start, int end)` 获取子数组
`static boolean[]`	`subarray(boolean[] array, int startIndex, int endIndex)` 生成一个新的数组,其中包含元素开始索引取值至结束位置索引开始索引包含,结束索引不包含,空数组输入产生空输出
`static byte[]`	`subarray(byte[] array, int startIndex, int endIndex)` 生成一个新的数组,其中包含元素开始索引取值至结束位置索引开始索引包含,结束索引不包含,空数组输入产生空输出
`static char[]`	`subarray(char[] array, int startIndex, int endIndex)` 生成一个新的数组,其中包含元素开始索引取值至结束位置索引开始索引包含,结束索引不包含,空数组输入产生空输出
`static double[]`	`subarray(double[] array, int startIndex, int endIndex)` 生成一个新的数组,其中包含元素开始索引取值至结束位置索引开始索引包含,结束索引不包含,空数组输入产生空输出
`static float[]`	`subarray(float[] array, int startIndex, int endIndex)` 生成一个新的数组,其中包含元素开始索引取值至结束位置索引开始索引包含,结束索引不包含,空数组输入产生空输出
`static int[]`	`subarray(int[] array, int startIndex, int endIndex)` 生成一个新的数组,其中包含元素开始索引取值至结束位置索引开始索引包含,结束索引不包含,空数组输入产生空输出
`static long[]`	`subarray(long[] array, int startIndex, int endIndex)` 生成一个新的数组,其中包含元素开始索引取值至结束位置索引开始索引包含,结束索引不包含,空数组输入产生空输出
`static short[]`	`subarray(short[] array, int startIndex, int endIndex)` 生成一个新的数组,其中包含元素开始索引取值至结束位置索引开始索引包含,结束索引不包含,空数组输入产生空输出
`static <T> T[]`	`subarray(T[] array, int startIndex, int endIndex)` 生成一个新的数组,其中包含元素开始索引取值至结束位置索引开始索引包含,结束索引不包含,空数组输入产生空输出
`static void`	`swap(boolean[] array, int offset1, int offset2)` 交换数组中连个位置的值
`static void`	`swap(boolean[] array, int offset1, int offset2, int len)` 交换数组中连个位置的值
`static void`	`swap(byte[] array, int offset1, int offset2)` 交换数组中连个位置的值
`static void`	`swap(byte[] array, int offset1, int offset2, int len)` 交换数组中连个位置的值
`static void`	`swap(char[] array, int offset1, int offset2)` 交换数组中连个位置的值
`static void`	`swap(char[] array, int offset1, int offset2, int len)` 交换数组中连个位置的值
`static void`	`swap(double[] array, int offset1, int offset2)` 交换数组中连个位置的值
`static void`	`swap(double[] array, int offset1, int offset2, int len)` 交换数组中连个位置的值
`static void`	`swap(float[] array, int offset1, int offset2)` 交换数组中连个位置的值
`static void`	`swap(float[] array, int offset1, int offset2, int len)` 交换数组中连个位置的值
`static void`	`swap(int[] array, int offset1, int offset2)` 交换数组中连个位置的值
`static void`	`swap(int[] array, int offset1, int offset2, int len)` 交换数组中连个位置的值
`static void`	`swap(long[] array, int offset1, int offset2)` 交换数组中连个位置的值
`static void`	`swap(long[] array, int offset1, int offset2, int len)` 交换数组中连个位置的值
`static void`	`swap(Object[] array, int offset1, int offset2)` 交换数组中连个位置的值
`static void`	`swap(Object[] array, int offset1, int offset2, int len)` 交换数组中连个位置的值
`static void`	`swap(short[] array, int offset1, int offset2)` 交换数组中连个位置的值
`static void`	`swap(short[] array, int offset1, int offset2, int len)` 交换数组中连个位置的值
`static byte[]`	`toArray(ByteBuffer bytebuffer)` `ByteBuffer` 转byte数组
`static <T> T[]`	`toArray(Collection<T> collection, Class<T> componentType)` 将集合转为数组
`static <T> T[]`	`toArray(Iterable<T> iterable, Class<T> componentType)` 将集合转为数组
`static <T> T[]`	`toArray(Iterator<T> iterator, Class<T> componentType)` 将集合转为数组
`static String[]`	`toArray(List<String> list)` 将集合转数组
`static Boolean[]`	`toObject(boolean[] array)` 将原始布尔值数组转换为对象此方法为`null`输入数组返回`null`
`static Byte[]`	`toObject(byte[] array)` 将对象byte数组转换为处理`null`的原始对象此方法为`null`输入数组返回`null`
`static Character[]`	`toObject(char[] array)` 将对象char数组转换为处理`null`的原始对象此方法为`null`输入数组返回`null`
`static Double[]`	`toObject(double[] array)` 将对象double数组转换为处理`null`的原始对象此方法为`null`输入数组返回`null`
`static Float[]`	`toObject(float[] array)` 将基元float组转换为对象此方法为`null`输入数组返回`null`
`static Integer[]`	`toObject(int[] array)` 将对象int数组转换为处理`null`的原始对象此方法为`null`输入数组返回`null`
`static Long[]`	`toObject(long[] array)` 将对象long数组转换为处理`null`的原始对象此方法为`null`输入数组返回`null`
`static Short[]`	`toObject(short[] array)` 将对象short数组转换为处理`null`的原始对象此方法为`null`输入数组返回`null`
`static boolean[]`	`toPrimitive(Boolean[] array)` 将对象布尔值数组转换为处理`null`的原始的类型此方法为`null`输入数组返回`null`
`static boolean[]`	`toPrimitive(Boolean[] array, boolean valueForNull)` 将对象布尔值数组转换为处理`null`的原始的类型此方法为`null`输入数组返回`null`
`static byte[]`	`toPrimitive(Byte[] array)` 将对象Byte数组转换为处理`null`的原始对象此方法为`null`输入数组返回`null`
`static byte[]`	`toPrimitive(Byte[] array, byte valueForNull)` 将对象Byte数组转换为处理`null`的原始对象此方法为`null`输入数组返回`null`
`static char[]`	`toPrimitive(Character[] array)` 将对象Character数组转换为处理`null`的原始对象此方法为`null`输入数组返回`null`
`static char[]`	`toPrimitive(Character[] array, char valueForNull)` 将对象Character数组转换为处理`null`的原始对象此方法为`null`输入数组返回`null`
`static double[]`	`toPrimitive(Double[] array)` 将对象Double数组转换为处理`null`的原始对象此方法为`null`输入数组返回`null`
`static double[]`	`toPrimitive(Double[] array, double valueForNull)` 将对象Double数组转换为处理`null`的原始对象此方法为`null`输入数组返回`null`
`static float[]`	`toPrimitive(Float[] array)` 将对象Float数组转换为处理`null`的原始对象此方法为`null`输入数组返回`null`
`static float[]`	`toPrimitive(Float[] array, float valueForNull)` 将对象Float数组转换为处理`null`的原始对象此方法为`null`输入数组返回`null`
`static int[]`	`toPrimitive(Integer[] array)` 将对象Integer数组转换为处理`null`的原始对象此方法为`null`输入数组返回`null`
`static int[]`	`toPrimitive(Integer[] array, int valueForNull)` 将对象Integer数组转换为处理`null`的原始对象此方法为`null`输入数组返回`null`
`static long[]`	`toPrimitive(Long[] array)` 将对象Long数组转换为处理`null`的原始对象此方法为`null`输入数组返回`null`
`static long[]`	`toPrimitive(Long[] array, long valueForNull)` 将对象Long数组转换为处理`null`的原始对象此方法为`null`输入数组返回`null`
`static Object`	`toPrimitive(Object array)` 从包装器类型数组创建基元类型数组该方法为一个`null`输入数组返回`null`
`static short[]`	`toPrimitive(Short[] array)` 将对象Short数组转换为处理`null`的原始对象此方法为`null`输入数组返回`null`
`static short[]`	`toPrimitive(Short[] array, short valueForNull)` 将对象Short数组转换为处理`null`的原始对象此方法为`null`输入数组返回`null`
`static String`	`toString(Object obj)` 数组或集合转String
`static String`	`toString(Object array, String stringIfNull)` 数组或集合转String
`static String[]`	`toStringArray(Object[] array)` 返回一个数组，该数组包含参数数组中每个元素的字符串表示形式.
`static String[]`	`toStringArray(Object[] array, String valueForNullElements)` 返回一个数组，该数组包含处理`null`元素的参数数组中每个元素的字符串表示形式该方法为一个`null`输入数组返回`null`
`static boolean[]`	`unWrap(Boolean... values)` 包装类数组转为原始类型数组
`static byte[]`	`unWrap(Byte... values)` 包装类数组转为原始类型数组
`static char[]`	`unWrap(Character... values)` 包装类数组转为原始类型数组
`static double[]`	`unWrap(Double... values)` 包装类数组转为原始类型数组
`static float[]`	`unWrap(Float... values)` 包装类数组转为原始类型数组
`static int[]`	`unWrap(Integer... values)` 包装类数组转为原始类型数组
`static long[]`	`unWrap(Long... values)` 包装类数组转为原始类型数组
`static short[]`	`unWrap(Short... values)` 包装类数组转为原始类型数组
`static Boolean[]`	`wrap(boolean... values)` 将原始类型数组包装为包装类型
`static Byte[]`	`wrap(byte... values)` 将原始类型数组包装为包装类型
`static Character[]`	`wrap(char... values)` 将原始类型数组包装为包装类型
`static Double[]`	`wrap(double... values)` 将原始类型数组包装为包装类型
`static Float[]`	`wrap(float... values)` 将原始类型数组包装为包装类型
`static Long[]`	`wrap(long... values)` 将原始类型数组包装为包装类型
`static Object[]`	`wrap(Object obj)` 包装数组对象
`static Short[]`	`wrap(short... values)` 将原始类型数组包装为包装类型
`static <K,V> Map<K,V>`	`zip(K[] keys, V[] values)` 映射键值(参考Python的zip()函数)，返回Map无序例如： keys = [a,b,c,d] values = [1,2,3,4] 则得到的Map是 {a=1, b=2, c=3, d=4} 如果两个数组长度不同，则只对应最短部分
`static <K,V> Map<K,V>`	`zip(K[] keys, V[] values, boolean isOrder)` 映射键值(参考Python的zip()函数) 例如： keys = [a,b,c,d] values = [1,2,3,4] 则得到的Map是 {a=1, b=2, c=3, d=4} 如果两个数组长度不同,则只对应最短部分

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

- Constructor Detail
  - ArrayKit
```
public ArrayKit()
```
- Method Detail
  - isArray
```
public static boolean isArray(Object obj)
```
    对象是否为数组对象
    
    Parameters:
    
    obj - 对象
    
    Returns:
    
    是否为数组对象, 如果为null 返回false
  - isEmpty
```
public static boolean isEmpty(Object array)
```
    数组是否为空此方法会匹配单一对象,如果此对象为null则返回true 如果此对象为非数组,理解为此对象为数组的第一个元素,则返回false 如果此对象为数组对象,数组长度大于0情况下返回false,否则返回true
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    是否为空
  - isEmpty
```
public static <T> boolean isEmpty(T[] array)
```
    数组是否为空
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    是否为空
  - isEmpty
```
public static boolean isEmpty(long[] array)
```
    数组是否为空
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    是否为空
  - isEmpty
```
public static boolean isEmpty(int[] array)
```
    数组是否为空
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    是否为空
  - isEmpty
```
public static boolean isEmpty(short[] array)
```
    数组是否为空
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    是否为空
  - isEmpty
```
public static boolean isEmpty(char[] array)
```
    数组是否为空
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    是否为空
  - isEmpty
```
public static boolean isEmpty(byte[] array)
```
    数组是否为空
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    是否为空
  - isEmpty
```
public static boolean isEmpty(double[] array)
```
    数组是否为空
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    是否为空
  - isEmpty
```
public static boolean isEmpty(float[] array)
```
    数组是否为空
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    是否为空
  - isEmpty
```
public static boolean isEmpty(boolean[] array)
```
    数组是否为空
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    是否为空
  - isNotEmpty
```
public static <T> boolean isNotEmpty(T[] array)
```
    数组是否为非空此方法会匹配单一对象,如果此对象为null则返回false 如果此对象为非数组,理解为此对象为数组的第一个元素,则返回true 如果此对象为数组对象,数组长度大于0情况下返回true,否则返回false
    
    Type Parameters:
    
    T - 对象
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    是否为非空
  - isNotEmpty
```
public static boolean isNotEmpty(long[] array)
```
    数组是否为非空
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    是否为非空
  - isNotEmpty
```
public static boolean isNotEmpty(int[] array)
```
    数组是否为非空
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    是否为非空
  - isNotEmpty
```
public static boolean isNotEmpty(short[] array)
```
    数组是否为非空
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    是否为非空
  - isNotEmpty
```
public static boolean isNotEmpty(char[] array)
```
    数组是否为非空
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    是否为非空
  - isNotEmpty
```
public static boolean isNotEmpty(byte[] array)
```
    数组是否为非空
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    是否为非空
  - isNotEmpty
```
public static boolean isNotEmpty(double[] array)
```
    数组是否为非空
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    是否为非空
  - isNotEmpty
```
public static boolean isNotEmpty(float[] array)
```
    数组是否为非空
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    是否为非空
  - isNotEmpty
```
public static boolean isNotEmpty(boolean[] array)
```
    数组是否为非空
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    是否为非空
  - isAllEmpty
```
public static boolean isAllEmpty(Object... args)
```
    是否存都为null或空对象，通过ObjectKit.isEmpty(Object) 判断元素
    
    Parameters:
    
    args - 被检查的对象,一个或者多个
    
    Returns:
    
    是否都为空
  - isAllNotEmpty
```
public static boolean isAllNotEmpty(Object... args)
```
    是否存都不为null或空对象，通过ObjectKit.isEmpty(Object) 判断元素
    
    Parameters:
    
    args - 被检查的对象,一个或者多个
    
    Returns:
    
    是否都不为空
  - nullToEmpty
```
public static <T> T[] nullToEmpty(T[] array,
                                  Class<T[]> type)
```
    输入数组返回一个空数组或原始数组
    
    Type Parameters:
    
    T - class 类型
    
    Parameters:
    
    array - 要检查null或为空的数组
    
    type - 所需数组的类表示形式
    
    Returns:
    
    如果null
    
    Throws:
    
    IllegalArgumentException - 如果类型参数为空
  - nullToEmpty
```
public static Object[] nullToEmpty(Object[] array)
```
    输入数组返回一个空数组或原始数组
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    空数组或原始数组
  - nullToEmpty
```
public static Class<?>[] nullToEmpty(Class<?>[] array)
```
    输入数组返回一个空数组或原始数组
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    空数组或原始数组
  - nullToEmpty
```
public static String[] nullToEmpty(String[] array)
```
    输入数组返回一个空数组或原始数组
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    空数组或原始数组
  - nullToEmpty
```
public static long[] nullToEmpty(long[] array)
```
    输入数组返回一个空数组或原始数组
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    空数组或原始数组
  - nullToEmpty
```
public static int[] nullToEmpty(int[] array)
```
    输入数组返回一个空数组或原始数组
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    空数组或原始数组
  - nullToEmpty
```
public static short[] nullToEmpty(short[] array)
```
    输入数组返回一个空数组或原始数组
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    空数组或原始数组
  - nullToEmpty
```
public static char[] nullToEmpty(char[] array)
```
    输入数组返回一个空数组或原始数组
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    空数组或原始数组
  - nullToEmpty
```
public static byte[] nullToEmpty(byte[] array)
```
    输入数组返回一个空数组或原始数组
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    空数组或原始数组
  - nullToEmpty
```
public static double[] nullToEmpty(double[] array)
```
    输入数组返回一个空数组或原始数组
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    空数组或原始数组
  - nullToEmpty
```
public static float[] nullToEmpty(float[] array)
```
    输入数组返回一个空数组或原始数组
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    空数组或原始数组
  - nullToEmpty
```
public static boolean[] nullToEmpty(boolean[] array)
```
    输入数组返回一个空数组或原始数组
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    空数组或原始数组
  - nullToEmpty
```
public static Long[] nullToEmpty(Long[] array)
```
    输入数组返回一个空数组或原始数组
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    空数组或原始数组
  - nullToEmpty
```
public static Integer[] nullToEmpty(Integer[] array)
```
    输入数组返回一个空数组或原始数组
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    空数组或原始数组
  - nullToEmpty
```
public static Short[] nullToEmpty(Short[] array)
```
    输入数组返回一个空数组或原始数组
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    空数组或原始数组
  - nullToEmpty
```
public static Character[] nullToEmpty(Character[] array)
```
    输入数组返回一个空数组或原始数组
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    空数组或原始数组
  - nullToEmpty
```
public static Byte[] nullToEmpty(Byte[] array)
```
    输入数组返回一个空数组或原始数组
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    空数组或原始数组
  - nullToEmpty
```
public static Double[] nullToEmpty(Double[] array)
```
    输入数组返回一个空数组或原始数组
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    空数组或原始数组
  - nullToEmpty
```
public static Float[] nullToEmpty(Float[] array)
```
    输入数组返回一个空数组或原始数组
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    空数组或原始数组
  - nullToEmpty
```
public static Boolean[] nullToEmpty(Boolean[] array)
```
    输入数组返回一个空数组或原始数组
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    空数组或原始数组
  - hasEmpty
```
public static boolean hasEmpty(Object... args)
```
    是否存在null或空对象，通过ObjectKit.isEmpty(Object) 判断元素
    
    Parameters:
    
    args - 被检查对象
    
    Returns:
    
    是否存在
  - hasNull
```
public static <T> boolean hasNull(T... array)
```
    是否包含null元素
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 被检查的数组
    
    Returns:
    
    是否包含null元素
  - firstNonNull
```
public static <T> T firstNonNull(T... array)
```
    返回数组中第一个非空元素
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    非空元素, 如果不存在非空元素或数组为空, 返回null
  - firstNotNull
```
public static Optional<Object> firstNotNull(Object[] objects)
```
    找到第一个不为 null 的元素
    
    Parameters:
    
    objects - 对象
    
    Returns:
    
    不为 null 的元素
  - toString
```
public static String toString(Object obj)
```
    数组或集合转String
    
    Parameters:
    
    obj - 集合或数组对象
    
    Returns:
    
    数组字符串, 与集合转字符串格式相同
  - toString
```
public static String toString(Object array,
                              String stringIfNull)
```
    数组或集合转String
    
    Parameters:
    
    array - 集合或数组对象
    
    stringIfNull - 是否null
    
    Returns:
    
    数组字符串, 与集合转字符串格式相同
  - toArray
```
public static String[] toArray(List<String> list)
```
    将集合转数组
    
    Parameters:
    
    list - 需要转换的集合信息
    
    Returns:
    
    转换后的数组
  - toArray
```
public static byte[] toArray(ByteBuffer bytebuffer)
```
    ByteBuffer 转byte数组
    
    Parameters:
    
    bytebuffer - ByteBuffer
    
    Returns:
    
    byte数组
  - toArray
```
public static <T> T[] toArray(Iterator<T> iterator,
                              Class<T> componentType)
```
    将集合转为数组
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    iterator - Iterator
    
    componentType - 集合元素类型
    
    Returns:
    
    数组
  - toArray
```
public static <T> T[] toArray(Iterable<T> iterable,
                              Class<T> componentType)
```
    将集合转为数组
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    iterable - Iterable
    
    componentType - 集合元素类型
    
    Returns:
    
    数组
  - toArray
```
public static <T> T[] toArray(Collection<T> collection,
                              Class<T> componentType)
```
    将集合转为数组
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    collection - 集合
    
    componentType - 集合元素类型
    
    Returns:
    
    数组
  - clone
```
public static <T> T[] clone(T[] array)
```
    克隆数组
    
    Type Parameters:
    
    T - 对象
    
    Parameters:
    
    array - 被克隆的数组
    
    Returns:
    
    新数组
  - clone
```
public static <T> T clone(T obj)
```
    克隆数组,如果非数组返回null
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    obj - 数组对象
    
    Returns:
    
    克隆后的数组对象
  - clone
```
public static long[] clone(long[] array)
```
    克隆数组
    
    Parameters:
    
    array - 被克隆的数组
    
    Returns:
    
    新数组
  - clone
```
public static int[] clone(int[] array)
```
    克隆数组
    
    Parameters:
    
    array - 被克隆的数组
    
    Returns:
    
    新数组
  - clone
```
public static short[] clone(short[] array)
```
    克隆数组
    
    Parameters:
    
    array - 被克隆的数组
    
    Returns:
    
    新数组
  - clone
```
public static char[] clone(char[] array)
```
    克隆数组
    
    Parameters:
    
    array - 被克隆的数组
    
    Returns:
    
    新数组
  - clone
```
public static byte[] clone(byte[] array)
```
    克隆数组
    
    Parameters:
    
    array - 被克隆的数组
    
    Returns:
    
    新数组
  - clone
```
public static double[] clone(double[] array)
```
    克隆数组
    
    Parameters:
    
    array - 被克隆的数组
    
    Returns:
    
    新数组
  - clone
```
public static float[] clone(float[] array)
```
    克隆数组
    
    Parameters:
    
    array - 被克隆的数组
    
    Returns:
    
    新数组
  - clone
```
public static boolean[] clone(boolean[] array)
```
    克隆数组
    
    Parameters:
    
    array - 被克隆的数组
    
    Returns:
    
    新数组
  - subarray
```
public static <T> T[] subarray(T[] array,
                               int startIndex,
                               int endIndex)
```
    生成一个新的数组,其中包含元素开始索引取值至结束位置索引开始索引包含,结束索引不包含,空数组输入产生空输出
    
    Type Parameters:
    
    T - 对象
    
    Parameters:
    
    array - 对象数组
    
    startIndex - 开始索引
    
    endIndex - 结束索引
    
    Returns:
    
    新数组
  - subarray
```
public static long[] subarray(long[] array,
                              int startIndex,
                              int endIndex)
```
    生成一个新的数组,其中包含元素开始索引取值至结束位置索引开始索引包含,结束索引不包含,空数组输入产生空输出
    
    Parameters:
    
    array - 对象数组
    
    startIndex - 开始索引
    
    endIndex - 结束索引
    
    Returns:
    
    新数组
  - subarray
```
public static int[] subarray(int[] array,
                             int startIndex,
                             int endIndex)
```
    生成一个新的数组,其中包含元素开始索引取值至结束位置索引开始索引包含,结束索引不包含,空数组输入产生空输出
    
    Parameters:
    
    array - 对象数组
    
    startIndex - 开始索引
    
    endIndex - 结束索引
    
    Returns:
    
    新数组
  - subarray
```
public static short[] subarray(short[] array,
                               int startIndex,
                               int endIndex)
```
    生成一个新的数组,其中包含元素开始索引取值至结束位置索引开始索引包含,结束索引不包含,空数组输入产生空输出
    
    Parameters:
    
    array - 对象数组
    
    startIndex - 开始索引
    
    endIndex - 结束索引
    
    Returns:
    
    新数组
  - subarray
```
public static char[] subarray(char[] array,
                              int startIndex,
                              int endIndex)
```
    生成一个新的数组,其中包含元素开始索引取值至结束位置索引开始索引包含,结束索引不包含,空数组输入产生空输出
    
    Parameters:
    
    array - 对象数组
    
    startIndex - 开始索引
    
    endIndex - 结束索引
    
    Returns:
    
    新数组
  - subarray
```
public static byte[] subarray(byte[] array,
                              int startIndex,
                              int endIndex)
```
    生成一个新的数组,其中包含元素开始索引取值至结束位置索引开始索引包含,结束索引不包含,空数组输入产生空输出
    
    Parameters:
    
    array - 对象数组
    
    startIndex - 开始索引
    
    endIndex - 结束索引
    
    Returns:
    
    新数组
  - subarray
```
public static double[] subarray(double[] array,
                                int startIndex,
                                int endIndex)
```
    生成一个新的数组,其中包含元素开始索引取值至结束位置索引开始索引包含,结束索引不包含,空数组输入产生空输出
    
    Parameters:
    
    array - 对象数组
    
    startIndex - 开始索引
    
    endIndex - 结束索引
    
    Returns:
    
    新数组
  - subarray
```
public static float[] subarray(float[] array,
                               int startIndex,
                               int endIndex)
```
    生成一个新的数组,其中包含元素开始索引取值至结束位置索引开始索引包含,结束索引不包含,空数组输入产生空输出
    
    Parameters:
    
    array - 对象数组
    
    startIndex - 开始索引
    
    endIndex - 结束索引
    
    Returns:
    
    新数组
  - subarray
```
public static boolean[] subarray(boolean[] array,
                                 int startIndex,
                                 int endIndex)
```
    生成一个新的数组,其中包含元素开始索引取值至结束位置索引开始索引包含,结束索引不包含,空数组输入产生空输出
    
    Parameters:
    
    array - 对象数组
    
    startIndex - 开始索引
    
    endIndex - 结束索引
    
    Returns:
    
    新数组
  - isSameLength
```
public static boolean isSameLength(Object[] array1,
                                   Object[] array2)
```
    检查两个数组是否相同长度
    
    Parameters:
    
    array1 - 参数1
    
    array2 - 参数2
    
    Returns:
    
    如果长度匹配返回true否则false
  - isSameLength
```
public static boolean isSameLength(long[] array1,
                                   long[] array2)
```
    检查两个数组是否相同长度
    
    Parameters:
    
    array1 - 参数1
    
    array2 - 参数2
    
    Returns:
    
    如果长度匹配返回true否则false
  - isSameLength
```
public static boolean isSameLength(int[] array1,
                                   int[] array2)
```
    检查两个数组是否相同长度
    
    Parameters:
    
    array1 - 参数1
    
    array2 - 参数2
    
    Returns:
    
    如果长度匹配返回true否则false
  - isSameLength
```
public static boolean isSameLength(short[] array1,
                                   short[] array2)
```
    检查两个数组是否相同长度
    
    Parameters:
    
    array1 - 参数1
    
    array2 - 参数2
    
    Returns:
    
    如果长度匹配返回true否则false
  - isSameLength
```
public static boolean isSameLength(char[] array1,
                                   char[] array2)
```
    检查两个数组是否相同长度
    
    Parameters:
    
    array1 - 参数1
    
    array2 - 参数2
    
    Returns:
    
    如果长度匹配返回true否则false
  - isSameLength
```
public static boolean isSameLength(byte[] array1,
                                   byte[] array2)
```
    检查两个数组是否相同长度
    
    Parameters:
    
    array1 - 参数1
    
    array2 - 参数2
    
    Returns:
    
    如果长度匹配返回true否则false
  - isSameLength
```
public static boolean isSameLength(double[] array1,
                                   double[] array2)
```
    检查两个数组是否相同长度
    
    Parameters:
    
    array1 - 参数1
    
    array2 - 参数2
    
    Returns:
    
    如果长度匹配返回true否则false
  - isSameLength
```
public static boolean isSameLength(float[] array1,
                                   float[] array2)
```
    检查两个数组是否相同长度
    
    Parameters:
    
    array1 - 参数1
    
    array2 - 参数2
    
    Returns:
    
    如果长度匹配返回true否则false
  - isSameLength
```
public static boolean isSameLength(boolean[] array1,
                                   boolean[] array2)
```
    检查两个数组是否相同长度
    
    Parameters:
    
    array1 - 参数1
    
    array2 - 参数2
    
    Returns:
    
    如果长度匹配返回true否则false
  - reverse
```
public static void reverse(Object[] array)
```
    反转数组,会变更原数组
    
    Parameters:
    
    array - 数组,会变更
  - reverse
```
public static void reverse(long[] array)
```
    反转数组,会变更原数组
    
    Parameters:
    
    array - 数组,会变更
  - reverse
```
public static void reverse(int[] array)
```
    反转数组,会变更原数组
    
    Parameters:
    
    array - 数组,会变更
  - reverse
```
public static void reverse(short[] array)
```
    反转数组,会变更原数组
    
    Parameters:
    
    array - 数组,会变更
  - reverse
```
public static void reverse(char[] array)
```
    反转数组,会变更原数组
    
    Parameters:
    
    array - 数组,会变更
  - reverse
```
public static void reverse(byte[] array)
```
    反转数组,会变更原数组
    
    Parameters:
    
    array - 数组,会变更
  - reverse
```
public static void reverse(double[] array)
```
    反转数组,会变更原数组
    
    Parameters:
    
    array - 数组,会变更
  - reverse
```
public static void reverse(float[] array)
```
    反转数组,会变更原数组
    
    Parameters:
    
    array - 数组,会变更
  - reverse
```
public static void reverse(boolean[] array)
```
    反转数组,会变更原数组
    
    Parameters:
    
    array - 数组,会变更
  - reverse
```
public static void reverse(boolean[] array,
                           int startIndex,
                           int endIndex)
```
    Parameters:
    
    array - 数组,会变更
    
    startIndex - 其实位置(包含)
    
    endIndex - 结束位置(不包含)
  - reverse
```
public static void reverse(byte[] array,
                           int startIndex,
                           int endIndex)
```
    反转数组,会变更原数组
    
    Parameters:
    
    array - 数组,会变更
    
    startIndex - 其实位置(包含)
    
    endIndex - 结束位置(不包含)
  - reverse
```
public static void reverse(char[] array,
                           int startIndex,
                           int endIndex)
```
    反转数组,会变更原数组
    
    Parameters:
    
    array - 数组,会变更
    
    startIndex - 其实位置(包含)
    
    endIndex - 结束位置(不包含)
  - reverse
```
public static void reverse(double[] array,
                           int startIndex,
                           int endIndex)
```
    反转数组,会变更原数组
    
    Parameters:
    
    array - 数组,会变更
    
    startIndex - 其实位置(包含)
    
    endIndex - 结束位置(不包含)
  - reverse
```
public static void reverse(float[] array,
                           int startIndex,
                           int endIndex)
```
    反转数组,会变更原数组
    
    Parameters:
    
    array - 数组,会变更
    
    startIndex - 其实位置(包含)
    
    endIndex - 结束位置(不包含)
  - reverse
```
public static void reverse(int[] array,
                           int startIndex,
                           int endIndex)
```
    反转数组,会变更原数组
    
    Parameters:
    
    array - 数组,会变更
    
    startIndex - 其实位置(包含)
    
    endIndex - 结束位置(不包含)
  - reverse
```
public static void reverse(long[] array,
                           int startIndex,
                           int endIndex)
```
    反转数组,会变更原数组
    
    Parameters:
    
    array - 数组,会变更
    
    startIndex - 其实位置(包含)
    
    endIndex - 结束位置(不包含)
  - reverse
```
public static void reverse(Object[] array,
                           int startIndex,
                           int endIndex)
```
    反转数组,会变更原数组
    
    Parameters:
    
    array - 数组,会变更
    
    startIndex - 其实位置(包含)
    
    endIndex - 结束位置(不包含)
  - reverse
```
public static void reverse(short[] array,
                           int startIndex,
                           int endIndex)
```
    反转数组,会变更原数组
    
    Parameters:
    
    array - 数组,会变更
    
    startIndex - 其实位置(包含)
    
    endIndex - 结束位置(不包含)
  - swap
```
public static void swap(Object[] array,
                        int offset1,
                        int offset2)
```
    交换数组中连个位置的值
    
    Parameters:
    
    array - 数组
    
    offset1 - 位置1
    
    offset2 - 位置2
  - swap
```
public static void swap(long[] array,
                        int offset1,
                        int offset2)
```
    交换数组中连个位置的值
    
    Parameters:
    
    array - 数组
    
    offset1 - 位置1
    
    offset2 - 位置2
  - swap
```
public static void swap(int[] array,
                        int offset1,
                        int offset2)
```
    交换数组中连个位置的值
    
    Parameters:
    
    array - 数组
    
    offset1 - 位置1
    
    offset2 - 位置2
  - swap
```
public static void swap(short[] array,
                        int offset1,
                        int offset2)
```
    交换数组中连个位置的值
    
    Parameters:
    
    array - 数组
    
    offset1 - 位置1
    
    offset2 - 位置2
  - swap
```
public static void swap(char[] array,
                        int offset1,
                        int offset2)
```
    交换数组中连个位置的值
    
    Parameters:
    
    array - 数组
    
    offset1 - 位置1
    
    offset2 - 位置2
  - swap
```
public static void swap(byte[] array,
                        int offset1,
                        int offset2)
```
    交换数组中连个位置的值
    
    Parameters:
    
    array - 数组
    
    offset1 - 位置1
    
    offset2 - 位置2
  - swap
```
public static void swap(double[] array,
                        int offset1,
                        int offset2)
```
    交换数组中连个位置的值
    
    Parameters:
    
    array - 数组
    
    offset1 - 位置1
    
    offset2 - 位置2
  - swap
```
public static void swap(float[] array,
                        int offset1,
                        int offset2)
```
    交换数组中连个位置的值
    
    Parameters:
    
    array - 数组
    
    offset1 - 位置1
    
    offset2 - 位置2
  - swap
```
public static void swap(boolean[] array,
                        int offset1,
                        int offset2)
```
    交换数组中连个位置的值
    
    Parameters:
    
    array - 数组
    
    offset1 - 位置1
    
    offset2 - 位置2
  - swap
```
public static void swap(boolean[] array,
                        int offset1,
                        int offset2,
                        int len)
```
    交换数组中连个位置的值
    
    Parameters:
    
    array - 数组
    
    offset1 - 位置1
    
    offset2 - 位置2
    
    len - 从给定索引开始交换的元素数量
  - swap
```
public static void swap(byte[] array,
                        int offset1,
                        int offset2,
                        int len)
```
    交换数组中连个位置的值
    
    Parameters:
    
    array - 数组
    
    offset1 - 位置1
    
    offset2 - 位置2
    
    len - 从给定索引开始交换的元素数量
  - swap
```
public static void swap(char[] array,
                        int offset1,
                        int offset2,
                        int len)
```
    交换数组中连个位置的值
    
    Parameters:
    
    array - 数组
    
    offset1 - 位置1
    
    offset2 - 位置2
    
    len - 从给定索引开始交换的元素数量
  - swap
```
public static void swap(double[] array,
                        int offset1,
                        int offset2,
                        int len)
```
    交换数组中连个位置的值
    
    Parameters:
    
    array - 数组
    
    offset1 - 位置1
    
    offset2 - 位置2
    
    len - 从给定索引开始交换的元素数量
  - swap
```
public static void swap(float[] array,
                        int offset1,
                        int offset2,
                        int len)
```
    交换数组中连个位置的值
    
    Parameters:
    
    array - 数组
    
    offset1 - 位置1
    
    offset2 - 位置2
    
    len - 从给定索引开始交换的元素数量
  - swap
```
public static void swap(int[] array,
                        int offset1,
                        int offset2,
                        int len)
```
    交换数组中连个位置的值
    
    Parameters:
    
    array - 数组
    
    offset1 - 位置1
    
    offset2 - 位置2
    
    len - 从给定索引开始交换的元素数量
  - swap
```
public static void swap(long[] array,
                        int offset1,
                        int offset2,
                        int len)
```
    交换数组中连个位置的值
    
    Parameters:
    
    array - 数组
    
    offset1 - 位置1
    
    offset2 - 位置2
    
    len - 从给定索引开始交换的元素数量
  - swap
```
public static void swap(Object[] array,
                        int offset1,
                        int offset2,
                        int len)
```
    交换数组中连个位置的值
    
    Parameters:
    
    array - 数组
    
    offset1 - 位置1
    
    offset2 - 位置2
    
    len - 从给定索引开始交换的元素数量
  - swap
```
public static void swap(short[] array,
                        int offset1,
                        int offset2,
                        int len)
```
    交换数组中连个位置的值
    
    Parameters:
    
    array - 数组
    
    offset1 - 位置1
    
    offset2 - 位置2
    
    len - 从给定索引开始交换的元素数量
  - shift
```
public static void shift(Object[] array,
                         int offset)
```
    移位给定数组的顺序
    
    Parameters:
    
    array - 要移动的数组，可以为null
    
    offset - 旋转元素的位置数。如果偏移量大于*旋转的元素数，则有效偏移量将等于旋转的元素数
  - shift
```
public static void shift(long[] array,
                         int offset)
```
    移位给定长数组的顺序
    
    Parameters:
    
    array - 要移动的数组，可以为null
    
    offset - 旋转元素的位置数。如果偏移量大于*旋转的元素数，则有效偏移量将等于旋转的元素数
  - shift
```
public static void shift(int[] array,
                         int offset)
```
    移位给定int数组的顺序
    
    Parameters:
    
    array - 要移动的数组，可以为null
    
    offset - 旋转元素的位置数。如果偏移量大于*旋转的元素数，则有效偏移量将等于旋转的元素数
  - shift
```
public static void shift(short[] array,
                         int offset)
```
    改变数组的顺序
    
    Parameters:
    
    array - 原数组
    
    offset - 偏移量
  - shift
```
public static void shift(char[] array,
                         int offset)
```
    改变数组的顺序
    
    Parameters:
    
    array - 原数组
    
    offset - 偏移量
  - shift
```
public static void shift(byte[] array,
                         int offset)
```
    改变数组的顺序
    
    Parameters:
    
    array - 原数组
    
    offset - 偏移量
  - shift
```
public static void shift(double[] array,
                         int offset)
```
    改变数组的顺序
    
    Parameters:
    
    array - 原数组
    
    offset - 偏移量
  - shift
```
public static void shift(float[] array,
                         int offset)
```
    改变数组的顺序
    
    Parameters:
    
    array - 原数组
    
    offset - 偏移量
  - shift
```
public static void shift(boolean[] array,
                         int offset)
```
    改变数组的顺序
    
    Parameters:
    
    array - 原数组
    
    offset - 偏移量
  - shift
```
public static void shift(boolean[] array,
                         int startIndex,
                         int endIndex,
                         int offset)
```
    改变数组的顺序
    
    Parameters:
    
    array - 原数组
    
    startIndex - 开始索引
    
    endIndex - 结束索引
    
    offset - 偏移量
  - shift
```
public static void shift(byte[] array,
                         int startIndex,
                         int endIndex,
                         int offset)
```
    改变数组的顺序
    
    Parameters:
    
    array - 原数组
    
    startIndex - 开始索引
    
    endIndex - 结束索引
    
    offset - 偏移量
  - shift
```
public static void shift(char[] array,
                         int startIndex,
                         int endIndex,
                         int offset)
```
    改变数组的顺序
    
    Parameters:
    
    array - 原数组
    
    startIndex - 开始索引
    
    endIndex - 结束索引
    
    offset - 偏移量
  - shift
```
public static void shift(double[] array,
                         int startIndex,
                         int endIndex,
                         int offset)
```
    改变数组的顺序
    
    Parameters:
    
    array - 原数组
    
    startIndex - 开始索引
    
    endIndex - 结束索引
    
    offset - 偏移量
  - shift
```
public static void shift(float[] array,
                         int startIndex,
                         int endIndex,
                         int offset)
```
    改变数组的顺序
    
    Parameters:
    
    array - 原数组
    
    startIndex - 开始索引
    
    endIndex - 结束索引
    
    offset - 偏移量
  - shift
```
public static void shift(int[] array,
                         int startIndex,
                         int endIndex,
                         int offset)
```
    改变数组的顺序
    
    Parameters:
    
    array - 原数组
    
    startIndex - 开始索引
    
    endIndex - 结束索引
    
    offset - 偏移量
  - shift
```
public static void shift(long[] array,
                         int startIndex,
                         int endIndex,
                         int offset)
```
    改变数组的顺序
    
    Parameters:
    
    array - 原数组
    
    startIndex - 开始索引
    
    endIndex - 结束索引
    
    offset - 偏移量
  - shift
```
public static void shift(Object[] array,
                         int startIndex,
                         int endIndex,
                         int offset)
```
    改变数组的顺序
    
    Parameters:
    
    array - 原数组
    
    startIndex - 开始索引
    
    endIndex - 结束索引
    
    offset - 偏移量
  - shift
```
public static void shift(short[] array,
                         int startIndex,
                         int endIndex,
                         int offset)
```
    改变数组的顺序
    
    Parameters:
    
    array - 原数组
    
    startIndex - 开始索引
    
    endIndex - 结束索引
    
    offset - 偏移量
  - indexOf
```
public static int indexOf(Object[] array,
                          Object value)
```
    返回数组中指定元素所在位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - indexOf
```
public static int indexOf(Object[] array,
                          Object value,
                          int index)
```
    返回数组中指定元素所在位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    index - 索引
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - lastIndexOf
```
public static int lastIndexOf(Object[] array,
                              Object value)
```
    返回数组中指定元素所在最后的位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - lastIndexOf
```
public static int lastIndexOf(Object[] array,
                              Object value,
                              int index)
```
    返回数组中指定元素所在最后的位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    index - 索引
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - contains
```
public static boolean contains(Object[] array,
                               Object value)
```
    数组中是否包含元素
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    是否包含
  - indexOf
```
public static int indexOf(long[] array,
                          long value)
```
    返回数组中指定元素所在位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - indexOf
```
public static int indexOf(long[] array,
                          long value,
                          int index)
```
    返回数组中指定元素所在位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    index - 索引
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - lastIndexOf
```
public static int lastIndexOf(long[] array,
                              long value)
```
    返回数组中指定元素所在最后的位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - lastIndexOf
```
public static int lastIndexOf(long[] array,
                              long value,
                              int index)
```
    返回数组中指定元素所在最后的位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    index - 索引
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - contains
```
public static boolean contains(long[] array,
                               long value)
```
    数组中是否包含元素
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    是否包含
  - indexOf
```
public static int indexOf(int[] array,
                          int value)
```
    返回数组中指定元素所在位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - indexOf
```
public static int indexOf(int[] array,
                          int value,
                          int index)
```
    返回数组中指定元素所在位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    index - 索引
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - lastIndexOf
```
public static int lastIndexOf(int[] array,
                              int value)
```
    返回数组中指定元素所在最后的位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - lastIndexOf
```
public static int lastIndexOf(int[] array,
                              int value,
                              int index)
```
    返回数组中指定元素所在最后的位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    index - 索引
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - contains
```
public static boolean contains(int[] array,
                               int value)
```
    数组中是否包含元素
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    是否包含
  - indexOf
```
public static int indexOf(short[] array,
                          short value)
```
    返回数组中指定元素所在位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - indexOf
```
public static int indexOf(short[] array,
                          short value,
                          int index)
```
    返回数组中指定元素所在位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    index - 索引
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - lastIndexOf
```
public static int lastIndexOf(short[] array,
                              short value)
```
    返回数组中指定元素所在最后的位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - lastIndexOf
```
public static int lastIndexOf(short[] array,
                              short value,
                              int index)
```
    返回数组中指定元素所在最后的位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    index - 索引
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - contains
```
public static boolean contains(short[] array,
                               short value)
```
    数组中是否包含元素
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    是否包含
  - indexOf
```
public static int indexOf(char[] array,
                          char value)
```
    返回数组中指定元素所在位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - indexOf
```
public static int indexOf(char[] array,
                          char value,
                          int index)
```
    返回数组中指定元素所在位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    index - 索引
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - lastIndexOf
```
public static int lastIndexOf(char[] array,
                              char value)
```
    返回数组中指定元素所在最后的位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - lastIndexOf
```
public static int lastIndexOf(char[] array,
                              char value,
                              int index)
```
    返回数组中指定元素所在最后的位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    index - 索引
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - contains
```
public static boolean contains(char[] array,
                               char value)
```
    数组中是否包含元素
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    是否包含
  - indexOf
```
public static int indexOf(byte[] array,
                          byte value)
```
    返回数组中指定元素所在位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - indexOf
```
public static int indexOf(byte[] array,
                          byte value,
                          int index)
```
    返回数组中指定元素所在位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    index - 索引
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - lastIndexOf
```
public static int lastIndexOf(byte[] array,
                              byte value)
```
    返回数组中指定元素所在最后的位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - lastIndexOf
```
public static int lastIndexOf(byte[] array,
                              byte value,
                              int index)
```
    返回数组中指定元素所在最后的位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    index - 索引
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - contains
```
public static boolean contains(byte[] array,
                               byte value)
```
    数组中是否包含元素
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    是否包含
  - indexOf
```
public static int indexOf(double[] array,
                          double value)
```
    返回数组中指定元素所在位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - indexOf
```
public static int indexOf(double[] array,
                          double value,
                          double tolerance)
```
    返回数组中指定元素所在位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    tolerance - 容差
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - indexOf
```
public static int indexOf(double[] array,
                          double value,
                          int index)
```
    返回数组中指定元素所在位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    index - 索引
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - indexOf
```
public static int indexOf(double[] array,
                          double value,
                          int index,
                          double tolerance)
```
    返回数组中指定元素所在位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    index - 索引
    
    tolerance - 容差
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - lastIndexOf
```
public static int lastIndexOf(double[] array,
                              double value)
```
    返回数组中指定元素所在最后的位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - lastIndexOf
```
public static int lastIndexOf(double[] array,
                              double value,
                              double tolerance)
```
    返回数组中指定元素所在最后的位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    tolerance - 容差
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - lastIndexOf
```
public static int lastIndexOf(double[] array,
                              double value,
                              int index)
```
    返回数组中指定元素所在最后的位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    index - 索引
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - lastIndexOf
```
public static int lastIndexOf(double[] array,
                              double value,
                              int index,
                              double tolerance)
```
    返回数组中指定元素所在最后的位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    index - 索引
    
    tolerance - 容差
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - contains
```
public static boolean contains(double[] array,
                               double value)
```
    数组中是否包含元素
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    是否包含
  - contains
```
public static boolean contains(double[] array,
                               double value,
                               double tolerance)
```
    返回数组中指定元素所在位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    tolerance - 容差
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - indexOf
```
public static int indexOf(float[] array,
                          float value)
```
    返回数组中指定元素所在位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - indexOf
```
public static int indexOf(float[] array,
                          float value,
                          int index)
```
    返回数组中指定元素所在位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    index - 索引
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - lastIndexOf
```
public static int lastIndexOf(float[] array,
                              float value)
```
    返回数组中指定元素所在最后的位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - lastIndexOf
```
public static int lastIndexOf(float[] array,
                              float value,
                              int index)
```
    返回数组中指定元素所在最后的位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    index - 索引
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - contains
```
public static boolean contains(float[] array,
                               float value)
```
    数组中是否包含元素
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    是否包含
  - indexOf
```
public static int indexOf(boolean[] array,
                          boolean value)
```
    返回数组中指定元素所在位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - indexOf
```
public static int indexOf(boolean[] array,
                          boolean value,
                          int index)
```
    返回数组中指定元素所在位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    index - 索引
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - lastIndexOf
```
public static int lastIndexOf(boolean[] array,
                              boolean value)
```
    返回数组中指定元素所在最后的位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - lastIndexOf
```
public static int lastIndexOf(boolean[] array,
                              boolean value,
                              int index)
```
    返回数组中指定元素所在最后的位置,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    index - 索引
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - contains
```
public static boolean contains(boolean[] array,
                               boolean value)
```
    数组中是否包含元素
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    是否包含
  - toPrimitive
```
public static char[] toPrimitive(Character[] array)
```
    将对象Character数组转换为处理null的原始对象此方法为null输入数组返回null
    
    Parameters:
    
    array - Character数组，可以是null
    
    Returns:
    
    char数组，null如果为空数组输入
    
    Throws:
    
    NullPointerException - 如果数组内容是null
  - toPrimitive
```
public static char[] toPrimitive(Character[] array,
                                 char valueForNull)
```
    将对象Character数组转换为处理null的原始对象此方法为null输入数组返回null
    
    Parameters:
    
    array - Character数组，可以是null
    
    valueForNull - 找到null时要插入的值
    
    Returns:
    
    Character数组，null如果为空数组输入
  - toObject
```
public static Character[] toObject(char[] array)
```
    将对象char数组转换为处理null的原始对象此方法为null输入数组返回null
    
    Parameters:
    
    array - char数组，可以是null
    
    Returns:
    
    Character数组，null如果为空数组输入
  - toPrimitive
```
public static long[] toPrimitive(Long[] array)
```
    将对象Long数组转换为处理null的原始对象此方法为null输入数组返回null
    
    Parameters:
    
    array - Long数组，可以是null
    
    Returns:
    
    long数组，null如果为空数组输入
  - toPrimitive
```
public static long[] toPrimitive(Long[] array,
                                 long valueForNull)
```
    将对象Long数组转换为处理null的原始对象此方法为null输入数组返回null
    
    Parameters:
    
    array - Long数组，可以是null
    
    valueForNull - 找到null时要插入的值
    
    Returns:
    
    Long数组，null如果为空数组输入
  - toObject
```
public static Long[] toObject(long[] array)
```
    将对象long数组转换为处理null的原始对象此方法为null输入数组返回null
    
    Parameters:
    
    array - long数组，可以是null
    
    Returns:
    
    Long数组，null如果为空数组输入
  - toPrimitive
```
public static int[] toPrimitive(Integer[] array)
```
    将对象Integer数组转换为处理null的原始对象此方法为null输入数组返回null
    
    Parameters:
    
    array - Integer数组，可以是null
    
    Returns:
    
    int数组，null如果为空数组输入
    
    Throws:
    
    NullPointerException - 如果数组内容是null
  - toPrimitive
```
public static int[] toPrimitive(Integer[] array,
                                int valueForNull)
```
    将对象Integer数组转换为处理null的原始对象此方法为null输入数组返回null
    
    Parameters:
    
    array - Integer数组，可以是null
    
    valueForNull - 找到null时要插入的值
    
    Returns:
    
    Integer数组，null如果为空数组输入
  - toObject
```
public static Integer[] toObject(int[] array)
```
    将对象int数组转换为处理null的原始对象此方法为null输入数组返回null
    
    Parameters:
    
    array - int数组，可以是null
    
    Returns:
    
    Integer数组，null如果为空数组输入
  - toPrimitive
```
public static short[] toPrimitive(Short[] array)
```
    将对象Short数组转换为处理null的原始对象此方法为null输入数组返回null
    
    Parameters:
    
    array - Short数组，可以是null
    
    Returns:
    
    short数组，null如果为空数组输入
  - toPrimitive
```
public static short[] toPrimitive(Short[] array,
                                  short valueForNull)
```
    将对象Short数组转换为处理null的原始对象此方法为null输入数组返回null
    
    Parameters:
    
    array - Short数组，可以是null
    
    valueForNull - 找到null时要插入的值
    
    Returns:
    
    Short数组，null如果为空数组输入
  - toObject
```
public static Short[] toObject(short[] array)
```
    将对象short数组转换为处理null的原始对象此方法为null输入数组返回null
    
    Parameters:
    
    array - short数组，可以是null
    
    Returns:
    
    Short数组，null如果为空数组输入
  - toPrimitive
```
public static byte[] toPrimitive(Byte[] array)
```
    将对象Byte数组转换为处理null的原始对象此方法为null输入数组返回null
    
    Parameters:
    
    array - Byte数组，可以是null
    
    Returns:
    
    byte数组，null如果为空数组输入
    
    Throws:
    
    NullPointerException - 如果数组内容是null
  - toPrimitive
```
public static byte[] toPrimitive(Byte[] array,
                                 byte valueForNull)
```
    将对象Byte数组转换为处理null的原始对象此方法为null输入数组返回null
    
    Parameters:
    
    array - Byte数组，可以是null
    
    valueForNull - 找到null时要插入的值
    
    Returns:
    
    Byte数组，null如果为空数组输入
  - toObject
```
public static Byte[] toObject(byte[] array)
```
    将对象byte数组转换为处理null的原始对象此方法为null输入数组返回null
    
    Parameters:
    
    array - byte数组，可以是null
    
    Returns:
    
    Byte数组，null如果为空数组输入
  - toPrimitive
```
public static double[] toPrimitive(Double[] array)
```
    将对象Double数组转换为处理null的原始对象此方法为null输入数组返回null
    
    Parameters:
    
    array - Double数组，可以是null
    
    Returns:
    
    double数组，null如果为空数组输入
    
    Throws:
    
    NullPointerException - 如果数组内容是null
  - toPrimitive
```
public static double[] toPrimitive(Double[] array,
                                   double valueForNull)
```
    将对象Double数组转换为处理null的原始对象此方法为null输入数组返回null
    
    Parameters:
    
    array - Double数组，可以是null
    
    valueForNull - 找到null时要插入的值
    
    Returns:
    
    Double数组，null如果为空数组输入
  - toObject
```
public static Double[] toObject(double[] array)
```
    将对象double数组转换为处理null的原始对象此方法为null输入数组返回null
    
    Parameters:
    
    array - double数组，可以是null
    
    Returns:
    
    double数组，null如果为空数组输入
  - toPrimitive
```
public static float[] toPrimitive(Float[] array)
```
    将对象Float数组转换为处理null的原始对象此方法为null输入数组返回null
    
    Parameters:
    
    array - Float数组，可以是null
    
    Returns:
    
    float数组，null如果为空数组输入
    
    Throws:
    
    NullPointerException - 如果数组内容是null
  - toPrimitive
```
public static float[] toPrimitive(Float[] array,
                                  float valueForNull)
```
    将对象Float数组转换为处理null的原始对象此方法为null输入数组返回null
    
    Parameters:
    
    array - Float数组，可以是null
    
    valueForNull - 找到null时要插入的值
    
    Returns:
    
    float数组，null如果为空数组输入
  - toObject
```
public static Float[] toObject(float[] array)
```
    将基元float组转换为对象此方法为null输入数组返回null
    
    Parameters:
    
    array - float数组
    
    Returns:
    
    Float数组，null如果为空数组输入
  - toPrimitive
```
public static Object toPrimitive(Object array)
```
    从包装器类型数组创建基元类型数组该方法为一个null输入数组返回null
    
    Parameters:
    
    array - 包装器对象的数组
    
    Returns:
    
    对应基元类型的数组，或原始数组
  - toPrimitive
```
public static boolean[] toPrimitive(Boolean[] array)
```
    将对象布尔值数组转换为处理null的原始的类型此方法为null输入数组返回null
    
    Parameters:
    
    array - Boolean数组，可以是null
    
    Returns:
    
    返回boolean数组, 如果输入为null则为null
    
    Throws:
    
    NullPointerException - 如果数组内容是null
  - toPrimitive
```
public static boolean[] toPrimitive(Boolean[] array,
                                    boolean valueForNull)
```
    将对象布尔值数组转换为处理null的原始的类型此方法为null输入数组返回null
    
    Parameters:
    
    array - Boolean数组，可以是null
    
    valueForNull - 找到null时要插入的值
    
    Returns:
    
    返回boolean数组, 如果输入为null则为null
  - toObject
```
public static Boolean[] toObject(boolean[] array)
```
    将原始布尔值数组转换为对象此方法为null输入数组返回null
    
    Parameters:
    
    array - boolean数组
    
    Returns:
    
    返回boolean数组, 如果输入为null则为null
  - addAll
```
public static <T> T[] addAll(T[]... arrays)
```
    将给定数组的所有元素添加到新数组中忽略null数组,新数组包含arrays的所有元素
```
 ArrayKit.addAll(null, null)     = null
 ArrayKit.addAll(array1, null)   = cloned copy of array1
 ArrayKit.addAll(null, array2)   = cloned copy of array2
 ArrayKit.addAll([], [])         = []
 ArrayKit.addAll(["a", "b", "c"], ["1", "2", "3"]) = ["a", "b", "c", "1", "2", "3"]
 
```
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    arrays - 数组集合
    
    Returns:
    
    合并后的新数组 T[]
  - addAll
```
public static byte[] addAll(byte[]... arrays)
```
    将给定数组的所有元素添加到新数组中忽略null数组,新数组包含arrays的所有元素
```
 ArrayKit.addAll(array1, null)   = cloned copy of array1
 ArrayKit.addAll(null, array2)   = cloned copy of array2
 ArrayKit.addAll([], [])         = []
 
```
    Parameters:
    
    arrays - 数组集合
    
    Returns:
    
    合并后的新数组 byte[]
  - addAll
```
public static boolean[] addAll(boolean[]... arrays)
```
    将给定数组的所有元素添加到新数组中忽略null数组,新数组包含arrays的所有元素
```
 ArrayKit.addAll(array1, null)   = cloned copy of array1
 ArrayKit.addAll(null, array2)   = cloned copy of array2
 ArrayKit.addAll([], [])         = []
 
```
    Parameters:
    
    arrays - 数组集合
    
    Returns:
    
    合并后的新数组 boolean[]
  - addAll
```
public static char[] addAll(char[]... arrays)
```
    将给定数组的所有元素添加到新数组中忽略null数组,新数组包含arrays的所有元素
```
 ArrayKit.addAll(array1, null)   = cloned copy of array1
 ArrayKit.addAll(null, array2)   = cloned copy of array2
 ArrayKit.addAll([], [])         = []
 
```
    Parameters:
    
    arrays - 数组集合
    
    Returns:
    
    合并后的新数组 char[]
  - addAll
```
public static short[] addAll(short[]... arrays)
```
    将给定数组的所有元素添加到新数组中忽略null数组,新数组包含arrays的所有元素
```
 ArrayKit.addAll(array1, null)   = cloned copy of array1
 ArrayKit.addAll(null, array2)   = cloned copy of array2
 ArrayKit.addAll([], [])         = []
 
```
    Parameters:
    
    arrays - 数组集合
    
    Returns:
    
    合并后的新数组 short[]
  - addAll
```
public static int[] addAll(int[]... arrays)
```
    将给定数组的所有元素添加到新数组中忽略null数组,新数组包含arrays的所有元素
```
 ArrayKit.addAll(array1, null)   = cloned copy of array1
 ArrayKit.addAll(null, array2)   = cloned copy of array2
 ArrayKit.addAll([], [])         = []
 
```
    Parameters:
    
    arrays - 数组集合
    
    Returns:
    
    合并后的新数组 int[]
  - addAll
```
public static long[] addAll(long[]... arrays)
```
    将给定数组的所有元素添加到新数组中忽略null数组,新数组包含arrays的所有元素
```
 ArrayKit.addAll(array1, null)   = cloned copy of array1
 ArrayKit.addAll(null, array2)   = cloned copy of array2
 ArrayKit.addAll([], [])         = []
 
```
    Parameters:
    
    arrays - 数组集合
    
    Returns:
    
    合并后的新数组 long[]
  - addAll
```
public static float[] addAll(float[]... arrays)
```
    将给定数组的所有元素添加到新数组中忽略null数组,新数组包含arrays的所有元素
```
 ArrayKit.addAll(array1, null)   = cloned copy of array1
 ArrayKit.addAll(null, array2)   = cloned copy of array2
 ArrayKit.addAll([], [])         = []
 
```
    Parameters:
    
    arrays - 数组集合
    
    Returns:
    
    合并后的新数组 float[]
  - addAll
```
public static double[] addAll(double[]... arrays)
```
    将给定数组的所有元素添加到新数组中忽略null数组,新数组包含arrays的所有元素
```
 ArrayKit.addAll(array1, null)   = cloned copy of array1
 ArrayKit.addAll(null, array2)   = cloned copy of array2
 ArrayKit.addAll([], [])         = []
 
```
    Parameters:
    
    arrays - 数组集合
    
    Returns:
    
    合并后的新数组 double[]
  - add
```
public static <T> T[] add(T[] array,
                          T element)
```
    复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null，则返回一个新元素数组，其组件类型与元素相同，除非元素本身为空，否则返回类型为Object[]
```
 ArrayKit.add(null, null)      = IllegalArgumentException
 ArrayKit.add(null, "a")       = ["a"]
 ArrayKit.add(["a"], null)     = ["a", null]
 ArrayKit.add(["a"], "b")      = ["a", "b"]
 ArrayKit.add(["a", "b"], "c") = ["a", "b", "c"]
 
```
    Type Parameters:
    
    T - 数组的组件类型
    
    Parameters:
    
    array - 要“add”元素的数组可以是null
    
    element - 要添加的对象可以是null
    
    Returns:
    
    包含现有元素的新数组加上返回的新元素数组类型将是输入数组的类型(除非为空)，在这种情况下，它将具有与元素相同的类型。如果两者都为空，则抛出IllegalArgumentException
    
    Throws:
    
    IllegalArgumentException - 如果两个参数都为空
  - add
```
public static boolean[] add(boolean[] array,
                            boolean element)
```
    复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null，则返回一个新元素数组，其组件类型与元素相同.
```
 ArrayKit.add(null, true)          = [true]
 ArrayKit.add([true], false)       = [true, false]
 ArrayKit.add([true, false], true) = [true, false, true]
 
```
    Parameters:
    
    array - 要复制并添加元素的数组可以是null
    
    element - 要在新数组的最后一个索引处添加的对象
    
    Returns:
    
    包含现有元素和新元素的新数组
  - add
```
public static byte[] add(byte[] array,
                         byte element)
```
    复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null，则返回一个新元素数组，其组件类型与元素相同.
```
 ArrayKit.add(null, 0)   = [0]
 ArrayKit.add([1], 0)    = [1, 0]
 ArrayKit.add([1, 0], 1) = [1, 0, 1]
 
```
    Parameters:
    
    array - 要复制并添加元素的数组可以是null
    
    element - 要在新数组的最后一个索引处添加的对象
    
    Returns:
    
    包含现有元素和新元素的新数组
  - add
```
public static char[] add(char[] array,
                         char element)
```
    复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null，则返回一个新元素数组，其组件类型与元素相同.
```
 ArrayKit.add(null, '0')       = ['0']
 ArrayKit.add(['1'], '0')      = ['1', '0']
 ArrayKit.add(['1', '0'], '1') = ['1', '0', '1']
 
```
    Parameters:
    
    array - 要复制并添加元素的数组可以是null
    
    element - 要在新数组的最后一个索引处添加的对象
    
    Returns:
    
    包含现有元素和新元素的新数组
  - add
```
public static double[] add(double[] array,
                           double element)
```
    复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null，则返回一个新元素数组，其组件类型与元素相同.
```
 ArrayKit.add(null, 0)   = [0]
 ArrayKit.add([1], 0)    = [1, 0]
 ArrayKit.add([1, 0], 1) = [1, 0, 1]
 
```
    Parameters:
    
    array - 要复制并添加元素的数组可以是null
    
    element - 要在新数组的最后一个索引处添加的对象
    
    Returns:
    
    包含现有元素和新元素的新数组
  - add
```
public static float[] add(float[] array,
                          float element)
```
    复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null，则返回一个新元素数组，其组件类型与元素相同.
```
 ArrayKit.add(null, 0)   = [0]
 ArrayKit.add([1], 0)    = [1, 0]
 ArrayKit.add([1, 0], 1) = [1, 0, 1]
 
```
    Parameters:
    
    array - 要复制并添加元素的数组可以是null
    
    element - 要在新数组的最后一个索引处添加的对象
    
    Returns:
    
    包含现有元素和新元素的新数组
  - add
```
public static int[] add(int[] array,
                        int element)
```
    复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null，则返回一个新元素数组，其组件类型与元素相同.
```
 ArrayKit.add(null, 0)   = [0]
 ArrayKit.add([1], 0)    = [1, 0]
 ArrayKit.add([1, 0], 1) = [1, 0, 1]
 
```
    Parameters:
    
    array - 要复制并添加元素的数组可以是null
    
    element - 要在新数组的最后一个索引处添加的对象
    
    Returns:
    
    包含现有元素和新元素的新数组
  - add
```
public static long[] add(long[] array,
                         long element)
```
    复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null，则返回一个新元素数组，其组件类型与元素相同.
```
 ArrayKit.add(null, 0)   = [0]
 ArrayKit.add([1], 0)    = [1, 0]
 ArrayKit.add([1, 0], 1) = [1, 0, 1]
 
```
    Parameters:
    
    array - 要复制并添加元素的数组可以是null
    
    element - 要在新数组的最后一个索引处添加的对象
    
    Returns:
    
    包含现有元素和新元素的新数组
  - add
```
public static short[] add(short[] array,
                          short element)
```
    复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null，则返回一个新元素数组，其组件类型与元素相同.
```
 ArrayKit.add(null, 0)   = [0]
 ArrayKit.add([1], 0)    = [1, 0]
 ArrayKit.add([1, 0], 1) = [1, 0, 1]
 
```
    Parameters:
    
    array - 要复制并添加元素的数组可以是null
    
    element - 要在新数组的最后一个索引处添加的对象
    
    Returns:
    
    包含现有元素和新元素的新数组
  - add
```
public static <T> T[] add(T[] array,
                          int index,
                          T element)
```
    复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null，则返回一个新元素数组，其组件类型与元素相同.
```
 ArrayKit.add(null, 0, null)      = IllegalArgumentException
 ArrayKit.add(null, 0, "a")       = ["a"]
 ArrayKit.add(["a"], 1, null)     = ["a", null]
 ArrayKit.add(["a"], 1, "b")      = ["a", "b"]
 ArrayKit.add(["a", "b"], 3, "c") = ["a", "b", "c"]
 
```
    Type Parameters:
    
    T - 数组的组件类型
    
    Parameters:
    
    array - 要复制并添加元素的数组可以是null
    
    index - 新对象的位置
    
    element - 要在新数组的最后一个索引处添加的对象
    
    Returns:
    
    包含现有元素和新元素的新数组
  - add
```
public static boolean[] add(boolean[] array,
                            int index,
                            boolean element)
```
    复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null，则返回一个新元素数组，其组件类型与元素相同.
```
 ArrayKit.add(null, 0, true)          = [true]
 ArrayKit.add([true], 0, false)       = [false, true]
 ArrayKit.add([false], 1, true)       = [false, true]
 ArrayKit.add([true, false], 1, true) = [true, true, false]
 
```
    Parameters:
    
    array - 要复制并添加元素的数组可以是null
    
    index - 新对象的位置
    
    element - 要在新数组的最后一个索引处添加的对象
    
    Returns:
    
    包含现有元素和新元素的新数组
  - add
```
public static char[] add(char[] array,
                         int index,
                         char element)
```
    复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null，则返回一个新元素数组，其组件类型与元素相同.
```
 ArrayKit.add(null, 0, 'a')            = ['a']
 ArrayKit.add(['a'], 0, 'b')           = ['b', 'a']
 ArrayKit.add(['a', 'b'], 0, 'c')      = ['c', 'a', 'b']
 ArrayKit.add(['a', 'b'], 1, 'k')      = ['a', 'k', 'b']
 ArrayKit.add(['a', 'b', 'c'], 1, 't') = ['a', 't', 'b', 'c']
 
```
    Parameters:
    
    array - 要复制并添加元素的数组可以是null
    
    index - 新对象的位置
    
    element - 要在新数组的最后一个索引处添加的对象
    
    Returns:
    
    包含现有元素和新元素的新数组
  - add
```
public static byte[] add(byte[] array,
                         int index,
                         byte element)
```
    复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null，则返回一个新元素数组，其组件类型与元素相同.
```
 ArrayKit.add([1], 0, 2)         = [2, 1]
 ArrayKit.add([2, 6], 2, 3)      = [2, 6, 3]
 ArrayKit.add([2, 6], 0, 1)      = [1, 2, 6]
 ArrayKit.add([2, 6, 3], 2, 1)   = [2, 6, 1, 3]
 
```
    Parameters:
    
    array - 要复制并添加元素的数组可以是null
    
    index - 新对象的位置
    
    element - 要在新数组的最后一个索引处添加的对象
    
    Returns:
    
    包含现有元素和新元素的新数组
  - add
```
public static short[] add(short[] array,
                          int index,
                          short element)
```
    复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null，则返回一个新元素数组，其组件类型与元素相同.
```
 ArrayKit.add([1], 0, 2)         = [2, 1]
 ArrayKit.add([2, 6], 2, 10)     = [2, 6, 10]
 ArrayKit.add([2, 6], 0, -4)     = [-4, 2, 6]
 ArrayKit.add([2, 6, 3], 2, 1)   = [2, 6, 1, 3]
 
```
    Parameters:
    
    array - 要复制并添加元素的数组可以是null
    
    index - 新对象的位置
    
    element - 要在新数组的最后一个索引处添加的对象
    
    Returns:
    
    包含现有元素和新元素的新数组
  - add
```
public static int[] add(int[] array,
                        int index,
                        int element)
```
    复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null，则返回一个新元素数组，其组件类型与元素相同.
```
 ArrayKit.add([1], 0, 2)         = [2, 1]
 ArrayKit.add([2, 6], 2, 10)     = [2, 6, 10]
 ArrayKit.add([2, 6], 0, -4)     = [-4, 2, 6]
 ArrayKit.add([2, 6, 3], 2, 1)   = [2, 6, 1, 3]
 
```
    Parameters:
    
    array - 要复制并添加元素的数组可以是null
    
    index - 新对象的位置
    
    element - 要在新数组的最后一个索引处添加的对象
    
    Returns:
    
    包含现有元素和新元素的新数组
  - add
```
public static long[] add(long[] array,
                         int index,
                         long element)
```
    复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null，则返回一个新元素数组，其组件类型与元素相同.
```
 ArrayKit.add([1L], 0, 2L)           = [2L, 1L]
 ArrayKit.add([2L, 6L], 2, 10L)      = [2L, 6L, 10L]
 ArrayKit.add([2L, 6L], 0, -4L)      = [-4L, 2L, 6L]
 ArrayKit.add([2L, 6L, 3L], 2, 1L)   = [2L, 6L, 1L, 3L]
 
```
    Parameters:
    
    array - 要复制并添加元素的数组可以是null
    
    index - 新对象的位置
    
    element - 要在新数组的最后一个索引处添加的对象
    
    Returns:
    
    包含现有元素和新元素的新数组
  - add
```
public static float[] add(float[] array,
                          int index,
                          float element)
```
    复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null，则返回一个新元素数组，其组件类型与元素相同.
```
 ArrayKit.add([1.1f], 0, 2.2f)               = [2.2f, 1.1f]
 ArrayKit.add([2.3f, 6.4f], 2, 10.5f)        = [2.3f, 6.4f, 10.5f]
 ArrayKit.add([2.6f, 6.7f], 0, -4.8f)        = [-4.8f, 2.6f, 6.7f]
 ArrayKit.add([2.9f, 6.0f, 0.3f], 2, 1.0f)   = [2.9f, 6.0f, 1.0f, 0.3f]
 
```
    Parameters:
    
    array - 要复制并添加元素的数组可以是null
    
    index - 新对象的位置
    
    element - 要在新数组的最后一个索引处添加的对象
    
    Returns:
    
    包含现有元素和新元素的新数组
  - add
```
public static double[] add(double[] array,
                           int index,
                           double element)
```
    复制给定数组并在新数组的末尾添加给定元素. 新数组的组件类型与输入数组的组件类型相同. 如果输入数组是null，则返回一个新元素数组，其组件类型与元素相同.
```
 ArrayKit.add([1.1], 0, 2.2)              = [2.2, 1.1]
 ArrayKit.add([2.3, 6.4], 2, 10.5)        = [2.3, 6.4, 10.5]
 ArrayKit.add([2.6, 6.7], 0, -4.8)        = [-4.8, 2.6, 6.7]
 ArrayKit.add([2.9, 6.0, 0.3], 2, 1.0)    = [2.9, 6.0, 1.0, 0.3]
 
```
    Parameters:
    
    array - 要复制并添加元素的数组可以是null
    
    index - 新对象的位置
    
    element - 要在新数组的最后一个索引处添加的对象
    
    Returns:
    
    包含现有元素和新元素的新数组
  - remove
```
public static <T> T[] remove(T[] array)
```
    去重数组中的元素，去重后生成新的数组，原数组不变此方法通过LinkedHashSet 去重
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    去重后的数组
  - remove
```
public static <T> T[] remove(T[] array,
                             int index)
```
    从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引
```
 ArrayKit.remove(["a"], 0)           = []
 ArrayKit.remove(["a", "b"], 0)      = ["b"]
 ArrayKit.remove(["a", "b"], 1)      = ["a"]
 ArrayKit.remove(["a", "b", "c"], 1) = ["a", "c"]
 
```
    Type Parameters:
    
    T - 数组的组件类型
    
    Parameters:
    
    array - 要从中删除的元素
    
    index - 要删除的元素的位置
    
    Returns:
    
    一个新数组，包含指定位置的元素以外的现有元素.
  - removeElement
```
public static <T> T[] removeElement(T[] array,
                                    Object element)
```
    从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引
```
 ArrayKit.removeElement(null, "a")            = null
 ArrayKit.removeElement([], "a")              = []
 ArrayKit.removeElement(["a"], "b")           = ["a"]
 ArrayKit.removeElement(["a", "b"], "a")      = ["b"]
 ArrayKit.removeElement(["a", "b", "a"], "a") = ["b", "a"]
 
```
    Type Parameters:
    
    T - 数组的组件类型
    
    Parameters:
    
    array - 要复制并添加元素的数组可以是null
    
    element - 要在新数组的最后一个索引处添加的对象
    
    Returns:
    
    一个新数组，包含指定位置的元素以外的现有元素.
  - remove
```
public static boolean[] remove(boolean[] array,
                               int index)
```
    从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引
```
 ArrayKit.remove([true], 0)              = []
 ArrayKit.remove([true, false], 0)       = [false]
 ArrayKit.remove([true, false], 1)       = [true]
 ArrayKit.remove([true, true, false], 1) = [true, false]
 
```
    Parameters:
    
    array - 要从中删除的元素
    
    index - 要删除的元素
    
    Returns:
    
    一个新数组，包含指定位置的元素以外的现有元素.
  - removeElement
```
public static boolean[] removeElement(boolean[] array,
                                      boolean element)
```
    从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引
```
 ArrayKit.removeElement(null, true)                = null
 ArrayKit.removeElement([], true)                  = []
 ArrayKit.removeElement([true], false)             = [true]
 ArrayKit.removeElement([true, false], false)      = [true]
 ArrayKit.removeElement([true, false, true], true) = [false, true]
 
```
    Parameters:
    
    array - 要从中移除元素的数组
    
    element - 要删除的元素
    
    Returns:
    
    一个新数组，包含指定位置的元素以外的现有元素.
  - remove
```
public static byte[] remove(byte[] array,
                            int index)
```
    从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引
```
 ArrayKit.remove([1], 0)          = []
 ArrayKit.remove([1, 0], 0)       = [0]
 ArrayKit.remove([1, 0], 1)       = [1]
 ArrayKit.remove([1, 0, 1], 1)    = [1, 1]
 
```
    Parameters:
    
    array - 要从中移除元素的数组
    
    index - 要删除的元素的位置
    
    Returns:
    
    一个新数组，包含指定位置的元素以外的现有元素.
  - removeElement
```
public static byte[] removeElement(byte[] array,
                                   byte element)
```
    从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引
```
 ArrayKit.removeElement(null, 1)        = null
 ArrayKit.removeElement([], 1)          = []
 ArrayKit.removeElement([1], 0)         = [1]
 ArrayKit.removeElement([1, 0], 0)      = [1]
 ArrayKit.removeElement([1, 0, 1], 1)   = [0, 1]
 
```
    Parameters:
    
    array - 要从中移除元素的数组
    
    element - 要删除的元素
    
    Returns:
    
    一个新数组，包含指定位置的元素以外的现有元素.
  - remove
```
public static char[] remove(char[] array,
                            int index)
```
    从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引
```
 ArrayKit.remove(['a'], 0)           = []
 ArrayKit.remove(['a', 'b'], 0)      = ['b']
 ArrayKit.remove(['a', 'b'], 1)      = ['a']
 ArrayKit.remove(['a', 'b', 'c'], 1) = ['a', 'c']
 
```
    Parameters:
    
    array - 要从中移除元素的数组
    
    index - 要删除的元素的位置
    
    Returns:
    
    一个新数组，包含指定位置的元素以外的现有元素..
  - removeElement
```
public static char[] removeElement(char[] array,
                                   char element)
```
    从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引
```
 ArrayKit.removeElement(null, 'a')            = null
 ArrayKit.removeElement([], 'a')              = []
 ArrayKit.removeElement(['a'], 'b')           = ['a']
 ArrayKit.removeElement(['a', 'b'], 'a')      = ['b']
 ArrayKit.removeElement(['a', 'b', 'a'], 'a') = ['b', 'a']
 
```
    Parameters:
    
    array - 要从中移除元素的数组
    
    element - 要删除的元素
    
    Returns:
    
    一个新数组，包含指定位置的元素以外的现有元素.
  - remove
```
public static double[] remove(double[] array,
                              int index)
```
    从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引
```
 ArrayKit.remove([1.1], 0)           = []
 ArrayKit.remove([2.5, 6.0], 0)      = [6.0]
 ArrayKit.remove([2.5, 6.0], 1)      = [2.5]
 ArrayKit.remove([2.5, 6.0, 3.8], 1) = [2.5, 3.8]
 
```
    Parameters:
    
    array - 要从中移除元素的数组
    
    index - 要删除的元素的位置
    
    Returns:
    
    一个新数组，包含指定位置的元素以外的现有元素.
  - removeElement
```
public static double[] removeElement(double[] array,
                                     double element)
```
    从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引
```
 ArrayKit.removeElement(null, 1.1)            = null
 ArrayKit.removeElement([], 1.1)              = []
 ArrayKit.removeElement([1.1], 1.2)           = [1.1]
 ArrayKit.removeElement([1.1, 2.3], 1.1)      = [2.3]
 ArrayKit.removeElement([1.1, 2.3, 1.1], 1.1) = [2.3, 1.1]
 
```
    Parameters:
    
    array - 要从中移除元素的数组
    
    element - 要删除的元素
    
    Returns:
    
    一个新数组，包含指定位置的元素以外的现有元素.
  - remove
```
public static float[] remove(float[] array,
                             int index)
```
    从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引
```
 ArrayKit.remove([1.1], 0)           = []
 ArrayKit.remove([2.5, 6.0], 0)      = [6.0]
 ArrayKit.remove([2.5, 6.0], 1)      = [2.5]
 ArrayKit.remove([2.5, 6.0, 3.8], 1) = [2.5, 3.8]
 
```
    Parameters:
    
    array - 要从中移除元素的数组
    
    index - 要删除的元素的位置
    
    Returns:
    
    一个新数组，包含指定位置的元素以外的现有元素.
  - removeElement
```
public static float[] removeElement(float[] array,
                                    float element)
```
    从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引
```
 ArrayKit.removeElement(null, 1.1)            = null
 ArrayKit.removeElement([], 1.1)              = []
 ArrayKit.removeElement([1.1], 1.2)           = [1.1]
 ArrayKit.removeElement([1.1, 2.3], 1.1)      = [2.3]
 ArrayKit.removeElement([1.1, 2.3, 1.1], 1.1) = [2.3, 1.1]
 
```
    Parameters:
    
    array - 要从中移除元素的数组
    
    element - 要删除的元素
    
    Returns:
    
    一个新数组，包含指定位置的元素以外的现有元素.
  - remove
```
public static int[] remove(int[] array,
                           int index)
```
    从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引
```
 ArrayKit.remove([1], 0)         = []
 ArrayKit.remove([2, 6], 0)      = [6]
 ArrayKit.remove([2, 6], 1)      = [2]
 ArrayKit.remove([2, 6, 3], 1)   = [2, 3]
 
```
    Parameters:
    
    array - 要从中移除元素的数组
    
    index - 要删除的元素的位置
    
    Returns:
    
    一个新数组，包含指定位置的元素以外的现有元素.
  - removeElement
```
public static int[] removeElement(int[] array,
                                  int element)
```
    从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引
```
 ArrayKit.removeElement(null, 1)      = null
 ArrayKit.removeElement([], 1)        = []
 ArrayKit.removeElement([1], 2)       = [1]
 ArrayKit.removeElement([1, 3], 1)    = [3]
 ArrayKit.removeElement([1, 3, 1], 1) = [3, 1]
 
```
    Parameters:
    
    array - 要从中移除元素的数组
    
    element - 要删除的元素
    
    Returns:
    
    一个新数组，包含指定位置的元素以外的现有元素.
  - remove
```
public static long[] remove(long[] array,
                            int index)
```
    从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引
```
 ArrayKit.remove([1], 0)         = []
 ArrayKit.remove([2, 6], 0)      = [6]
 ArrayKit.remove([2, 6], 1)      = [2]
 ArrayKit.remove([2, 6, 3], 1)   = [2, 3]
 
```
    Parameters:
    
    array - 要从中移除元素的数组
    
    index - 要删除的元素的位置
    
    Returns:
    
    一个新数组，包含指定位置的元素以外的现有元素.
  - removeElement
```
public static long[] removeElement(long[] array,
                                   long element)
```
    从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引
```
 ArrayKit.removeElement(null, 1)      = null
 ArrayKit.removeElement([], 1)        = []
 ArrayKit.removeElement([1], 2)       = [1]
 ArrayKit.removeElement([1, 3], 1)    = [3]
 ArrayKit.removeElement([1, 3, 1], 1) = [3, 1]
 
```
    Parameters:
    
    array - 要从中移除元素的数组
    
    element - 要删除的元素
    
    Returns:
    
    一个新数组，包含指定位置的元素以外的现有元素.
  - remove
```
public static short[] remove(short[] array,
                             int index)
```
    从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引
```
 ArrayKit.remove([1], 0)         = []
 ArrayKit.remove([2, 6], 0)      = [6]
 ArrayKit.remove([2, 6], 1)      = [2]
 ArrayKit.remove([2, 6, 3], 1)   = [2, 3]
 
```
    Parameters:
    
    array - 要从中移除元素的数组
    
    index - 要删除的元素的位置
    
    Returns:
    
    一个新数组，包含指定位置的元素以外的现有元素.
  - removeElement
```
public static short[] removeElement(short[] array,
                                    short element)
```
    从指定数组中移除指定位置的元素。所有后续元素都向左移动(从它们的索引中减去1) 此方法返回一个新数组，除了指定位置上的元素外，该数组具有与输入数组相同的元素如果是null，则会抛出IndexOutOfBoundsException，无法指定有效的索引
```
 ArrayKit.removeElement(null, 1)      = null
 ArrayKit.removeElement([], 1)        = []
 ArrayKit.removeElement([1], 2)       = [1]
 ArrayKit.removeElement([1, 3], 1)    = [3]
 ArrayKit.removeElement([1, 3, 1], 1) = [3, 1]
 
```
    Parameters:
    
    array - 要从中移除元素的数组
    
    element - 要删除的元素
    
    Returns:
    
    一个新数组，包含指定位置的元素以外的现有元素.
  - removeAll
```
public static <T> T[] removeAll(T[] array,
                                int... indices)
```
    从指定数组中移除指定位置的元素。所有剩余的元素都向左移动返回数组的组件类型始终与输入数组的组件类型相同此方法返回一个新数组，该数组具有与输入数组相同的元素
```
 ArrayKit.removeAll(["a", "b", "c"], 0, 2) = ["b"]
 ArrayKit.removeAll(["a", "b", "c"], 1, 2) = ["a"]
 
```
    Type Parameters:
    
    T - 数组的组件类型
    
    Parameters:
    
    array - 要从中删除元素的数组可能不是null
    
    indices - 要删除的元素的位置
    
    Returns:
    
    一个新数组，包含指定位置之外的现有元素.
  - removeElements
```
public static <T> T[] removeElements(T[] array,
                                     T... values)
```
    从指定数组中移除指定数量*的指定元素。所有后续元素都左移对于指定的要删除的元素，其数量大于原始数组中包含的数量，除了删除现有的匹配项外，不会发生任何更改返回数组的组件类型始终与输入数组的组件类型相同.
```
 ArrayKit.removeElements(null, "a", "b")            = null
 ArrayKit.removeElements([], "a", "b")              = []
 ArrayKit.removeElements(["a"], "b", "c")           = ["a"]
 ArrayKit.removeElements(["a", "b"], "a", "c")      = ["b"]
 ArrayKit.removeElements(["a", "b", "a"], "a")      = ["b", "a"]
 ArrayKit.removeElements(["a", "b", "a"], "a", "a") = ["b"]
 
```
    Type Parameters:
    
    T - 数组的组件类型
    
    Parameters:
    
    array - 要从中删除元素的数组可能不是null
    
    values - 要删除的元素
    
    Returns:
    
    一个新数组，包含指定位置之外的现有元素.
  - removeAll
```
public static byte[] removeAll(byte[] array,
                               int... indices)
```
    从指定数组中移除指定位置的元素。所有剩余的元素都向左移动返回数组的组件类型始终与输入数组的组件类型相同此方法返回一个新数组，该数组具有与输入数组相同的元素
```
 ArrayKit.removeAll([1], 0)             = []
 ArrayKit.removeAll([2, 6], 0)          = [6]
 ArrayKit.removeAll([2, 6], 0, 1)       = []
 ArrayKit.removeAll([2, 6, 3], 1, 2)    = [2]
 ArrayKit.removeAll([2, 6, 3], 0, 2)    = [6]
 ArrayKit.removeAll([2, 6, 3], 0, 1, 2) = []
 
```
    Parameters:
    
    array - 要从中删除元素的数组可能不是null
    
    indices - 要删除的元素的位置
    
    Returns:
    
    一个新数组，包含指定位置之外的现有元素.
  - removeElements
```
public static byte[] removeElements(byte[] array,
                                    byte... values)
```
    从指定数组中移除指定数量*的指定元素。所有后续元素都左移对于指定的要删除的元素，其数量大于原始数组中包含的数量，除了删除现有的匹配项外，不会发生任何更改返回数组的组件类型始终与输入数组的组件类型相同.
```
 ArrayKit.removeElements(null, 1, 2)      = null
 ArrayKit.removeElements([], 1, 2)        = []
 ArrayKit.removeElements([1], 2, 3)       = [1]
 ArrayKit.removeElements([1, 3], 1, 2)    = [3]
 ArrayKit.removeElements([1, 3, 1], 1)    = [3, 1]
 ArrayKit.removeElements([1, 3, 1], 1, 1) = [3]
 
```
    Parameters:
    
    array - 要从中删除元素的数组可能不是null
    
    values - 要删除的元素
    
    Returns:
    
    一个新数组，包含指定位置之外的现有元素.
  - removeAll
```
public static short[] removeAll(short[] array,
                                int... indices)
```
    从指定数组中移除指定位置的元素。所有剩余的元素都向左移动返回数组的组件类型始终与输入数组的组件类型相同此方法返回一个新数组，该数组具有与输入数组相同的元素
```
 ArrayKit.removeAll([1], 0)             = []
 ArrayKit.removeAll([2, 6], 0)          = [6]
 ArrayKit.removeAll([2, 6], 0, 1)       = []
 ArrayKit.removeAll([2, 6, 3], 1, 2)    = [2]
 ArrayKit.removeAll([2, 6, 3], 0, 2)    = [6]
 ArrayKit.removeAll([2, 6, 3], 0, 1, 2) = []
 
```
    Parameters:
    
    array - 要从中删除元素的数组可能不是null
    
    indices - 要删除的元素的位置
    
    Returns:
    
    一个新数组，包含指定位置之外的现有元素.
  - removeElements
```
public static short[] removeElements(short[] array,
                                     short... values)
```
    从指定数组中移除指定数量*的指定元素。所有后续元素都左移对于指定的要删除的元素，其数量大于原始数组中包含的数量，除了删除现有的匹配项外，不会发生任何更改. 返回数组的组件类型始终与输入数组的组件类型相同.
```
 ArrayKit.removeElements(null, 1, 2)      = null
 ArrayKit.removeElements([], 1, 2)        = []
 ArrayKit.removeElements([1], 2, 3)       = [1]
 ArrayKit.removeElements([1, 3], 1, 2)    = [3]
 ArrayKit.removeElements([1, 3, 1], 1)    = [3, 1]
 ArrayKit.removeElements([1, 3, 1], 1, 1) = [3]
 
```
    Parameters:
    
    array - 要从中删除元素的数组可能不是null
    
    values - 要删除的元素
    
    Returns:
    
    一个新数组，包含指定位置之外的现有元素.
  - removeAll
```
public static int[] removeAll(int[] array,
                              int... indices)
```
    从指定数组中移除指定位置的元素。所有剩余的元素都向左移动返回数组的组件类型始终与输入数组的组件类型相同此方法返回一个新数组，该数组具有与输入数组相同的元素
```
 ArrayKit.removeAll([1], 0)             = []
 ArrayKit.removeAll([2, 6], 0)          = [6]
 ArrayKit.removeAll([2, 6], 0, 1)       = []
 ArrayKit.removeAll([2, 6, 3], 1, 2)    = [2]
 ArrayKit.removeAll([2, 6, 3], 0, 2)    = [6]
 ArrayKit.removeAll([2, 6, 3], 0, 1, 2) = []
 
```
    Parameters:
    
    array - 要从中删除元素的数组可能不是null
    
    indices - 要删除的元素的位置
    
    Returns:
    
    一个新数组，包含指定位置之外的现有元素.
  - removeElements
```
public static int[] removeElements(int[] array,
                                   int... values)
```
    从指定数组中移除指定数量*的指定元素。所有后续元素都左移. 对于指定的要删除的元素，其数量大于原始数组中包含的数量，除了删除现有的匹配项外，不会发生任何更改返回数组的组件类型始终与输入数组的组件类型相同
```
 ArrayKit.removeElements(null, 1, 2)      = null
 ArrayKit.removeElements([], 1, 2)        = []
 ArrayKit.removeElements([1], 2, 3)       = [1]
 ArrayKit.removeElements([1, 3], 1, 2)    = [3]
 ArrayKit.removeElements([1, 3, 1], 1)    = [3, 1]
 ArrayKit.removeElements([1, 3, 1], 1, 1) = [3]
 
```
    Parameters:
    
    array - 要从中删除元素的数组可能不是null
    
    values - 要删除的元素
    
    Returns:
    
    一个新数组，包含指定位置之外的现有元素.
  - removeAll
```
public static char[] removeAll(char[] array,
                               int... indices)
```
    从指定数组中移除指定位置的元素。所有剩余的元素都向左移动返回数组的组件类型始终与输入数组的组件类型相同此方法返回一个新数组，该数组具有与输入数组相同的元素
```
 ArrayKit.removeAll([1], 0)             = []
 ArrayKit.removeAll([2, 6], 0)          = [6]
 ArrayKit.removeAll([2, 6], 0, 1)       = []
 ArrayKit.removeAll([2, 6, 3], 1, 2)    = [2]
 ArrayKit.removeAll([2, 6, 3], 0, 2)    = [6]
 ArrayKit.removeAll([2, 6, 3], 0, 1, 2) = []
 
```
    Parameters:
    
    array - 要从中删除元素的数组可能不是null
    
    indices - 要删除的元素的位置
    
    Returns:
    
    一个新数组，包含指定位置之外的现有元素.
  - removeElements
```
public static char[] removeElements(char[] array,
                                    char... values)
```
    从指定数组中移除指定数量*的指定元素。所有后续元素都左移对于指定的要删除的元素，其数量大于原始数组中包含的数量，除了删除现有的匹配项外，不会发生任何更改. 返回数组的组件类型始终与输入数组的组件类型相同.
```
 ArrayKit.removeElements(null, 1, 2)      = null
 ArrayKit.removeElements([], 1, 2)        = []
 ArrayKit.removeElements([1], 2, 3)       = [1]
 ArrayKit.removeElements([1, 3], 1, 2)    = [3]
 ArrayKit.removeElements([1, 3, 1], 1)    = [3, 1]
 ArrayKit.removeElements([1, 3, 1], 1, 1) = [3]
 
```
    Parameters:
    
    array - 要从中删除元素的数组可能不是null
    
    values - 要删除的元素
    
    Returns:
    
    一个新数组，包含指定位置之外的现有元素.
  - removeAll
```
public static long[] removeAll(long[] array,
                               int... indices)
```
    从指定数组中移除指定位置的元素。所有剩余的元素都向左移动返回数组的组件类型始终与输入数组的组件类型相同此方法返回一个新数组，该数组具有与输入数组相同的元素
```
 ArrayKit.removeAll([1], 0)             = []
 ArrayKit.removeAll([2, 6], 0)          = [6]
 ArrayKit.removeAll([2, 6], 0, 1)       = []
 ArrayKit.removeAll([2, 6, 3], 1, 2)    = [2]
 ArrayKit.removeAll([2, 6, 3], 0, 2)    = [6]
 ArrayKit.removeAll([2, 6, 3], 0, 1, 2) = []
 
```
    Parameters:
    
    array - 要从中删除元素的数组可能不是null
    
    indices - 要删除的元素的位置
    
    Returns:
    
    一个新数组，包含指定位置之外的现有元素.
  - removeElements
```
public static long[] removeElements(long[] array,
                                    long... values)
```
    从指定数组中移除指定数量*的指定元素。所有后续元素都左移对于指定的要删除的元素，其数量大于原始数组中包含的数量，除了删除现有的匹配项外，不会发生任何更改返回数组的组件类型始终与输入数组的组件类型相同
```
 ArrayKit.removeElements(null, 1, 2)      = null
 ArrayKit.removeElements([], 1, 2)        = []
 ArrayKit.removeElements([1], 2, 3)       = [1]
 ArrayKit.removeElements([1, 3], 1, 2)    = [3]
 ArrayKit.removeElements([1, 3, 1], 1)    = [3, 1]
 ArrayKit.removeElements([1, 3, 1], 1, 1) = [3]
 
```
    Parameters:
    
    array - 要从中删除元素的数组可能不是null
    
    values - 要删除的元素
    
    Returns:
    
    一个新数组，包含指定位置之外的现有元素.
  - removeAll
```
public static float[] removeAll(float[] array,
                                int... indices)
```
    从指定数组中移除指定位置的元素。所有剩余的元素都向左移动返回数组的组件类型始终与输入数组的组件类型相同此方法返回一个新数组，该数组具有与输入数组相同的元素
```
 ArrayKit.removeAll([1], 0)             = []
 ArrayKit.removeAll([2, 6], 0)          = [6]
 ArrayKit.removeAll([2, 6], 0, 1)       = []
 ArrayKit.removeAll([2, 6, 3], 1, 2)    = [2]
 ArrayKit.removeAll([2, 6, 3], 0, 2)    = [6]
 ArrayKit.removeAll([2, 6, 3], 0, 1, 2) = []
 
```
    Parameters:
    
    array - 要从中删除元素的数组可能不是null
    
    indices - 要删除的元素的位置
    
    Returns:
    
    一个新数组，包含指定位置之外的现有元素.
  - removeElements
```
public static float[] removeElements(float[] array,
                                     float... values)
```
    从指定数组中移除指定数量*的指定元素。所有后续元素都左移对于指定的要删除的元素，其数量大于原始数组中包含的数量，除了删除现有的匹配项外，不会发生任何更改返回数组的组件类型始终与输入数组的组件类型相同
```
 ArrayKit.removeElements(null, 1, 2)      = null
 ArrayKit.removeElements([], 1, 2)        = []
 ArrayKit.removeElements([1], 2, 3)       = [1]
 ArrayKit.removeElements([1, 3], 1, 2)    = [3]
 ArrayKit.removeElements([1, 3, 1], 1)    = [3, 1]
 ArrayKit.removeElements([1, 3, 1], 1, 1) = [3]
 
```
    Parameters:
    
    array - 要从中删除元素的数组可能不是null
    
    values - 要删除的元素
    
    Returns:
    
    一个新数组，包含指定位置之外的现有元素.
  - removeAll
```
public static double[] removeAll(double[] array,
                                 int... indices)
```
    从指定数组中移除指定位置的元素。所有剩余的元素都向左移动返回数组的组件类型始终与输入数组的组件类型相同此方法返回一个新数组，该数组具有与输入数组相同的元素
```
 ArrayKit.removeAll([1], 0)             = []
 ArrayKit.removeAll([2, 6], 0)          = [6]
 ArrayKit.removeAll([2, 6], 0, 1)       = []
 ArrayKit.removeAll([2, 6, 3], 1, 2)    = [2]
 ArrayKit.removeAll([2, 6, 3], 0, 2)    = [6]
 ArrayKit.removeAll([2, 6, 3], 0, 1, 2) = []
 
```
    Parameters:
    
    array - 要从中删除元素的数组可能不是null
    
    indices - 要删除的元素的位置
    
    Returns:
    
    一个新数组，包含指定位置之外的现有元素.
  - removeElements
```
public static double[] removeElements(double[] array,
                                      double... values)
```
    从指定数组中移除指定数量*的指定元素。所有后续元素都左移对于指定的要删除的元素，其数量大于原始数组中包含的数量，除了删除现有的匹配项外，不会发生任何更改. 返回数组的组件类型始终与输入数组的组件类型相同.
```
 ArrayKit.removeElements(null, 1, 2)      = null
 ArrayKit.removeElements([], 1, 2)        = []
 ArrayKit.removeElements([1], 2, 3)       = [1]
 ArrayKit.removeElements([1, 3], 1, 2)    = [3]
 ArrayKit.removeElements([1, 3, 1], 1)    = [3, 1]
 ArrayKit.removeElements([1, 3, 1], 1, 1) = [3]
 
```
    Parameters:
    
    array - 要从中删除元素的数组可能不是null
    
    values - 要删除的元素
    
    Returns:
    
    一个新数组，包含指定位置之外的现有元素.
  - removeAll
```
public static boolean[] removeAll(boolean[] array,
                                  int... indices)
```
    从指定数组中移除指定位置的元素。所有剩余的元素都向左移动返回数组的组件类型始终与输入数组的组件类型相同此方法返回一个新数组，该数组具有与输入数组相同的元素
```
 ArrayKit.removeAll([true, false, true], 0, 2) = [false]
 ArrayKit.removeAll([true, false, true], 1, 2) = [true]
 
```
    Parameters:
    
    array - 要从中删除元素的数组可能不是null
    
    indices - 要删除的元素的位置
    
    Returns:
    
    一个新数组，包含指定位置之外的现有元素
  - removeElements
```
public static boolean[] removeElements(boolean[] array,
                                       boolean... values)
```
    从指定数组中移除指定数量*的指定元素。所有后续元素都左移对于指定的要删除的元素，其数量大于原始数组中包含的数量，除了删除现有的匹配项外，不会发生任何更改. 返回数组的组件类型始终与输入数组的组件类型相同.
```
 ArrayKit.removeElements(null, true, false)               = null
 ArrayKit.removeElements([], true, false)                 = []
 ArrayKit.removeElements([true], false, false)            = [true]
 ArrayKit.removeElements([true, false], true, true)       = [false]
 ArrayKit.removeElements([true, false, true], true)       = [false, true]
 ArrayKit.removeElements([true, false, true], true, true) = [false]
 
```
    Parameters:
    
    array - 要从中删除元素的数组可能不是null
    
    values - 要删除的元素
    
    Returns:
    
    一个新数组，包含指定位置之外的现有元素.
  - isSorted
```
public static <T extends Comparable<? super T>> boolean isSorted(T[] array)
```
    该方法检查提供的数组是否按照类的compareTo方法排序.
    
    Type Parameters:
    
    T - 要检查数组的数据类型，必须实现Comparable
    
    Parameters:
    
    array - 要检查的数组
    
    Returns:
    
    数组是否已排序
  - isSorted
```
public static <T> boolean isSorted(T[] array,
                                   Comparator<T> comparator)
```
    该方法检查提供的数组是否按照提供的Comparator排序.
    
    Type Parameters:
    
    T - 数组的数据类型
    
    Parameters:
    
    array - 要检查的数组
    
    comparator - 要比较的Comparator
    
    Returns:
    
    数组是否已排序
  - isSorted
```
public static boolean isSorted(int[] array)
```
    该方法检查提供的数组是否按照提供的Comparator排序.
    
    Parameters:
    
    array - 要检查的数组
    
    Returns:
    
    数组是否已排序
  - isSorted
```
public static boolean isSorted(long[] array)
```
    该方法检查提供的数组是否按照提供的Comparator排序.
    
    Parameters:
    
    array - 要检查的数组
    
    Returns:
    
    数组是否已排序
  - isSorted
```
public static boolean isSorted(short[] array)
```
    该方法检查提供的数组是否按照提供的Comparator排序.
    
    Parameters:
    
    array - 要检查的数组
    
    Returns:
    
    数组是否已排序
  - isSorted
```
public static boolean isSorted(double[] array)
```
    该方法检查提供的数组是否按照提供的Comparator排序.
    
    Parameters:
    
    array - 要检查的数组
    
    Returns:
    
    数组是否已排序
  - isSorted
```
public static boolean isSorted(float[] array)
```
    该方法检查提供的数组是否按照提供的Comparator排序.
    
    Parameters:
    
    array - 要检查的数组
    
    Returns:
    
    数组是否已排序
  - isSorted
```
public static boolean isSorted(byte[] array)
```
    该方法检查提供的数组是否按照提供的Comparator排序.
    
    Parameters:
    
    array - 要检查的数组
    
    Returns:
    
    数组是否已排序
  - isSorted
```
public static boolean isSorted(char[] array)
```
    该方法检查提供的数组是否按照提供的Comparator排序.
    
    Parameters:
    
    array - 要检查的数组
    
    Returns:
    
    数组是否已排序
  - isSorted
```
public static boolean isSorted(boolean[] array)
```
    该方法检查提供的数组是否按照提供的Comparator排序.
    
    Parameters:
    
    array - 要检查的数组
    
    Returns:
    
    数组是否已排序
  - removeAllOccurences
```
public static boolean[] removeAllOccurences(boolean[] array,
                                            boolean element)
```
    从指定的布尔数组中移除指定元素. 所有随后的元素都向左移动(从它们的索引中减去1). 如果数组不包含此类元素，则不会从数组中删除任何元素. 如果输入的数组是null，则返回的是null
    
    Parameters:
    
    element - 要删除的元素
    
    array - 输入数组
    
    Returns:
    
    一个新数组，包含除指定元素之外的现有元素.
  - removeAllOccurences
```
public static char[] removeAllOccurences(char[] array,
                                         char element)
```
    从指定的布尔数组中移除指定元素. 所有随后的元素都向左移动(从它们的索引中减去1). 如果数组不包含此类元素，则不会从数组中删除任何元素. 如果输入的数组是null，则返回的是null
    
    Parameters:
    
    element - 要删除的元素
    
    array - 输入数组
    
    Returns:
    
    一个新数组，包含除指定元素之外的现有元素.
  - removeAllOccurences
```
public static byte[] removeAllOccurences(byte[] array,
                                         byte element)
```
    从指定的布尔数组中移除指定元素. 所有随后的元素都向左移动(从它们的索引中减去1). 如果数组不包含此类元素，则不会从数组中删除任何元素. 如果输入的数组是null，则返回的是null
    
    Parameters:
    
    element - 要删除的元素
    
    array - 输入数组
    
    Returns:
    
    一个新数组，包含除指定元素之外的现有元素.
  - removeAllOccurences
```
public static short[] removeAllOccurences(short[] array,
                                          short element)
```
    从指定的布尔数组中移除指定元素. 所有随后的元素都向左移动(从它们的索引中减去1). 如果数组不包含此类元素，则不会从数组中删除任何元素. 如果输入的数组是null，则返回的是null
    
    Parameters:
    
    element - 要删除的元素
    
    array - 输入数组
    
    Returns:
    
    一个新数组，包含除指定元素之外的现有元素.
  - removeAllOccurences
```
public static int[] removeAllOccurences(int[] array,
                                        int element)
```
    从指定的布尔数组中移除指定元素. 所有随后的元素都向左移动(从它们的索引中减去1). 如果数组不包含此类元素，则不会从数组中删除任何元素. 如果输入的数组是null，则返回的是null
    
    Parameters:
    
    element - 要删除的元素
    
    array - 输入数组
    
    Returns:
    
    一个新数组，包含除指定元素之外的现有元素.
  - removeAllOccurences
```
public static long[] removeAllOccurences(long[] array,
                                         long element)
```
    从指定的布尔数组中移除指定元素. 所有随后的元素都向左移动(从它们的索引中减去1). 如果数组不包含此类元素，则不会从数组中删除任何元素. 如果输入的数组是null，则返回的是null
    
    Parameters:
    
    element - 要删除的元素
    
    array - 输入数组
    
    Returns:
    
    一个新数组，包含除指定元素之外的现有元素.
  - removeAllOccurences
```
public static float[] removeAllOccurences(float[] array,
                                          float element)
```
    从指定的布尔数组中移除指定元素. 所有随后的元素都向左移动(从它们的索引中减去1). 如果数组不包含此类元素，则不会从数组中删除任何元素. 如果输入的数组是null，则返回的是null
    
    Parameters:
    
    element - 要删除的元素
    
    array - 输入数组
    
    Returns:
    
    一个新数组，包含除指定元素之外的现有元素.
  - removeAllOccurences
```
public static double[] removeAllOccurences(double[] array,
                                           double element)
```
    从指定的布尔数组中移除指定元素. 所有随后的元素都向左移动(从它们的索引中减去1). 如果数组不包含此类元素，则不会从数组中删除任何元素. 如果输入的数组是null，则返回的是null
    
    Parameters:
    
    element - 要删除的元素
    
    array - 输入数组
    
    Returns:
    
    一个新数组，包含除指定元素之外的现有元素.
  - removeAllOccurences
```
public static <T> T[] removeAllOccurences(T[] array,
                                          T element)
```
    从指定的布尔数组中移除指定元素. 所有随后的元素都向左移动(从它们的索引中减去1). 如果数组不包含此类元素，则不会从数组中删除任何元素. 如果输入的数组是null，则返回的是null
    
    Type Parameters:
    
    T - 对象
    
    Parameters:
    
    element - 要删除的元素
    
    array - 输入数组
    
    Returns:
    
    一个新数组，包含除指定元素之外的现有元素.
  - toStringArray
```
public static String[] toStringArray(Object[] array)
```
    返回一个数组，该数组包含参数数组中每个元素的字符串表示形式. 该方法为一个null输入数组返回null.
    
    Parameters:
    
    array - 要处理的Object[] 可以为null
    
    Returns:
    
    String[]的大小与其元素的字符串表示形式相同，null如果是空数组输入
  - toStringArray
```
public static String[] toStringArray(Object[] array,
                                     String valueForNullElements)
```
    返回一个数组，该数组包含处理null元素的参数数组中每个元素的字符串表示形式该方法为一个null输入数组返回null
    
    Parameters:
    
    array - 要处理的Object[] 可以为null
    
    valueForNullElements - 找到null 时要插入的值
    
    Returns:
    
    (@ code String)阵列，如果没有阵列输入
  - insert
```
public static <T> T[] insert(T[] buffer,
                             int index,
                             T... newElements)
```
    将新元素插入到到已有数组中的某个位置添加新元素会生成一个新的数组，不影响原数组如果插入位置为为负数，从原数组从后向前计数，若大于原数组长度，则空白处用null填充
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    buffer - 已有数组
    
    index - 插入位置，此位置为对应此位置元素之前的空档
    
    newElements - 新元素
    
    Returns:
    
    新数组
  - insert
```
public static <T> Object insert(Object array,
                                int index,
                                T... newElements)
```
    将新元素插入到到已有数组中的某个位置添加新元素会生成一个新的数组，不影响原数组如果插入位置为为负数，从原数组从后向前计数，若大于原数组长度，则空白处用null填充
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 已有数组
    
    index - 插入位置，此位置为对应此位置元素之前的空档
    
    newElements - 新元素
    
    Returns:
    
    新数组
  - insert
```
public static boolean[] insert(int index,
                               boolean[] array,
                               boolean... values)
```
    将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时，它总是一个新的数组
```
 ArrayKit.insert(index, null, null)      = null
 ArrayKit.insert(index, array, null)     = cloned copy of 'array'
 ArrayKit.insert(index, null, values)    = null
 
```
    Parameters:
    
    index - 插入位置,此位置为对应此位置元素之前的空档
    
    array - 已有数组
    
    values - 要插入的新值可以是null
    
    Returns:
    
    新数组.
  - insert
```
public static byte[] insert(int index,
                            byte[] array,
                            byte... values)
```
    将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时，它总是一个新的数组
```
 ArrayKit.insert(index, null, null)      = null
 ArrayKit.insert(index, array, null)     = cloned copy of 'array'
 ArrayKit.insert(index, null, values)    = null
 
```
    Parameters:
    
    index - 插入位置,此位置为对应此位置元素之前的空档
    
    array - 已有数组
    
    values - 要插入的新值可以是null
    
    Returns:
    
    新数组.
  - insert
```
public static char[] insert(int index,
                            char[] array,
                            char... values)
```
    将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时，它总是一个新的数组
```
 ArrayKit.insert(index, null, null)      = null
 ArrayKit.insert(index, array, null)     = cloned copy of 'array'
 ArrayKit.insert(index, null, values)    = null
 
```
    Parameters:
    
    index - 插入位置,此位置为对应此位置元素之前的空档
    
    array - 已有数组
    
    values - 要插入的新值可以是null
    
    Returns:
    
    新数组.
  - insert
```
public static double[] insert(int index,
                              double[] array,
                              double... values)
```
    将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时，它总是一个新的数组
```
 ArrayKit.insert(index, null, null)      = null
 ArrayKit.insert(index, array, null)     = cloned copy of 'array'
 ArrayKit.insert(index, null, values)    = null
 
```
    Parameters:
    
    index - 插入位置,此位置为对应此位置元素之前的空档
    
    array - 已有数组
    
    values - 要插入的新值可以是null
    
    Returns:
    
    新数组.
  - insert
```
public static float[] insert(int index,
                             float[] array,
                             float... values)
```
    将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时，它总是一个新的数组
```
 ArrayKit.insert(index, null, null)      = null
 ArrayKit.insert(index, array, null)     = cloned copy of 'array'
 ArrayKit.insert(index, null, values)    = null
 
```
    Parameters:
    
    index - 插入位置,此位置为对应此位置元素之前的空档
    
    array - 已有数组
    
    values - 要插入的新值可以是null
    
    Returns:
    
    新数组.
  - insert
```
public static int[] insert(int index,
                           int[] array,
                           int... values)
```
    将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时，它总是一个新的数组
```
 ArrayKit.insert(index, null, null)      = null
 ArrayKit.insert(index, array, null)     = cloned copy of 'array'
 ArrayKit.insert(index, null, values)    = null
 
```
    Parameters:
    
    index - 插入位置,此位置为对应此位置元素之前的空档
    
    array - 已有数组
    
    values - 要插入的新值可以是null
    
    Returns:
    
    新数组.
  - insert
```
public static long[] insert(int index,
                            long[] array,
                            long... values)
```
    将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时，它总是一个新的数组
```
 ArrayKit.insert(index, null, null)      = null
 ArrayKit.insert(index, array, null)     = cloned copy of 'array'
 ArrayKit.insert(index, null, values)    = null
 
```
    Parameters:
    
    index - 插入位置,此位置为对应此位置元素之前的空档
    
    array - 已有数组
    
    values - 要插入的新值可以是null
    
    Returns:
    
    新数组.
  - insert
```
public static short[] insert(int index,
                             short[] array,
                             short... values)
```
    将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时，它总是一个新的数组
```
 ArrayKit.insert(index, null, null)      = null
 ArrayKit.insert(index, array, null)     = cloned copy of 'array'
 ArrayKit.insert(index, null, values)    = null
 
```
    Parameters:
    
    index - 插入位置,此位置为对应此位置元素之前的空档
    
    array - 已有数组
    
    values - 要插入的新值可以是null
    
    Returns:
    
    新数组.
  - insert
```
public static <T> T[] insert(int index,
                             T[] array,
                             T... values)
```
    将元素插入到给定索引处的数组中(从零开始) 当一个数组被返回时，它总是一个新的数组
```
 ArrayKit.insert(index, null, null)      = null
 ArrayKit.insert(index, array, null)     = cloned copy of 'array'
 ArrayKit.insert(index, null, values)    = null
 
```
    Type Parameters:
    
    T - 对象
    
    Parameters:
    
    index - 插入位置,此位置为对应此位置元素之前的空档
    
    array - 已有数组
    
    values - 要插入的新值可以是null
    
    Returns:
    
    新数组.
  - shuffle
```
public static void shuffle(Object[] array)
```
    使用Fisher-Yates算法随机遍历指定数组的元素.
    
    Parameters:
    
    array - 要洗牌的数组
  - shuffle
```
public static void shuffle(Object[] array,
                           Random random)
```
    使用Fisher-Yates算法随机遍历指定数组的元素.
    
    Parameters:
    
    array - 要洗牌的数组
    
    random - 用于排列元素的随机性的来源
  - shuffle
```
public static void shuffle(boolean[] array)
```
    使用Fisher-Yates算法随机遍历指定数组的元素.
    
    Parameters:
    
    array - 要洗牌的数组
  - shuffle
```
public static void shuffle(boolean[] array,
                           Random random)
```
    使用Fisher-Yates算法随机遍历指定数组的元素.
    
    Parameters:
    
    array - 要洗牌的数组
    
    random - 用于排列元素的随机性的来源
  - shuffle
```
public static void shuffle(byte[] array)
```
    使用Fisher-Yates算法随机遍历指定数组的元素.
    
    Parameters:
    
    array - 要洗牌的数组
  - shuffle
```
public static void shuffle(byte[] array,
                           Random random)
```
    使用Fisher-Yates算法随机遍历指定数组的元素.
    
    Parameters:
    
    array - 要洗牌的数组
    
    random - 用于排列元素的随机性的来源
  - shuffle
```
public static void shuffle(char[] array)
```
    使用Fisher-Yates算法随机遍历指定数组的元素.
    
    Parameters:
    
    array - 要洗牌的数组
  - shuffle
```
public static void shuffle(char[] array,
                           Random random)
```
    使用Fisher-Yates算法随机遍历指定数组的元素.
    
    Parameters:
    
    array - 要洗牌的数组
    
    random - 用于排列元素的随机性的来源
  - shuffle
```
public static void shuffle(short[] array)
```
    使用Fisher-Yates算法随机遍历指定数组的元素.
    
    Parameters:
    
    array - 要洗牌的数组
  - shuffle
```
public static void shuffle(short[] array,
                           Random random)
```
    使用Fisher-Yates算法随机遍历指定数组的元素.
    
    Parameters:
    
    array - 要洗牌的数组
    
    random - 用于排列元素的随机性的来源
  - shuffle
```
public static void shuffle(int[] array)
```
    使用Fisher-Yates算法随机遍历指定数组的元素.
    
    Parameters:
    
    array - 要洗牌的数组
  - shuffle
```
public static void shuffle(int[] array,
                           Random random)
```
    使用Fisher-Yates算法随机遍历指定数组的元素.
    
    Parameters:
    
    array - 要洗牌的数组
    
    random - 用于排列元素的随机性的来源
  - shuffle
```
public static void shuffle(long[] array)
```
    使用Fisher-Yates算法随机遍历指定数组的元素.
    
    Parameters:
    
    array - 要洗牌的数组
  - shuffle
```
public static void shuffle(long[] array,
                           Random random)
```
    使用Fisher-Yates算法随机遍历指定数组的元素.
    
    Parameters:
    
    array - 要洗牌的数组
    
    random - 用于排列元素的随机性的来源
  - shuffle
```
public static void shuffle(float[] array)
```
    使用Fisher-Yates算法随机遍历指定数组的元素.
    
    Parameters:
    
    array - 要洗牌的数组
  - shuffle
```
public static void shuffle(float[] array,
                           Random random)
```
    使用Fisher-Yates算法随机遍历指定数组的元素.
    
    Parameters:
    
    array - 要洗牌的数组
    
    random - 用于排列元素的随机性的来源
  - shuffle
```
public static void shuffle(double[] array)
```
    使用Fisher-Yates算法随机遍历指定数组的元素.
    
    Parameters:
    
    array - 要洗牌的数组
  - shuffle
```
public static void shuffle(double[] array,
                           Random random)
```
    使用Fisher-Yates算法随机遍历指定数组的元素.
    
    Parameters:
    
    array - 要洗牌的数组
    
    random - 用于排列元素的随机性的来源
  - newArray
```
public static <T> T[] newArray(Class<?> componentType,
                               int newSize)
```
    新建一个空数组
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    componentType - 元素类型
    
    newSize - 大小
    
    Returns:
    
    空数组
  - newArray
```
public static <T> T[] newArray(int newSize)
```
    新建一个空数组
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    newSize - 大小
    
    Returns:
    
    空数组
  - newArray
```
public static Object[] newArray(Class<?> type,
                                Object arrayObj)
```
    强转数组类型强制转换的前提是数组元素类型可被强制转换强制转换后会生成一个新数组
    
    Parameters:
    
    type - 数组类型或数组元素类型
    
    arrayObj - 原数组
    
    Returns:
    
    转换后的数组类型
    
    Throws:
    
    NullPointerException - 提供参数为空
    
    IllegalArgumentException - 参数arrayObj不是数组
  - getComponentType
```
public static Class<?> getComponentType(Object array)
```
    获取数组对象的元素类型
    
    Parameters:
    
    array - 数组对象
    
    Returns:
    
    元素类型
  - getComponentType
```
public static Class<?> getComponentType(Class<?> arrayClass)
```
    获取数组对象的元素类型
    
    Parameters:
    
    arrayClass - 数组类
    
    Returns:
    
    元素类型
  - getArrayType
```
public static Class<?> getArrayType(Class<?> componentType)
```
    根据数组元素类型,获取数组的类型方法是通过创建一个空数组从而获取其类型
    
    Parameters:
    
    componentType - 数组元素类型
    
    Returns:
    
    数组类型
  - append
```
public static <T> T[] append(T[] buffer,
                             T... newElements)
```
    将新元素添加到已有数组中添加新元素会生成一个新的数组，不影响原数组
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    buffer - 已有数组
    
    newElements - 新元素
    
    Returns:
    
    新数组
  - append
```
public static <T> Object append(Object array,
                                T... newElements)
```
    将新元素添加到已有数组中添加新元素会生成一个新的数组，不影响原数组
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 已有数组
    
    newElements - 新元素
    
    Returns:
    
    新数组
  - setOrAppend
```
public static <T> T[] setOrAppend(T[] buffer,
                                  int index,
                                  T value)
```
    将元素值设置为数组的某个位置,当给定的index大于数组长度,则追加
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    buffer - 已有数组
    
    index - 位置,大于长度追加,否则替换
    
    value - 新值
    
    Returns:
    
    新数组或原有数组
  - setOrAppend
```
public static Object setOrAppend(Object array,
                                 int index,
                                 Object value)
```
    将元素值设置为数组的某个位置,当给定的index大于数组长度,则追加
    
    Parameters:
    
    array - 已有数组
    
    index - 位置,大于长度追加,否则替换
    
    value - 新值
    
    Returns:
    
    新数组或原有数组
  - resize
```
public static <T> T[] resize(T[] buffer,
                             int newSize,
                             Class<?> componentType)
```
    生成一个新的重新设置大小的数组调整大小后拷贝原数组到新数组下扩大则占位前N个位置,缩小则截断
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    buffer - 原数组
    
    newSize - 新的数组大小
    
    componentType - 数组元素类型
    
    Returns:
    
    调整后的新数组
  - resize
```
public static <T> T[] resize(T[] buffer,
                             int newSize)
```
    生成一个新的重新设置大小的数组新数组的类型为原数组的类型,调整大小后拷贝原数组到新数组下扩大则占位前N个位置,缩小则截断
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    buffer - 原数组
    
    newSize - 新的数组大小
    
    Returns:
    
    调整后的新数组
  - resize
```
public static byte[] resize(byte[] bytes,
                            int newSize)
```
    生成一个新的重新设置大小的数组调整大小后拷贝原数组到新数组下扩大则占位前N个位置,其它位置补充0,缩小则截断
    
    Parameters:
    
    bytes - 原数组
    
    newSize - 新的数组大小
    
    Returns:
    
    调整后的新数组
  - copy
```
public static Object copy(Object src,
                          int srcPos,
                          Object dest,
                          int destPos,
                          int length)
```
    包装 System.arraycopy(Object, int, Object, int, int) 数组复制
    
    Parameters:
    
    src - 源数组
    
    srcPos - 源数组开始位置
    
    dest - 目标数组
    
    destPos - 目标数组开始位置
    
    length - 拷贝数组长度
    
    Returns:
    
    目标数组
  - copy
```
public static Object copy(Object src,
                          Object dest,
                          int length)
```
    包装 System.arraycopy(Object, int, Object, int, int) 数组复制,缘数组和目标数组都是从位置0开始复制
    
    Parameters:
    
    src - 源数组
    
    dest - 目标数组
    
    length - 拷贝数组长度
    
    Returns:
    
    目标数组
  - range
```
public static int[] range(int excludedEnd)
```
    生成一个从0开始的数字列表
    
    Parameters:
    
    excludedEnd - 结束的数字(不包含)
    
    Returns:
    
    数字列表
  - range
```
public static int[] range(int includedStart,
                          int excludedEnd)
```
    生成一个数字列表自动判定正序反序
    
    Parameters:
    
    includedStart - 开始的数字(包含)
    
    excludedEnd - 结束的数字(不包含)
    
    Returns:
    
    数字列表
  - range
```
public static int[] range(int includedStart,
                          int excludedEnd,
                          int step)
```
    生成一个数字列表自动判定正序反序
    
    Parameters:
    
    includedStart - 开始的数字(包含)
    
    excludedEnd - 结束的数字(不包含)
    
    step - 步进
    
    Returns:
    
    数字列表
  - unWrap
```
public static int[] unWrap(Integer... values)
```
    包装类数组转为原始类型数组
    
    Parameters:
    
    values - 包装类型数组
    
    Returns:
    
    原始类型数组
  - wrap
```
public static Long[] wrap(long... values)
```
    将原始类型数组包装为包装类型
    
    Parameters:
    
    values - 原始类型数组
    
    Returns:
    
    包装类型数组
  - unWrap
```
public static long[] unWrap(Long... values)
```
    包装类数组转为原始类型数组
    
    Parameters:
    
    values - 包装类型数组
    
    Returns:
    
    原始类型数组
  - wrap
```
public static Character[] wrap(char... values)
```
    将原始类型数组包装为包装类型
    
    Parameters:
    
    values - 原始类型数组
    
    Returns:
    
    包装类型数组
  - unWrap
```
public static char[] unWrap(Character... values)
```
    包装类数组转为原始类型数组
    
    Parameters:
    
    values - 包装类型数组
    
    Returns:
    
    原始类型数组
  - wrap
```
public static Byte[] wrap(byte... values)
```
    将原始类型数组包装为包装类型
    
    Parameters:
    
    values - 原始类型数组
    
    Returns:
    
    包装类型数组
  - unWrap
```
public static byte[] unWrap(Byte... values)
```
    包装类数组转为原始类型数组
    
    Parameters:
    
    values - 包装类型数组
    
    Returns:
    
    原始类型数组
  - wrap
```
public static Short[] wrap(short... values)
```
    将原始类型数组包装为包装类型
    
    Parameters:
    
    values - 原始类型数组
    
    Returns:
    
    包装类型数组
  - unWrap
```
public static short[] unWrap(Short... values)
```
    包装类数组转为原始类型数组
    
    Parameters:
    
    values - 包装类型数组
    
    Returns:
    
    原始类型数组
  - wrap
```
public static Float[] wrap(float... values)
```
    将原始类型数组包装为包装类型
    
    Parameters:
    
    values - 原始类型数组
    
    Returns:
    
    包装类型数组
  - unWrap
```
public static float[] unWrap(Float... values)
```
    包装类数组转为原始类型数组
    
    Parameters:
    
    values - 包装类型数组
    
    Returns:
    
    原始类型数组
  - wrap
```
public static Double[] wrap(double... values)
```
    将原始类型数组包装为包装类型
    
    Parameters:
    
    values - 原始类型数组
    
    Returns:
    
    包装类型数组
  - unWrap
```
public static double[] unWrap(Double... values)
```
    包装类数组转为原始类型数组
    
    Parameters:
    
    values - 包装类型数组
    
    Returns:
    
    原始类型数组
  - wrap
```
public static Boolean[] wrap(boolean... values)
```
    将原始类型数组包装为包装类型
    
    Parameters:
    
    values - 原始类型数组
    
    Returns:
    
    包装类型数组
  - unWrap
```
public static boolean[] unWrap(Boolean... values)
```
    包装类数组转为原始类型数组
    
    Parameters:
    
    values - 包装类型数组
    
    Returns:
    
    原始类型数组
  - wrap
```
public static Object[] wrap(Object obj)
```
    包装数组对象
    
    Parameters:
    
    obj - 对象,可以是对象数组或者基本类型数组
    
    Returns:
    
    包装类型数组或对象数组
    
    Throws:
    
    InstrumentException - 对象为非数组
  - get
```
public static <T> T get(Object array,
                        int index)
```
    获取数组对象中指定index的值,支持负数,例如-1表示倒数第一个值
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组对象
    
    index - 下标,支持负数
    
    Returns:
    
    值
  - get
```
public static <T> T[] get(Object array,
                          int... indexes)
```
    获取数组中指定多个下标元素值,组成新数组
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组
    
    indexes - 下标列表
    
    Returns:
    
    结果
  - sub
```
public static <T> T[] sub(T[] array,
                          int start,
                          int end)
```
    获取子数组
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组
    
    start - 开始位置(包括)
    
    end - 结束位置(不包括)
    
    Returns:
    
    新的数组
    
    See Also:
    
    Arrays.copyOfRange(Object[], int, int)
  - sub
```
public static byte[] sub(byte[] array,
                         int start,
                         int end)
```
    获取子数组
    
    Parameters:
    
    array - 数组
    
    start - 开始位置(包括)
    
    end - 结束位置(不包括)
    
    Returns:
    
    新的数组
    
    See Also:
    
    Arrays.copyOfRange(Object[], int, int)
  - sub
```
public static int[] sub(int[] array,
                        int start,
                        int end)
```
    获取子数组
    
    Parameters:
    
    array - 数组
    
    start - 开始位置(包括)
    
    end - 结束位置(不包括)
    
    Returns:
    
    新的数组
    
    See Also:
    
    Arrays.copyOfRange(Object[], int, int)
  - sub
```
public static long[] sub(long[] array,
                         int start,
                         int end)
```
    获取子数组
    
    Parameters:
    
    array - 数组
    
    start - 开始位置(包括)
    
    end - 结束位置(不包括)
    
    Returns:
    
    新的数组
    
    See Also:
    
    Arrays.copyOfRange(Object[], int, int)
  - sub
```
public static short[] sub(short[] array,
                          int start,
                          int end)
```
    获取子数组
    
    Parameters:
    
    array - 数组
    
    start - 开始位置(包括)
    
    end - 结束位置(不包括)
    
    Returns:
    
    新的数组
    
    See Also:
    
    Arrays.copyOfRange(Object[], int, int)
  - sub
```
public static char[] sub(char[] array,
                         int start,
                         int end)
```
    获取子数组
    
    Parameters:
    
    array - 数组
    
    start - 开始位置(包括)
    
    end - 结束位置(不包括)
    
    Returns:
    
    新的数组
    
    See Also:
    
    Arrays.copyOfRange(Object[], int, int)
  - sub
```
public static double[] sub(double[] array,
                           int start,
                           int end)
```
    获取子数组
    
    Parameters:
    
    array - 数组
    
    start - 开始位置(包括)
    
    end - 结束位置(不包括)
    
    Returns:
    
    新的数组
    
    See Also:
    
    Arrays.copyOfRange(Object[], int, int)
  - sub
```
public static float[] sub(float[] array,
                          int start,
                          int end)
```
    获取子数组
    
    Parameters:
    
    array - 数组
    
    start - 开始位置(包括)
    
    end - 结束位置(不包括)
    
    Returns:
    
    新的数组
    
    See Also:
    
    Arrays.copyOfRange(Object[], int, int)
  - sub
```
public static boolean[] sub(boolean[] array,
                            int start,
                            int end)
```
    获取子数组
    
    Parameters:
    
    array - 数组
    
    start - 开始位置(包括)
    
    end - 结束位置(不包括)
    
    Returns:
    
    新的数组
    
    See Also:
    
    Arrays.copyOfRange(Object[], int, int)
  - sub
```
public static Object[] sub(Object array,
                           int start,
                           int end)
```
    获取子数组
    
    Parameters:
    
    array - 数组
    
    start - 开始位置(包括)
    
    end - 结束位置(不包括)
    
    Returns:
    
    新的数组
  - sub
```
public static Object[] sub(Object array,
                           int start,
                           int end,
                           int step)
```
    获取子数组
    
    Parameters:
    
    array - 数组
    
    start - 开始位置(包括)
    
    end - 结束位置(不包括)
    
    step - 步进
    
    Returns:
    
    新的数组
  - join
```
public static <T> String join(T[] array,
                              CharSequence conjunction)
```
    以 conjunction 为分隔符将数组转换为字符串
    
    Type Parameters:
    
    T - 被处理的集合
    
    Parameters:
    
    array - 数组
    
    conjunction - 分隔符
    
    Returns:
    
    连接后的字符串
  - join
```
public static <T> String join(T[] array,
                              CharSequence conjunction,
                              String prefix,
                              String suffix)
```
    以 conjunction 为分隔符将数组转换为字符串
    
    Type Parameters:
    
    T - 被处理的集合
    
    Parameters:
    
    array - 数组
    
    conjunction - 分隔符
    
    prefix - 每个元素添加的前缀，null表示不添加
    
    suffix - 每个元素添加的后缀，null表示不添加
    
    Returns:
    
    连接后的字符串
  - join
```
public static <T> String join(T[] array,
                              CharSequence conjunction,
                              Editor<T> editor)
```
    以 conjunction 为分隔符将数组转换为字符串
    
    Type Parameters:
    
    T - 被处理的集合
    
    Parameters:
    
    array - 数组
    
    conjunction - 分隔符
    
    editor - 每个元素的编辑器，null表示不编辑
    
    Returns:
    
    连接后的字符串
  - join
```
public static String join(long[] array,
                          CharSequence conjunction)
```
    以 conjunction 为分隔符将数组转换为字符串
    
    Parameters:
    
    array - 数组
    
    conjunction - 分隔符
    
    Returns:
    
    连接后的字符串
  - join
```
public static String join(int[] array,
                          CharSequence conjunction)
```
    以 conjunction 为分隔符将数组转换为字符串
    
    Parameters:
    
    array - 数组
    
    conjunction - 分隔符
    
    Returns:
    
    连接后的字符串
  - join
```
public static String join(short[] array,
                          CharSequence conjunction)
```
    以 conjunction 为分隔符将数组转换为字符串
    
    Parameters:
    
    array - 数组
    
    conjunction - 分隔符
    
    Returns:
    
    连接后的字符串
  - join
```
public static String join(char[] array,
                          CharSequence conjunction)
```
    以 conjunction 为分隔符将数组转换为字符串
    
    Parameters:
    
    array - 数组
    
    conjunction - 分隔符
    
    Returns:
    
    连接后的字符串
  - join
```
public static String join(byte[] array,
                          CharSequence conjunction)
```
    以 conjunction 为分隔符将数组转换为字符串
    
    Parameters:
    
    array - 数组
    
    conjunction - 分隔符
    
    Returns:
    
    连接后的字符串
  - join
```
public static String join(boolean[] array,
                          CharSequence conjunction)
```
    以 conjunction 为分隔符将数组转换为字符串
    
    Parameters:
    
    array - 数组
    
    conjunction - 分隔符
    
    Returns:
    
    连接后的字符串
  - join
```
public static String join(float[] array,
                          CharSequence conjunction)
```
    以 conjunction 为分隔符将数组转换为字符串
    
    Parameters:
    
    array - 数组
    
    conjunction - 分隔符
    
    Returns:
    
    连接后的字符串
  - join
```
public static String join(double[] array,
                          CharSequence conjunction)
```
    以 conjunction 为分隔符将数组转换为字符串
    
    Parameters:
    
    array - 数组
    
    conjunction - 分隔符
    
    Returns:
    
    连接后的字符串
  - join
```
public static String join(Object array,
                          CharSequence conjunction)
```
    以 conjunction 为分隔符将数组转换为字符串
    
    Parameters:
    
    array - 数组
    
    conjunction - 分隔符
    
    Returns:
    
    连接后的字符串
  - min
```
public static <T extends Comparable<? super T>> T min(T[] numberArray)
```
    取最小值
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    numberArray - 数字数组
    
    Returns:
    
    最小值
  - min
```
public static long min(long... numberArray)
```
    取最小值
    
    Parameters:
    
    numberArray - 数字数组
    
    Returns:
    
    最小值
  - min
```
public static int min(int... numberArray)
```
    取最小值
    
    Parameters:
    
    numberArray - 数字数组
    
    Returns:
    
    最小值
  - min
```
public static short min(short... numberArray)
```
    取最小值
    
    Parameters:
    
    numberArray - 数字数组
    
    Returns:
    
    最小值
  - min
```
public static char min(char... numberArray)
```
    取最小值
    
    Parameters:
    
    numberArray - 数字数组
    
    Returns:
    
    最小值
  - min
```
public static byte min(byte... numberArray)
```
    取最小值
    
    Parameters:
    
    numberArray - 数字数组
    
    Returns:
    
    最小值
  - min
```
public static double min(double... numberArray)
```
    取最小值
    
    Parameters:
    
    numberArray - 数字数组
    
    Returns:
    
    最小值
  - min
```
public static float min(float... numberArray)
```
    取最小值
    
    Parameters:
    
    numberArray - 数字数组
    
    Returns:
    
    最小值
  - max
```
public static <T extends Comparable<? super T>> T max(T[] numberArray)
```
    取最大值
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    numberArray - 数字数组
    
    Returns:
    
    最大值
  - max
```
public static long max(long... numberArray)
```
    取最大值
    
    Parameters:
    
    numberArray - 数字数组
    
    Returns:
    
    最大值
  - max
```
public static int max(int... numberArray)
```
    取最大值
    
    Parameters:
    
    numberArray - 数字数组
    
    Returns:
    
    最大值
  - max
```
public static short max(short... numberArray)
```
    取最大值
    
    Parameters:
    
    numberArray - 数字数组
    
    Returns:
    
    最大值
  - max
```
public static char max(char... numberArray)
```
    取最大值
    
    Parameters:
    
    numberArray - 数字数组
    
    Returns:
    
    最大值
  - max
```
public static byte max(byte... numberArray)
```
    取最大值
    
    Parameters:
    
    numberArray - 数字数组
    
    Returns:
    
    最大值
  - max
```
public static double max(double... numberArray)
```
    取最大值
    
    Parameters:
    
    numberArray - 数字数组
    
    Returns:
    
    最大值
  - max
```
public static float max(float... numberArray)
```
    取最大值
    
    Parameters:
    
    numberArray - 数字数组
    
    Returns:
    
    最大值
  - max
```
public static <T extends Comparable<? super T>> T max(T[] numberArray,
                                                      Comparator<T> comparator)
```
    取最大值
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    numberArray - 数字数组
    
    comparator - 比较器，null表示默认比较器
    
    Returns:
    
    最大值
  - filter
```
public static <T> T[] filter(T[] array,
                             Editor<T> editor)
```
    过滤过滤过程通过传入的Editor实现来返回需要的元素内容,这个Editor实现可以实现以下功能：
```
 1、过滤出需要的对象,如果返回null表示这个元素对象抛弃
 2、修改元素对象,返回集合中为修改后的对象
 
```
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组
    
    editor - 编辑器接口
    
    Returns:
    
    过滤后的数组
  - filter
```
public static <T> T[] filter(T[] array,
                             Filter<T> filter)
```
    过滤过滤过程通过传入的Filter实现来过滤返回需要的元素内容,这个Editor实现可以实现以下功能：
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组
    
    filter - 过滤器接口,用于定义过滤规则
    
    Returns:
    
    过滤后的数组
  - zip
```
public static <K,V> Map<K,V> zip(K[] keys,
                                 V[] values)
```
    映射键值(参考Python的zip()函数)，返回Map无序例如： keys = [a,b,c,d] values = [1,2,3,4] 则得到的Map是 {a=1, b=2, c=3, d=4} 如果两个数组长度不同，则只对应最短部分
    
    Type Parameters:
    
    K - Key类型
    
    V - Value类型
    
    Parameters:
    
    keys - 键列表
    
    values - 值列表
    
    Returns:
    
    Map
  - zip
```
public static <K,V> Map<K,V> zip(K[] keys,
                                 V[] values,
                                 boolean isOrder)
```
    映射键值(参考Python的zip()函数) 例如： keys = [a,b,c,d] values = [1,2,3,4] 则得到的Map是 {a=1, b=2, c=3, d=4} 如果两个数组长度不同,则只对应最短部分
    
    Type Parameters:
    
    K - Key类型
    
    V - Value类型
    
    Parameters:
    
    keys - 键列表
    
    values - 值列表
    
    isOrder - 是否有序
    
    Returns:
    
    Map
  - isSameType
```
public static boolean isSameType(Object array1,
                                 Object array2)
```
    检查两个数组是否为同一类型
    
    Parameters:
    
    array1 - 第1个数组不能是null
    
    array2 - 第2个数组不能是null
    
    Returns:
    
    如果数组类型匹配，则为true
    
    Throws:
    
    IllegalArgumentException - 如果其中一个数组是null
  - indexOfIgnoreCase
```
public static int indexOfIgnoreCase(CharSequence[] array,
                                    CharSequence value)
```
    返回数组中指定元素所在位置,忽略大小写,未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    数组中指定元素所在位置, 未找到返回INDEX_NOT_FOUND
  - isArrayIndexValid
```
public static <T> boolean isArrayIndexValid(T[] array,
                                            int index)
```
    返回是否可以在给定索引处安全地访问给定数组
    
    Type Parameters:
    
    T - 数组的组件类型
    
    Parameters:
    
    array - 要检查的数组可能为空
    
    index - 要检查的数组的索引
    
    Returns:
    
    给定索引在给定数组中是否可安全访问
  - containsIgnoreCase
```
public static boolean containsIgnoreCase(CharSequence[] array,
                                         CharSequence value)
```
    数组中是否包含元素,忽略大小写
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    是否包含
  - getLength
```
public static int getLength(Object array)
```
    返回指定数组的长度
```
 ArrayKit.getLength(null)            = 0
 ArrayKit.getLength([])              = 0
 ArrayKit.getLength([null])          = 1
 ArrayKit.getLength([true, false])   = 2
 ArrayKit.getLength([1, 2, 3])       = 3
 ArrayKit.getLength(["a", "b", "c"]) = 3
 
```
    Parameters:
    
    array - 要从中检索长度的数组可以为空
    
    Returns:
    
    数组的长度，如果数组是null，则为0
    
    Throws:
    
    IllegalArgumentException - 如果对象参数不是数组
  - hashCode
```
public static int hashCode(Object array)
```
    获得一个数组哈希码,用于正确处理多维数组多维基元数组也可以用该方法正确处理
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    返回数组的哈希码
  - cast
```
public static Object[] cast(Class<?> type,
                            Object arrayObj)
                     throws NullPointerException,
                            IllegalArgumentException
```
    强转数组类型强制转换的前提是数组元素类型可被强制转换强制转换后会生成一个新数组
    
    Parameters:
    
    type - 数组类型或数组元素类型
    
    arrayObj - 原数组
    
    Returns:
    
    转换后的数组类型
    
    Throws:
    
    NullPointerException - 提供参数为空
    
    IllegalArgumentException - 参数arrayObj不是数组

Class ArrayKit

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ArrayKit

Method Detail

isArray

isEmpty

isEmpty

isEmpty

isEmpty

isEmpty

isEmpty

isEmpty

isEmpty

isEmpty

isEmpty

isNotEmpty

isNotEmpty

isNotEmpty

isNotEmpty

isNotEmpty

isNotEmpty

isNotEmpty

isNotEmpty

isNotEmpty

isAllEmpty

isAllNotEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

hasEmpty

hasNull

firstNonNull

firstNotNull

toString

toString

toArray

toArray

toArray

toArray

toArray

clone

clone

clone

clone

clone

clone

clone

clone

clone

clone

subarray

subarray

subarray

subarray

subarray

subarray

subarray

subarray

subarray

isSameLength