ArrayUtils (bus-core 3.0.5 API)

java.lang.Object
- org.aoju.bus.core.utils.ArrayUtils

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

Since:

JDK 1.8

Version:

3.0.5

Author:

Kimi Liu

Field Summary

Fields
Modifier and Type	Field and Description
`static boolean[]`	`EMPTY_BOOLEAN_ARRAY` `boolean` array.
`static Boolean[]`	`EMPTY_BOOLEAN_OBJECT_ARRAY` `Boolean` array.
`static byte[]`	`EMPTY_BYTE_ARRAY` `byte` array.
`static Byte[]`	`EMPTY_BYTE_OBJECT_ARRAY` `Byte` array.
`static char[]`	`EMPTY_CHAR_ARRAY` `char` array.
`static Character[]`	`EMPTY_CHARACTER_OBJECT_ARRAY` `Character` array.
`static Class<?>[]`	`EMPTY_CLASS_ARRAY` `Class` array.
`static double[]`	`EMPTY_DOUBLE_ARRAY` `double` array.
`static Double[]`	`EMPTY_DOUBLE_OBJECT_ARRAY` `Double` array.
`static float[]`	`EMPTY_FLOAT_ARRAY` `float` array.
`static Float[]`	`EMPTY_FLOAT_OBJECT_ARRAY` `Float` array.
`static int[]`	`EMPTY_INT_ARRAY` `int` array.
`static Integer[]`	`EMPTY_INTEGER_OBJECT_ARRAY` `Integer` array.
`static long[]`	`EMPTY_LONG_ARRAY` `long` array.
`static Long[]`	`EMPTY_LONG_OBJECT_ARRAY` `Long` array.
`static Object[]`	`EMPTY_OBJECT_ARRAY` `Object` array.
`static short[]`	`EMPTY_SHORT_ARRAY` `short` array.
`static Short[]`	`EMPTY_SHORT_OBJECT_ARRAY` `Short` array.
`static String[]`	`EMPTY_STRING_ARRAY` `String` array.
`static int`	`INDEX_NOT_FOUND` 列表或数组中没有找到元素时的索引值 : `-1`.

Constructor Summary

Constructors
Constructor and Description

ArrayUtils()

Constructors
Constructor and Description
`ArrayUtils()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static boolean[]`	`add(boolean[] array, boolean element)` Copies the given array and adds the given element at the end of the new array.
`static boolean[]`	`add(boolean[] array, int index, boolean element)` Inserts the specified element at the specified position in the array.
`static byte[]`	`add(byte[] array, byte element)` Copies the given array and adds the given element at the end of the new array.
`static byte[]`	`add(byte[] array, int index, byte element)` Inserts the specified element at the specified position in the array.
`static char[]`	`add(char[] array, char element)` Copies the given array and adds the given element at the end of the new array.
`static char[]`	`add(char[] array, int index, char element)` Inserts the specified element at the specified position in the array.
`static double[]`	`add(double[] array, double element)` Copies the given array and adds the given element at the end of the new array.
`static double[]`	`add(double[] array, int index, double element)` Inserts the specified element at the specified position in the array.
`static float[]`	`add(float[] array, float element)` Copies the given array and adds the given element at the end of the new array.
`static float[]`	`add(float[] array, int index, float element)` Inserts the specified element at the specified position in the array.
`static int[]`	`add(int[] array, int element)` Copies the given array and adds the given element at the end of the new array.
`static int[]`	`add(int[] array, int index, int element)` Inserts the specified element at the specified position in the array.
`static long[]`	`add(long[] array, int index, long element)` Inserts the specified element at the specified position in the array.
`static long[]`	`add(long[] array, long element)` Copies the given array and adds the given element at the end of the new array.
`static short[]`	`add(short[] array, int index, short element)` Inserts the specified element at the specified position in the array.
`static short[]`	`add(short[] array, short element)` Copies the given array and adds the given element at the end of the new array.
`static <T> T[]`	`add(T[] array, int index, T element)` Inserts the specified element at the specified position in the array.
`static <T> T[]`	`add(T[] array, T element)` Copies the given array and adds the given element at the end of the new array.
`static boolean[]`	`addAll(boolean[] array1, boolean... array2)` Adds all the elements of the given arrays into a new array.
`static byte[]`	`addAll(byte[] array1, byte... array2)` Adds all the elements of the given arrays into a new array.
`static char[]`	`addAll(char[] array1, char... array2)` Adds all the elements of the given arrays into a new array.
`static double[]`	`addAll(double[] array1, double... array2)` Adds all the elements of the given arrays into a new array.
`static float[]`	`addAll(float[] array1, float... array2)` Adds all the elements of the given arrays into a new array.
`static int[]`	`addAll(int[] array1, int... array2)` Adds all the elements of the given arrays into a new array.
`static long[]`	`addAll(long[] array1, long... array2)` Adds all the elements of the given arrays into a new array.
`static short[]`	`addAll(short[] array1, short... array2)` Adds all the elements of the given arrays into a new array.
`static <T> T[]`	`addAll(T[]... arrays)` 将多个数组合并在一起忽略null的数组
`static <T> T[]`	`addAll(T[] array1, T... array2)` Adds all the elements of the given arrays into a new array.
`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>`	`firstNotNullElem(Object[] objects)` 找到第一个不为 null 的元素
`static <T> T`	`get(Object array, int index)` 获取数组对象中指定index的值，支持负数，例如-1表示倒数第一个值
`static <T> T[]`	`getAny(Object array, int... indexes)` 获取数组中指定多个下标元素值，组成新数组
`static Class<?>`	`getArrayType(Class<?> componentType)` 根据数组元素类型，获取数组的类型方法是通过创建一个空数组从而获取其类型
`static Class<?>`	`getComponentType(Class<?> arrayClass)` 获取数组对象的元素类型
`static Class<?>`	`getComponentType(Object array)` 获取数组对象的元素类型
`static int`	`getLength(Object array)` 返回指定数组的长度
`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)` Inserts elements into an array at the given index (starting from zero).
`static byte[]`	`insert(int index, byte[] array, byte... values)` Inserts elements into an array at the given index (starting from zero).
`static char[]`	`insert(int index, char[] array, char... values)` Inserts elements into an array at the given index (starting from zero).
`static double[]`	`insert(int index, double[] array, double... values)` Inserts elements into an array at the given index (starting from zero).
`static float[]`	`insert(int index, float[] array, float... values)` Inserts elements into an array at the given index (starting from zero).
`static int[]`	`insert(int index, int[] array, int... values)` Inserts elements into an array at the given index (starting from zero).
`static long[]`	`insert(int index, long[] array, long... values)` Inserts elements into an array at the given index (starting from zero).
`static short[]`	`insert(int index, short[] array, short... values)` Inserts elements into an array at the given index (starting from zero).
`static <T> T[]`	`insert(int index, T[] array, T... values)` Inserts elements into an array at the given index (starting from zero).
`static <T> Object`	`insert(Object array, int index, T... newElements)` 将新元素插入到到已有数组中的某个位置添加新元素会生成一个新的数组，不影响原数组如果插入位置为为负数，从原数组从后向前计数，若大于原数组长度，则空白处用null填充
`static <T> T[]`	`insert(T[] array, int index, T... newElements)`
`static boolean`	`isArray(Object obj)` 对象是否为数组对象
`static <T> boolean`	`isArrayIndexValid(T[] array, int index)` Returns whether a given array can safely be accessed at the given 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(Object[] array)` 数组是否为空此方法会匹配单一对象，如果此对象为`null`则返回true 如果此对象为非数组，理解为此对象为数组的第一个元素，则返回false 如果此对象为数组对象，数组长度大于0情况下返回false，否则返回true
`static boolean`	`isEmpty(short[] 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)` This method checks whether the provided array is sorted according to natural ordering (`false` before `true`).
`static boolean`	`isSorted(byte[] array)` This method checks whether the provided array is sorted according to natural ordering.
`static boolean`	`isSorted(char[] array)` This method checks whether the provided array is sorted according to natural ordering.
`static boolean`	`isSorted(double[] array)` This method checks whether the provided array is sorted according to natural ordering.
`static boolean`	`isSorted(float[] array)` This method checks whether the provided array is sorted according to natural ordering.
`static boolean`	`isSorted(int[] array)` This method checks whether the provided array is sorted according to natural ordering.
`static boolean`	`isSorted(long[] array)` This method checks whether the provided array is sorted according to natural ordering.
`static boolean`	`isSorted(short[] array)` This method checks whether the provided array is sorted according to natural ordering.
`static <T extends Comparable<? super T>> boolean`	`isSorted(T[] array)` This method checks whether the provided array is sorted according to the class's `compareTo` method.
`static <T> boolean`	`isSorted(T[] array, Comparator<T> comparator)` This method checks whether the provided array is sorted according to the provided `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, 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 int`	`length(Object array)` 获取数组长度如果参数为`null`，返回0
`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 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 <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)` Removes the element at the specified position from the specified array.
`static byte[]`	`remove(byte[] array, int index)` Removes the element at the specified position from the specified array.
`static char[]`	`remove(char[] array, int index)` Removes the element at the specified position from the specified array.
`static double[]`	`remove(double[] array, int index)` Removes the element at the specified position from the specified array.
`static float[]`	`remove(float[] array, int index)` Removes the element at the specified position from the specified array.
`static int[]`	`remove(int[] array, int index)` Removes the element at the specified position from the specified array.
`static long[]`	`remove(long[] array, int index)` Removes the element at the specified position from the specified array.
`static short[]`	`remove(short[] array, int index)` Removes the element at the specified position from the specified array.
`static <T> T[]`	`remove(T[] array, int index)` Removes the element at the specified position from the specified array.
`static boolean[]`	`removeAll(boolean[] array, int... indices)` Removes the elements at the specified positions from the specified array.
`static byte[]`	`removeAll(byte[] array, int... indices)` Removes the elements at the specified positions from the specified array.
`static char[]`	`removeAll(char[] array, int... indices)` Removes the elements at the specified positions from the specified array.
`static double[]`	`removeAll(double[] array, int... indices)` Removes the elements at the specified positions from the specified array.
`static float[]`	`removeAll(float[] array, int... indices)` Removes the elements at the specified positions from the specified array.
`static int[]`	`removeAll(int[] array, int... indices)` Removes the elements at the specified positions from the specified array.
`static long[]`	`removeAll(long[] array, int... indices)` Removes the elements at the specified positions from the specified array.
`static short[]`	`removeAll(short[] array, int... indices)` Removes the elements at the specified positions from the specified array.
`static <T> T[]`	`removeAll(T[] array, int... indices)` Removes the elements at the specified positions from the specified array.
`static boolean[]`	`removeAllOccurences(boolean[] array, boolean element)` Removes the occurrences of the specified element from the specified boolean array.
`static byte[]`	`removeAllOccurences(byte[] array, byte element)` Removes the occurrences of the specified element from the specified byte array.
`static char[]`	`removeAllOccurences(char[] array, char element)` Removes the occurrences of the specified element from the specified char array.
`static double[]`	`removeAllOccurences(double[] array, double element)` Removes the occurrences of the specified element from the specified double array.
`static float[]`	`removeAllOccurences(float[] array, float element)` Removes the occurrences of the specified element from the specified float array.
`static int[]`	`removeAllOccurences(int[] array, int element)` Removes the occurrences of the specified element from the specified int array.
`static long[]`	`removeAllOccurences(long[] array, long element)` Removes the occurrences of the specified element from the specified long array.
`static short[]`	`removeAllOccurences(short[] array, short element)` Removes the occurrences of the specified element from the specified short array.
`static <T> T[]`	`removeAllOccurences(T[] array, T element)` Removes the occurrences of the specified element from the specified array.
`static boolean[]`	`removeElement(boolean[] array, boolean element)` Removes the first occurrence of the specified element from the specified array.
`static byte[]`	`removeElement(byte[] array, byte element)` Removes the first occurrence of the specified element from the specified array.
`static char[]`	`removeElement(char[] array, char element)` Removes the first occurrence of the specified element from the specified array.
`static double[]`	`removeElement(double[] array, double element)` Removes the first occurrence of the specified element from the specified array.
`static float[]`	`removeElement(float[] array, float element)` Removes the first occurrence of the specified element from the specified array.
`static int[]`	`removeElement(int[] array, int element)` Removes the first occurrence of the specified element from the specified array.
`static long[]`	`removeElement(long[] array, long element)` Removes the first occurrence of the specified element from the specified array.
`static short[]`	`removeElement(short[] array, short element)` Removes the first occurrence of the specified element from the specified array.
`static <T> T[]`	`removeElement(T[] array, Object element)` Removes the first occurrence of the specified element from the specified array.
`static boolean[]`	`removeElements(boolean[] array, boolean... values)` Removes occurrences of specified elements, in specified quantities, from the specified array.
`static byte[]`	`removeElements(byte[] array, byte... values)` Removes occurrences of specified elements, in specified quantities, from the specified array.
`static char[]`	`removeElements(char[] array, char... values)` Removes occurrences of specified elements, in specified quantities, from the specified array.
`static double[]`	`removeElements(double[] array, double... values)` Removes occurrences of specified elements, in specified quantities, from the specified array.
`static float[]`	`removeElements(float[] array, float... values)` Removes occurrences of specified elements, in specified quantities, from the specified array.
`static int[]`	`removeElements(int[] array, int... values)` Removes occurrences of specified elements, in specified quantities, from the specified array.
`static long[]`	`removeElements(long[] array, long... values)` Removes occurrences of specified elements, in specified quantities, from the specified array.
`static short[]`	`removeElements(short[] array, short... values)` Removes occurrences of specified elements, in specified quantities, from the specified array.
`static <T> T[]`	`removeElements(T[] array, T... values)` Removes occurrences of specified elements, in specified quantities, from the specified array.
`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)` Shifts the order of the given int array.
`static void`	`shift(int[] array, int startIndex, int endIndex, int offset)` 改变数组的顺序
`static void`	`shift(long[] array, int offset)` Shifts the order of the given long array.
`static void`	`shift(long[] array, int startIndex, int endIndex, int offset)` 改变数组的顺序
`static void`	`shift(Object[] array, int offset)` Shifts the order of the given array.
`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)` Randomly permutes the elements of the specified array using the Fisher-Yates algorithm.
`static void`	`shuffle(boolean[] array, Random random)` Randomly permutes the elements of the specified array using the Fisher-Yates algorithm.
`static void`	`shuffle(byte[] array)` Randomly permutes the elements of the specified array using the Fisher-Yates algorithm.
`static void`	`shuffle(byte[] array, Random random)` Randomly permutes the elements of the specified array using the Fisher-Yates algorithm.
`static void`	`shuffle(char[] array)` Randomly permutes the elements of the specified array using the Fisher-Yates algorithm.
`static void`	`shuffle(char[] array, Random random)` Randomly permutes the elements of the specified array using the Fisher-Yates algorithm.
`static void`	`shuffle(double[] array)` Randomly permutes the elements of the specified array using the Fisher-Yates algorithm.
`static void`	`shuffle(double[] array, Random random)` Randomly permutes the elements of the specified array using the Fisher-Yates algorithm.
`static void`	`shuffle(float[] array)` Randomly permutes the elements of the specified array using the Fisher-Yates algorithm.
`static void`	`shuffle(float[] array, Random random)` Randomly permutes the elements of the specified array using the Fisher-Yates algorithm.
`static void`	`shuffle(int[] array)` Randomly permutes the elements of the specified array using the Fisher-Yates algorithm.
`static void`	`shuffle(int[] array, Random random)` Randomly permutes the elements of the specified array using the Fisher-Yates algorithm.
`static void`	`shuffle(long[] array)` Randomly permutes the elements of the specified array using the Fisher-Yates algorithm.
`static void`	`shuffle(long[] array, Random random)` Randomly permutes the elements of the specified array using the Fisher-Yates algorithm.
`static void`	`shuffle(Object[] array)` Randomly permutes the elements of the specified array using the Fisher-Yates algorithm.
`static void`	`shuffle(Object[] array, Random random)` Randomly permutes the elements of the specified array using the Fisher-Yates algorithm.
`static void`	`shuffle(short[] array)` Randomly permutes the elements of the specified array using the Fisher-Yates algorithm.
`static void`	`shuffle(short[] array, Random random)` Randomly permutes the elements of the specified array using the Fisher-Yates algorithm.
`static byte[][]`	`split(byte[] array, int len)` 拆分byte数组为几个等份（最后一份可能小于len）
`static Object[]`	`sub(Object array, int start, int end)` 获取子数组
`static Object[]`	`sub(Object array, int start, int end, int step)` 获取子数组
`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(T... items)` 该方法通常用于调用者本身使用泛型类型的场景必须组合成数组。
`static Map<Object,Object>`	`toMap(Object[] array)` 将给定数组转换为`Map` 数组的每个元素必须是`Map`。或数组，其中至少包含两个元素，其中第一个元素用作键，第二个元素用作值。
`static Boolean[]`	`toObject(boolean[] array)` Converts an array of primitive booleans to objects.
`static Byte[]`	`toObject(byte[] array)` Converts an array of primitive bytes to objects.
`static Character[]`	`toObject(char[] array)` Converts an array of primitive chars to objects.
`static Double[]`	`toObject(double[] array)` Converts an array of primitive doubles to objects.
`static Float[]`	`toObject(float[] array)` Converts an array of primitive floats to objects.
`static Integer[]`	`toObject(int[] array)` Converts an array of primitive ints to objects.
`static Long[]`	`toObject(long[] array)` Converts an array of primitive longs to objects.
`static Short[]`	`toObject(short[] array)` Converts an array of primitive shorts to objects.
`static boolean[]`	`toPrimitive(Boolean[] array)` Converts an array of object Booleans to primitives.
`static boolean[]`	`toPrimitive(Boolean[] array, boolean valueForNull)` Converts an array of object Booleans to primitives handling `null`.
`static byte[]`	`toPrimitive(Byte[] array)` Converts an array of object Bytes to primitives.
`static byte[]`	`toPrimitive(Byte[] array, byte valueForNull)` Converts an array of object Bytes to primitives handling `null`.
`static char[]`	`toPrimitive(Character[] array)` Converts an array of object Characters to primitives.
`static char[]`	`toPrimitive(Character[] array, char valueForNull)` Converts an array of object Character to primitives handling `null`.
`static double[]`	`toPrimitive(Double[] array)` Converts an array of object Doubles to primitives.
`static double[]`	`toPrimitive(Double[] array, double valueForNull)` Converts an array of object Doubles to primitives handling `null`.
`static float[]`	`toPrimitive(Float[] array)` Converts an array of object Floats to primitives.
`static float[]`	`toPrimitive(Float[] array, float valueForNull)` Converts an array of object Floats to primitives handling `null`.
`static int[]`	`toPrimitive(Integer[] array)` Converts an array of object Integers to primitives.
`static int[]`	`toPrimitive(Integer[] array, int valueForNull)` Converts an array of object Integer to primitives handling `null`.
`static long[]`	`toPrimitive(Long[] array)` Converts an array of object Longs to primitives.
`static long[]`	`toPrimitive(Long[] array, long valueForNull)` Converts an array of object Long to primitives handling `null`.
`static Object`	`toPrimitive(Object array)` Create an array of primitive type from an array of wrapper types.
`static short[]`	`toPrimitive(Short[] array)` Converts an array of object Shorts to primitives.
`static short[]`	`toPrimitive(Short[] array, short valueForNull)` Converts an array of object Short to primitives handling `null`.
`static String`	`toString(Object array)` 数组或集合转String
`static String`	`toString(Object array, String stringIfNull)` 数组或集合转String
`static String[]`	`toStringArray(Object[] array)` Returns an array containing the string representation of each element in the argument array.
`static String[]`	`toStringArray(Object[] array, String valueForNullElements)` Returns an array containing the string representation of each element in the argument array handling `null` elements.
`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, 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

- Field Detail
  - EMPTY_OBJECT_ARRAY
```
public static final Object[] EMPTY_OBJECT_ARRAY
```
    Object array.
  - EMPTY_CLASS_ARRAY
```
public static final Class<?>[] EMPTY_CLASS_ARRAY
```
    Class array.
  - EMPTY_STRING_ARRAY
```
public static final String[] EMPTY_STRING_ARRAY
```
    String array.
  - EMPTY_LONG_ARRAY
```
public static final long[] EMPTY_LONG_ARRAY
```
    long array.
  - EMPTY_LONG_OBJECT_ARRAY
```
public static final Long[] EMPTY_LONG_OBJECT_ARRAY
```
    Long array.
  - EMPTY_INT_ARRAY
```
public static final int[] EMPTY_INT_ARRAY
```
    int array.
  - EMPTY_INTEGER_OBJECT_ARRAY
```
public static final Integer[] EMPTY_INTEGER_OBJECT_ARRAY
```
    Integer array.
  - EMPTY_SHORT_ARRAY
```
public static final short[] EMPTY_SHORT_ARRAY
```
    short array.
  - EMPTY_SHORT_OBJECT_ARRAY
```
public static final Short[] EMPTY_SHORT_OBJECT_ARRAY
```
    Short array.
  - EMPTY_BYTE_ARRAY
```
public static final byte[] EMPTY_BYTE_ARRAY
```
    byte array.
  - EMPTY_BYTE_OBJECT_ARRAY
```
public static final Byte[] EMPTY_BYTE_OBJECT_ARRAY
```
    Byte array.
  - EMPTY_DOUBLE_ARRAY
```
public static final double[] EMPTY_DOUBLE_ARRAY
```
    double array.
  - EMPTY_DOUBLE_OBJECT_ARRAY
```
public static final Double[] EMPTY_DOUBLE_OBJECT_ARRAY
```
    Double array.
  - EMPTY_FLOAT_ARRAY
```
public static final float[] EMPTY_FLOAT_ARRAY
```
    float array.
  - EMPTY_FLOAT_OBJECT_ARRAY
```
public static final Float[] EMPTY_FLOAT_OBJECT_ARRAY
```
    Float array.
  - EMPTY_BOOLEAN_ARRAY
```
public static final boolean[] EMPTY_BOOLEAN_ARRAY
```
    boolean array.
  - EMPTY_BOOLEAN_OBJECT_ARRAY
```
public static final Boolean[] EMPTY_BOOLEAN_OBJECT_ARRAY
```
    Boolean array.
  - EMPTY_CHAR_ARRAY
```
public static final char[] EMPTY_CHAR_ARRAY
```
    char array.
  - EMPTY_CHARACTER_OBJECT_ARRAY
```
public static final Character[] EMPTY_CHARACTER_OBJECT_ARRAY
```
    Character array.
  - INDEX_NOT_FOUND
```
public static final int INDEX_NOT_FOUND
```
    列表或数组中没有找到元素时的索引值 : -1. 此值由该类中的方法返回，也可用于与所返回的值进行比较List.
    
    See Also:
    
    Constant Field Values
- Constructor Detail
  - ArrayUtils
```
public ArrayUtils()
```
- Method Detail
  - toString
```
public static String toString(Object array)
```
    数组或集合转String
    
    Parameters:
    
    array - 集合或数组对象
    
    Returns:
    
    数组字符串，与集合转字符串格式相同
  - toString
```
public static String toString(Object array,
                              String stringIfNull)
```
    数组或集合转String
    
    Parameters:
    
    array - 集合或数组对象
    
    stringIfNull - 是否null
    
    Returns:
    
    数组字符串，与集合转字符串格式相同
  - hashCode
```
public static int hashCode(Object array)
```
    获得一个数组哈希码，用于正确处理多维数组。多维基元数组也可以用该方法正确处理。
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    返回数组的哈希码
  - toMap
```
public static Map<Object,Object> toMap(Object[] array)
```
    将给定数组转换为Map 数组的每个元素必须是Map。或数组，其中至少包含两个元素，其中第一个元素用作键，第二个元素用作值。
```
 Map colorMap = ArrayUtils.toMap(new String[][] {
     {"RED", "#FF0000"},
     {"GREEN", "#00FF00"},
     {"BLUE", "#0000FF"}});
 
```
    Parameters:
    
    array - 数组
    
    Returns:
    
    Map
  - toArray
```
public static <T> T[] toArray(T... items)
```
    该方法通常用于调用者本身使用泛型类型的场景必须组合成数组。
    注意，此方法只适用于提供相同类型的参数，以便编译器可以推断数组本身的类型。虽然可以选择显式输入like in Number[] array = ArrayUtils.toArray(Integer.valueOf(42),Double.valueOf(Math.PI)) 与……相比没有什么真正的优势 new Number[]{整数.valueof(42),Double.valueOf(Math.PI)}。
    
    Type Parameters:
    
    T - 对象
    
    Parameters:
    
    items - 数组
    
    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:
    
    新数组
  - nullToEmpty
```
public static <T> T[] nullToEmpty(T[] array,
                                  Class<T[]> type)
```
    输入数组返回一个空数组或原始数组
    
    Type Parameters:
    
    T - the class type
    
    Parameters:
    
    array - the array to check for null or empty
    
    type - the class representation of the desired array
    
    Returns:
    
    the same array, public static empty array if null
    
    Throws:
    
    IllegalArgumentException - if the type argument is null
    
    Since:
    
    3.5
  - 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:
    
    空数组或原始数组
  - 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
  - getLength
```
public static int getLength(Object array)
```
    返回指定数组的长度
```
 ArrayUtils.getLength(null)            = 0
 ArrayUtils.getLength([])              = 0
 ArrayUtils.getLength([null])          = 1
 ArrayUtils.getLength([true, false])   = 2
 ArrayUtils.getLength([1, 2, 3])       = 3
 ArrayUtils.getLength(["a", "b", "c"]) = 3
 
```
    Parameters:
    
    array - the array to retrieve the length from, may be null
    
    Returns:
    
    The length of the array, or 0 if the array is null
    
    Throws:
    
    IllegalArgumentException - if the object argument is not an array.
    
    Since:
    
    2.1
  - isSameType
```
public static boolean isSameType(Object array1,
                                 Object array2)
```
    检查两个数组是否为同一类型
    
    Parameters:
    
    array1 - the first array, must not be null
    
    array2 - the second array, must not be null
    
    Returns:
    
    true if type of arrays matches
    
    Throws:
    
    IllegalArgumentException - if either array is null
  - 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 Examples:
    
    ArrayUtils.swap(["1", "2", "3"], 0, 2) -> ["3", "2", "1"]
    
    ArrayUtils.swap(["1", "2", "3"], 0, 0) -> ["1", "2", "3"]
    
    ArrayUtils.swap(["1", "2", "3"], 1, 0) -> ["2", "1", "3"]
    
    ArrayUtils.swap(["1", "2", "3"], 0, 5) -> ["1", "2", "3"]
    
    ArrayUtils.swap(["1", "2", "3"], -1, 1) -> ["2", "1", "3"]
    Since:
    
    3.5
  - swap
```
public static void swap(long[] array,
                        int offset1,
                        int offset2)
```
    交换数组中连个位置的值
    Parameters:
    
    array - 数组
    
    offset1 - 位置1
    offset2 - 位置2 Examples:
    
    ArrayUtils.swap([true, false, true], 0, 2) -> [true, false, true]
    
    ArrayUtils.swap([true, false, true], 0, 0) -> [true, false, true]
    
    ArrayUtils.swap([true, false, true], 1, 0) -> [false, true, true]
    
    ArrayUtils.swap([true, false, true], 0, 5) -> [true, false, true]
    
    ArrayUtils.swap([true, false, true], -1, 1) -> [false, true, true]
    Since:
    
    3.5
  - swap
```
public static void swap(int[] array,
                        int offset1,
                        int offset2)
```
    交换数组中连个位置的值
    Parameters:
    
    array - 数组
    
    offset1 - 位置1
    offset2 - 位置2
    Examples:
    
    ArrayUtils.swap([1, 2, 3], 0, 2) -> [3, 2, 1]
    
    ArrayUtils.swap([1, 2, 3], 0, 0) -> [1, 2, 3]
    
    ArrayUtils.swap([1, 2, 3], 1, 0) -> [2, 1, 3]
    
    ArrayUtils.swap([1, 2, 3], 0, 5) -> [1, 2, 3]
    
    ArrayUtils.swap([1, 2, 3], -1, 1) -> [2, 1, 3]
    Since:
    
    3.5
  - swap
```
public static void swap(short[] array,
                        int offset1,
                        int offset2)
```
    交换数组中连个位置的值
    Parameters:
    
    array - 数组
    
    offset1 - 位置1
    offset2 - 位置2
    Examples:
    
    ArrayUtils.swap([1, 2, 3], 0, 2) -> [3, 2, 1]
    
    ArrayUtils.swap([1, 2, 3], 0, 0) -> [1, 2, 3]
    
    ArrayUtils.swap([1, 2, 3], 1, 0) -> [2, 1, 3]
    
    ArrayUtils.swap([1, 2, 3], 0, 5) -> [1, 2, 3]
    
    ArrayUtils.swap([1, 2, 3], -1, 1) -> [2, 1, 3]
    Since:
    
    3.5
  - swap
```
public static void swap(char[] array,
                        int offset1,
                        int offset2)
```
    交换数组中连个位置的值
    Parameters:
    
    array - 数组
    
    offset1 - 位置1
    offset2 - 位置2
    Examples:
    
    ArrayUtils.swap([1, 2, 3], 0, 2) -> [3, 2, 1]
    
    ArrayUtils.swap([1, 2, 3], 0, 0) -> [1, 2, 3]
    
    ArrayUtils.swap([1, 2, 3], 1, 0) -> [2, 1, 3]
    
    ArrayUtils.swap([1, 2, 3], 0, 5) -> [1, 2, 3]
    
    ArrayUtils.swap([1, 2, 3], -1, 1) -> [2, 1, 3]
    Since:
    
    3.5
  - swap
```
public static void swap(byte[] array,
                        int offset1,
                        int offset2)
```
    交换数组中连个位置的值
    Parameters:
    
    array - 数组
    
    offset1 - 位置1
    offset2 - 位置2
    Examples:
    
    ArrayUtils.swap([1, 2, 3], 0, 2) -> [3, 2, 1]
    
    ArrayUtils.swap([1, 2, 3], 0, 0) -> [1, 2, 3]
    
    ArrayUtils.swap([1, 2, 3], 1, 0) -> [2, 1, 3]
    
    ArrayUtils.swap([1, 2, 3], 0, 5) -> [1, 2, 3]
    
    ArrayUtils.swap([1, 2, 3], -1, 1) -> [2, 1, 3]
    Since:
    
    3.5
  - swap
```
public static void swap(double[] array,
                        int offset1,
                        int offset2)
```
    交换数组中连个位置的值
    Parameters:
    
    array - 数组
    
    offset1 - 位置1
    offset2 - 位置2
    Examples:
    
    ArrayUtils.swap([1, 2, 3], 0, 2) -> [3, 2, 1]
    
    ArrayUtils.swap([1, 2, 3], 0, 0) -> [1, 2, 3]
    
    ArrayUtils.swap([1, 2, 3], 1, 0) -> [2, 1, 3]
    
    ArrayUtils.swap([1, 2, 3], 0, 5) -> [1, 2, 3]
    
    ArrayUtils.swap([1, 2, 3], -1, 1) -> [2, 1, 3]
    Since:
    
    3.5
  - swap
```
public static void swap(float[] array,
                        int offset1,
                        int offset2)
```
    交换数组中连个位置的值
    Parameters:
    
    array - 数组
    
    offset1 - 位置1
    offset2 - 位置2
    Examples:
    
    ArrayUtils.swap([1, 2, 3], 0, 2) -> [3, 2, 1]
    
    ArrayUtils.swap([1, 2, 3], 0, 0) -> [1, 2, 3]
    
    ArrayUtils.swap([1, 2, 3], 1, 0) -> [2, 1, 3]
    
    ArrayUtils.swap([1, 2, 3], 0, 5) -> [1, 2, 3]
    
    ArrayUtils.swap([1, 2, 3], -1, 1) -> [2, 1, 3]
    Since:
    
    3.5
  - swap
```
public static void swap(boolean[] array,
                        int offset1,
                        int offset2)
```
    交换数组中连个位置的值
    Parameters:
    
    array - 数组
    
    offset1 - 位置1
    offset2 - 位置2
    Examples:
    
    ArrayUtils.swap([1, 2, 3], 0, 2) -> [3, 2, 1]
    
    ArrayUtils.swap([1, 2, 3], 0, 0) -> [1, 2, 3]
    
    ArrayUtils.swap([1, 2, 3], 1, 0) -> [2, 1, 3]
    
    ArrayUtils.swap([1, 2, 3], 0, 5) -> [1, 2, 3]
    
    ArrayUtils.swap([1, 2, 3], -1, 1) -> [2, 1, 3]
    Since:
    
    3.5
  - swap
```
public static void swap(boolean[] array,
                        int offset1,
                        int offset2,
                        int len)
```
    交换数组中连个位置的值
    Parameters:
    
    array - 数组
    
    offset1 - 位置1
    
    offset2 - 位置2
    len - 从给定索引开始交换的元素数量
    Examples:
    
    ArrayUtils.swap([true, false, true, false], 0, 2, 1) -> [true, false, true, false]
    
    ArrayUtils.swap([true, false, true, false], 0, 0, 1) -> [true, false, true, false]
    
    ArrayUtils.swap([true, false, true, false], 0, 2, 2) -> [true, false, true, false]
    
    ArrayUtils.swap([true, false, true, false], -3, 2, 2) -> [true, false, true, false]
    
    ArrayUtils.swap([true, false, true, false], 0, 3, 3) -> [false, false, true, true]
    Since:
    
    3.5
  - swap
```
public static void swap(byte[] array,
                        int offset1,
                        int offset2,
                        int len)
```
    交换数组中连个位置的值
    Parameters:
    
    array - 数组
    
    offset1 - 位置1
    
    offset2 - 位置2
    len - 从给定索引开始交换的元素数量
    Examples:
    
    ArrayUtils.swap([1, 2, 3, 4], 0, 2, 1) -> [3, 2, 1, 4]
    
    ArrayUtils.swap([1, 2, 3, 4], 0, 0, 1) -> [1, 2, 3, 4]
    
    ArrayUtils.swap([1, 2, 3, 4], 2, 0, 2) -> [3, 4, 1, 2]
    
    ArrayUtils.swap([1, 2, 3, 4], -3, 2, 2) -> [3, 4, 1, 2]
    
    ArrayUtils.swap([1, 2, 3, 4], 0, 3, 3) -> [4, 2, 3, 1]
    Since:
    
    3.5
  - swap
```
public static void swap(char[] array,
                        int offset1,
                        int offset2,
                        int len)
```
    交换数组中连个位置的值
    Parameters:
    
    array - 数组
    
    offset1 - 位置1
    
    offset2 - 位置2
    len - 从给定索引开始交换的元素数量
    Examples:
    
    ArrayUtils.swap([1, 2, 3, 4], 0, 2, 1) -> [3, 2, 1, 4]
    
    ArrayUtils.swap([1, 2, 3, 4], 0, 0, 1) -> [1, 2, 3, 4]
    
    ArrayUtils.swap([1, 2, 3, 4], 2, 0, 2) -> [3, 4, 1, 2]
    
    ArrayUtils.swap([1, 2, 3, 4], -3, 2, 2) -> [3, 4, 1, 2]
    
    ArrayUtils.swap([1, 2, 3, 4], 0, 3, 3) -> [4, 2, 3, 1]
    Since:
    
    3.5
  - swap
```
public static void swap(double[] array,
                        int offset1,
                        int offset2,
                        int len)
```
    交换数组中连个位置的值
    Parameters:
    
    array - 数组
    
    offset1 - 位置1
    
    offset2 - 位置2
    len - 从给定索引开始交换的元素数量
    Examples:
    
    ArrayUtils.swap([1, 2, 3, 4], 0, 2, 1) -> [3, 2, 1, 4]
    
    ArrayUtils.swap([1, 2, 3, 4], 0, 0, 1) -> [1, 2, 3, 4]
    
    ArrayUtils.swap([1, 2, 3, 4], 2, 0, 2) -> [3, 4, 1, 2]
    
    ArrayUtils.swap([1, 2, 3, 4], -3, 2, 2) -> [3, 4, 1, 2]
    
    ArrayUtils.swap([1, 2, 3, 4], 0, 3, 3) -> [4, 2, 3, 1]
    Since:
    
    3.5
  - swap
```
public static void swap(float[] array,
                        int offset1,
                        int offset2,
                        int len)
```
    交换数组中连个位置的值
    Parameters:
    
    array - 数组
    
    offset1 - 位置1
    
    offset2 - 位置2
    len - 从给定索引开始交换的元素数量
    Examples:
    
    ArrayUtils.swap([1, 2, 3, 4], 0, 2, 1) -> [3, 2, 1, 4]
    
    ArrayUtils.swap([1, 2, 3, 4], 0, 0, 1) -> [1, 2, 3, 4]
    
    ArrayUtils.swap([1, 2, 3, 4], 2, 0, 2) -> [3, 4, 1, 2]
    
    ArrayUtils.swap([1, 2, 3, 4], -3, 2, 2) -> [3, 4, 1, 2]
    
    ArrayUtils.swap([1, 2, 3, 4], 0, 3, 3) -> [4, 2, 3, 1]
    Since:
    
    3.5
  - swap
```
public static void swap(int[] array,
                        int offset1,
                        int offset2,
                        int len)
```
    交换数组中连个位置的值
    Parameters:
    
    array - 数组
    
    offset1 - 位置1
    
    offset2 - 位置2
    len - 从给定索引开始交换的元素数量
    Examples:
    
    ArrayUtils.swap([1, 2, 3, 4], 0, 2, 1) -> [3, 2, 1, 4]
    
    ArrayUtils.swap([1, 2, 3, 4], 0, 0, 1) -> [1, 2, 3, 4]
    
    ArrayUtils.swap([1, 2, 3, 4], 2, 0, 2) -> [3, 4, 1, 2]
    
    ArrayUtils.swap([1, 2, 3, 4], -3, 2, 2) -> [3, 4, 1, 2]
    
    ArrayUtils.swap([1, 2, 3, 4], 0, 3, 3) -> [4, 2, 3, 1]
  - swap
```
public static void swap(long[] array,
                        int offset1,
                        int offset2,
                        int len)
```
    交换数组中连个位置的值
    Parameters:
    
    array - 数组
    
    offset1 - 位置1
    
    offset2 - 位置2
    len - 从给定索引开始交换的元素数量
    Examples:
    
    ArrayUtils.swap([1, 2, 3, 4], 0, 2, 1) -> [3, 2, 1, 4]
    
    ArrayUtils.swap([1, 2, 3, 4], 0, 0, 1) -> [1, 2, 3, 4]
    
    ArrayUtils.swap([1, 2, 3, 4], 2, 0, 2) -> [3, 4, 1, 2]
    
    ArrayUtils.swap([1, 2, 3, 4], -3, 2, 2) -> [3, 4, 1, 2]
    
    ArrayUtils.swap([1, 2, 3, 4], 0, 3, 3) -> [4, 2, 3, 1]
  - swap
```
public static void swap(Object[] array,
                        int offset1,
                        int offset2,
                        int len)
```
    交换数组中连个位置的值
    Parameters:
    
    array - 数组
    
    offset1 - 位置1
    
    offset2 - 位置2
    len - 从给定索引开始交换的元素数量
    Examples:
    
    ArrayUtils.swap(["1", "2", "3", "4"], 0, 2, 1) -> ["3", "2", "1", "4"]
    
    ArrayUtils.swap(["1", "2", "3", "4"], 0, 0, 1) -> ["1", "2", "3", "4"]
    
    ArrayUtils.swap(["1", "2", "3", "4"], 2, 0, 2) -> ["3", "4", "1", "2"]
    
    ArrayUtils.swap(["1", "2", "3", "4"], -3, 2, 2) -> ["3", "4", "1", "2"]
    
    ArrayUtils.swap(["1", "2", "3", "4"], 0, 3, 3) -> ["4", "2", "3", "1"]
    Since:
    
    3.5
  - swap
```
public static void swap(short[] array,
                        int offset1,
                        int offset2,
                        int len)
```
    交换数组中连个位置的值
    Parameters:
    
    array - 数组
    
    offset1 - 位置1
    
    offset2 - 位置2
    len - 从给定索引开始交换的元素数量 Examples:
    
    ArrayUtils.swap([1, 2, 3, 4], 0, 2, 1) -> [3, 2, 1, 4]
    
    ArrayUtils.swap([1, 2, 3, 4], 0, 0, 1) -> [1, 2, 3, 4]
    
    ArrayUtils.swap([1, 2, 3, 4], 2, 0, 2) -> [3, 4, 1, 2]
    
    ArrayUtils.swap([1, 2, 3, 4], -3, 2, 2) -> [3, 4, 1, 2]
    
    ArrayUtils.swap([1, 2, 3, 4], 0, 3, 3) -> [4, 2, 3, 1]
    Since:
    
    3.5
  - shift
```
public static void shift(Object[] array,
                         int offset)
```
    Shifts the order of the given array.
    There is no special handling for multi-dimensional arrays. This method does nothing for null or empty input arrays.
    
    Parameters:
    
    array - the array to shift, may be null
    
    offset - The number of positions to rotate the elements. If the offset is larger than the number of elements to rotate, than the effective offset is modulo the number of elements to rotate.
    
    Since:
    
    3.5
  - shift
```
public static void shift(long[] array,
                         int offset)
```
    Shifts the order of the given long array.
    There is no special handling for multi-dimensional arrays. This method does nothing for null or empty input arrays.
    
    Parameters:
    
    array - the array to shift, may be null
    
    offset - The number of positions to rotate the elements. If the offset is larger than the number of elements to rotate, than the effective offset is modulo the number of elements to rotate.
    
    Since:
    
    3.5
  - shift
```
public static void shift(int[] array,
                         int offset)
```
    Shifts the order of the given int array.
    There is no special handling for multi-dimensional arrays. This method does nothing for null or empty input arrays.
    
    Parameters:
    
    array - the array to shift, may be null
    
    offset - The number of positions to rotate the elements. If the offset is larger than the number of elements to rotate, than the effective offset is modulo the number of elements to rotate.
    
    Since:
    
    3.5
  - 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
    
    Since:
    
    3.0.7
  - indexOf
```
public static int indexOf(Object[] array,
                          Object value,
                          int index)
```
    返回数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    index - 索引
    
    Returns:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Since:
    
    3.0.7
  - lastIndexOf
```
public static int lastIndexOf(Object[] array,
                              Object value)
```
    返回数组中指定元素所在最后的位置，未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Since:
    
    3.0.7
  - lastIndexOf
```
public static int lastIndexOf(Object[] array,
                              Object value,
                              int index)
```
    返回数组中指定元素所在最后的位置，未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    index - 索引
    
    Returns:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Since:
    
    3.0.7
  - 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
    
    Since:
    
    3.0.7
  - indexOf
```
public static int indexOf(long[] array,
                          long value,
                          int index)
```
    返回数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    index - 索引
    
    Returns:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Since:
    
    3.0.7
  - lastIndexOf
```
public static int lastIndexOf(long[] array,
                              long value)
```
    返回数组中指定元素所在最后的位置，未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Since:
    
    3.0.7
  - lastIndexOf
```
public static int lastIndexOf(long[] array,
                              long value,
                              int index)
```
    返回数组中指定元素所在最后的位置，未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    index - 索引
    
    Returns:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Since:
    
    3.0.7
  - 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
    
    Since:
    
    3.0.7
  - indexOf
```
public static int indexOf(int[] array,
                          int value,
                          int index)
```
    返回数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    index - 索引
    
    Returns:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Since:
    
    3.0.7
  - lastIndexOf
```
public static int lastIndexOf(int[] array,
                              int value)
```
    返回数组中指定元素所在最后的位置，未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Since:
    
    3.0.7
  - lastIndexOf
```
public static int lastIndexOf(int[] array,
                              int value,
                              int index)
```
    返回数组中指定元素所在最后的位置，未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    index - 索引
    
    Returns:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Since:
    
    3.0.7
  - 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
    
    Since:
    
    3.0.7
  - indexOf
```
public static int indexOf(short[] array,
                          short value,
                          int index)
```
    返回数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    index - 索引
    
    Returns:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Since:
    
    3.0.7
  - lastIndexOf
```
public static int lastIndexOf(short[] array,
                              short value)
```
    返回数组中指定元素所在最后的位置，未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Since:
    
    3.0.7
  - lastIndexOf
```
public static int lastIndexOf(short[] array,
                              short value,
                              int index)
```
    返回数组中指定元素所在最后的位置，未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    index - 索引
    
    Returns:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Since:
    
    3.0.7
  - 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
    
    Since:
    
    3.0.7
  - indexOf
```
public static int indexOf(char[] array,
                          char value,
                          int index)
```
    返回数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    index - 索引
    
    Returns:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Since:
    
    3.0.7
  - lastIndexOf
```
public static int lastIndexOf(char[] array,
                              char value)
```
    返回数组中指定元素所在最后的位置，未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Since:
    
    3.0.7
  - lastIndexOf
```
public static int lastIndexOf(char[] array,
                              char value,
                              int index)
```
    返回数组中指定元素所在最后的位置，未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    index - 索引
    
    Returns:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Since:
    
    3.0.7
  - 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
    
    Since:
    
    3.0.7
  - indexOf
```
public static int indexOf(byte[] array,
                          byte value,
                          int index)
```
    返回数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    index - 索引
    
    Returns:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Since:
    
    3.0.7
  - lastIndexOf
```
public static int lastIndexOf(byte[] array,
                              byte value)
```
    返回数组中指定元素所在最后的位置，未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Since:
    
    3.0.7
  - lastIndexOf
```
public static int lastIndexOf(byte[] array,
                              byte value,
                              int index)
```
    返回数组中指定元素所在最后的位置，未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    index - 索引
    
    Returns:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Since:
    
    3.0.7
  - 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
    
    Since:
    
    3.0.7
  - indexOf
```
public static int indexOf(double[] array,
                          double value,
                          double tolerance)
```
    返回数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    tolerance - 容差
    
    Returns:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Since:
    
    3.0.7
  - indexOf
```
public static int indexOf(double[] array,
                          double value,
                          int index)
```
    返回数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    index - 索引
    
    Returns:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Since:
    
    3.0.7
  - 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
    
    Since:
    
    3.0.7
  - lastIndexOf
```
public static int lastIndexOf(double[] array,
                              double value)
```
    返回数组中指定元素所在最后的位置，未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Since:
    
    3.0.7
  - lastIndexOf
```
public static int lastIndexOf(double[] array,
                              double value,
                              double tolerance)
```
    返回数组中指定元素所在最后的位置，未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    tolerance - 容差
    
    Returns:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Since:
    
    3.0.7
  - lastIndexOf
```
public static int lastIndexOf(double[] array,
                              double value,
                              int index)
```
    返回数组中指定元素所在最后的位置，未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    index - 索引
    
    Returns:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Since:
    
    3.0.7
  - 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
    
    Since:
    
    3.0.7
  - 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
    
    Since:
    
    3.0.7
  - indexOf
```
public static int indexOf(float[] array,
                          float value)
```
    返回数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Since:
    
    3.0.7
  - indexOf
```
public static int indexOf(float[] array,
                          float value,
                          int index)
```
    返回数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    index - 索引
    
    Returns:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Since:
    
    3.0.7
  - lastIndexOf
```
public static int lastIndexOf(float[] array,
                              float value)
```
    返回数组中指定元素所在最后的位置，未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Since:
    
    3.0.7
  - lastIndexOf
```
public static int lastIndexOf(float[] array,
                              float value,
                              int index)
```
    返回数组中指定元素所在最后的位置，未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    index - 索引
    
    Returns:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Since:
    
    3.0.7
  - 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
    
    Since:
    
    3.0.7
  - indexOf
```
public static int indexOf(boolean[] array,
                          boolean value,
                          int index)
```
    返回数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    index - 索引
    
    Returns:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Since:
    
    3.0.7
  - lastIndexOf
```
public static int lastIndexOf(boolean[] array,
                              boolean value)
```
    返回数组中指定元素所在最后的位置，未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Since:
    
    3.0.7
  - lastIndexOf
```
public static int lastIndexOf(boolean[] array,
                              boolean value,
                              int index)
```
    返回数组中指定元素所在最后的位置，未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    index - 索引
    
    Returns:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Since:
    
    3.0.7
  - contains
```
public static boolean contains(boolean[] array,
                               boolean value)
```
    数组中是否包含元素
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    是否包含
  - toPrimitive
```
public static char[] toPrimitive(Character[] array)
```
    Converts an array of object Characters to primitives.
    This method returns null for a null input array.
    
    Parameters:
    
    array - a Character array, may be null
    
    Returns:
    
    a char array, null if null array input
    
    Throws:
    
    NullPointerException - if array content is null
  - toPrimitive
```
public static char[] toPrimitive(Character[] array,
                                 char valueForNull)
```
    Converts an array of object Character to primitives handling null.
    This method returns null for a null input array.
    
    Parameters:
    
    array - a Character array, may be null
    
    valueForNull - the value to insert if null found
    
    Returns:
    
    a char array, null if null array input
  - toObject
```
public static Character[] toObject(char[] array)
```
    Converts an array of primitive chars to objects.
    This method returns null for a null input array.
    
    Parameters:
    
    array - a char array
    
    Returns:
    
    a Character array, null if null array input
  - toPrimitive
```
public static long[] toPrimitive(Long[] array)
```
    Converts an array of object Longs to primitives.
    This method returns null for a null input array.
    
    Parameters:
    
    array - a Long array, may be null
    
    Returns:
    
    a long array, null if null array input
  - toPrimitive
```
public static long[] toPrimitive(Long[] array,
                                 long valueForNull)
```
    Converts an array of object Long to primitives handling null.
    This method returns null for a null input array.
    
    Parameters:
    
    array - a Long array, may be null
    
    valueForNull - the value to insert if null found
    
    Returns:
    
    a long array, null if null array input
  - toObject
```
public static Long[] toObject(long[] array)
```
    Converts an array of primitive longs to objects.
    This method returns null for a null input array.
    
    Parameters:
    
    array - a long array
    
    Returns:
    
    a Long array, null if null array input
  - toPrimitive
```
public static int[] toPrimitive(Integer[] array)
```
    Converts an array of object Integers to primitives.
    This method returns null for a null input array.
    
    Parameters:
    
    array - a Integer array, may be null
    
    Returns:
    
    an int array, null if null array input
    
    Throws:
    
    NullPointerException - if array content is null
  - toPrimitive
```
public static int[] toPrimitive(Integer[] array,
                                int valueForNull)
```
    Converts an array of object Integer to primitives handling null.
    This method returns null for a null input array.
    
    Parameters:
    
    array - a Integer array, may be null
    
    valueForNull - the value to insert if null found
    
    Returns:
    
    an int array, null if null array input
  - toObject
```
public static Integer[] toObject(int[] array)
```
    Converts an array of primitive ints to objects.
    This method returns null for a null input array.
    
    Parameters:
    
    array - an int array
    
    Returns:
    
    an Integer array, null if null array input
  - toPrimitive
```
public static short[] toPrimitive(Short[] array)
```
    Converts an array of object Shorts to primitives.
    This method returns null for a null input array.
    
    Parameters:
    
    array - a Short array, may be null
    
    Returns:
    
    a byte array, null if null array input
    
    Throws:
    
    NullPointerException - if array content is null
  - toPrimitive
```
public static short[] toPrimitive(Short[] array,
                                  short valueForNull)
```
    Converts an array of object Short to primitives handling null.
    This method returns null for a null input array.
    
    Parameters:
    
    array - a Short array, may be null
    
    valueForNull - the value to insert if null found
    
    Returns:
    
    a byte array, null if null array input
  - toObject
```
public static Short[] toObject(short[] array)
```
    Converts an array of primitive shorts to objects.
    This method returns null for a null input array.
    
    Parameters:
    
    array - a short array
    
    Returns:
    
    a Short array, null if null array input
  - toPrimitive
```
public static byte[] toPrimitive(Byte[] array)
```
    Converts an array of object Bytes to primitives.
    This method returns null for a null input array.
    
    Parameters:
    
    array - a Byte array, may be null
    
    Returns:
    
    a byte array, null if null array input
    
    Throws:
    
    NullPointerException - if array content is null
  - toPrimitive
```
public static byte[] toPrimitive(Byte[] array,
                                 byte valueForNull)
```
    Converts an array of object Bytes to primitives handling null.
    This method returns null for a null input array.
    
    Parameters:
    
    array - a Byte array, may be null
    
    valueForNull - the value to insert if null found
    
    Returns:
    
    a byte array, null if null array input
  - toObject
```
public static Byte[] toObject(byte[] array)
```
    Converts an array of primitive bytes to objects.
    This method returns null for a null input array.
    
    Parameters:
    
    array - a byte array
    
    Returns:
    
    a Byte array, null if null array input
  - toPrimitive
```
public static double[] toPrimitive(Double[] array)
```
    Converts an array of object Doubles to primitives.
    This method returns null for a null input array.
    
    Parameters:
    
    array - a Double array, may be null
    
    Returns:
    
    a double array, null if null array input
    
    Throws:
    
    NullPointerException - if array content is null
  - toPrimitive
```
public static double[] toPrimitive(Double[] array,
                                   double valueForNull)
```
    Converts an array of object Doubles to primitives handling null.
    This method returns null for a null input array.
    
    Parameters:
    
    array - a Double array, may be null
    
    valueForNull - the value to insert if null found
    
    Returns:
    
    a double array, null if null array input
  - toObject
```
public static Double[] toObject(double[] array)
```
    Converts an array of primitive doubles to objects.
    This method returns null for a null input array.
    
    Parameters:
    
    array - a double array
    
    Returns:
    
    a Double array, null if null array input
  - toPrimitive
```
public static float[] toPrimitive(Float[] array)
```
    Converts an array of object Floats to primitives.
    This method returns null for a null input array.
    
    Parameters:
    
    array - a Float array, may be null
    
    Returns:
    
    a float array, null if null array input
    
    Throws:
    
    NullPointerException - if array content is null
  - toPrimitive
```
public static float[] toPrimitive(Float[] array,
                                  float valueForNull)
```
    Converts an array of object Floats to primitives handling null.
    This method returns null for a null input array.
    
    Parameters:
    
    array - a Float array, may be null
    
    valueForNull - the value to insert if null found
    
    Returns:
    
    a float array, null if null array input
  - toObject
```
public static Float[] toObject(float[] array)
```
    Converts an array of primitive floats to objects.
    This method returns null for a null input array.
    
    Parameters:
    
    array - a float array
    
    Returns:
    
    a Float array, null if null array input
  - toPrimitive
```
public static Object toPrimitive(Object array)
```
    Create an array of primitive type from an array of wrapper types.
    This method returns null for a null input array.
    
    Parameters:
    
    array - an array of wrapper object
    
    Returns:
    
    an array of the corresponding primitive type, or the original array
    
    Since:
    
    3.5
  - toPrimitive
```
public static boolean[] toPrimitive(Boolean[] array)
```
    Converts an array of object Booleans to primitives.
    This method returns null for a null input array.
    
    Parameters:
    
    array - a Boolean array, may be null
    
    Returns:
    
    a boolean array, null if null array input
    
    Throws:
    
    NullPointerException - if array content is null
  - toPrimitive
```
public static boolean[] toPrimitive(Boolean[] array,
                                    boolean valueForNull)
```
    Converts an array of object Booleans to primitives handling null.
    This method returns null for a null input array.
    
    Parameters:
    
    array - a Boolean array, may be null
    
    valueForNull - the value to insert if null found
    
    Returns:
    
    a boolean array, null if null array input
  - toObject
```
public static Boolean[] toObject(boolean[] array)
```
    Converts an array of primitive booleans to objects.
    This method returns null for a null input array.
    
    Parameters:
    
    array - a boolean array
    
    Returns:
    
    a Boolean array, null if null array input
  - isEmpty
```
public static boolean isEmpty(Object array)
```
    数组是否为空
    此方法会匹配单一对象，如果此对象为null则返回true
    如果此对象为非数组，理解为此对象为数组的第一个元素，则返回false
    如果此对象为数组对象，数组长度大于0情况下返回false，否则返回true
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    是否为空
  - isEmpty
```
public static boolean isEmpty(Object[] array)
```
    数组是否为空
    此方法会匹配单一对象，如果此对象为null则返回true
    如果此对象为非数组，理解为此对象为数组的第一个元素，则返回false
    如果此对象为数组对象，数组长度大于0情况下返回false，否则返回true
    
    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:
    
    是否为非空
  - addAll
```
public static <T> T[] addAll(T[] array1,
                             T... array2)
```
    Adds all the elements of the given arrays into a new array.
    The new array contains all of the element of array1 followed by all of the elements array2. When an array is returned, it is always a new array.
```
 ArrayUtils.addAll(null, null)     = null
 ArrayUtils.addAll(array1, null)   = cloned copy of array1
 ArrayUtils.addAll(null, array2)   = cloned copy of array2
 ArrayUtils.addAll([], [])         = []
 ArrayUtils.addAll([null], [null]) = [null, null]
 ArrayUtils.addAll(["a", "b", "c"], ["1", "2", "3"]) = ["a", "b", "c", "1", "2", "3"]
 
```
    Type Parameters:
    
    T - the component type of the array
    
    Parameters:
    
    array1 - the first array whose elements are added to the new array, may be null
    
    array2 - the second array whose elements are added to the new array, may be null
    
    Returns:
    
    The new array, null if both arrays are null. The type of the new array is the type of the first array, unless the first array is null, in which case the type is the same as the second array.
    
    Throws:
    
    IllegalArgumentException - if the array types are incompatible
    
    Since:
    
    2.1
  - addAll
```
public static boolean[] addAll(boolean[] array1,
                               boolean... array2)
```
    Adds all the elements of the given arrays into a new array.
    The new array contains all of the element of array1 followed by all of the elements array2. When an array is returned, it is always a new array.
```
 ArrayUtils.addAll(array1, null)   = cloned copy of array1
 ArrayUtils.addAll(null, array2)   = cloned copy of array2
 ArrayUtils.addAll([], [])         = []
 
```
    Parameters:
    
    array1 - the first array whose elements are added to the new array.
    
    array2 - the second array whose elements are added to the new array.
    
    Returns:
    
    The new boolean[] array.
    
    Since:
    
    2.1
  - addAll
```
public static char[] addAll(char[] array1,
                            char... array2)
```
    Adds all the elements of the given arrays into a new array.
    The new array contains all of the element of array1 followed by all of the elements array2. When an array is returned, it is always a new array.
```
 ArrayUtils.addAll(array1, null)   = cloned copy of array1
 ArrayUtils.addAll(null, array2)   = cloned copy of array2
 ArrayUtils.addAll([], [])         = []
 
```
    Parameters:
    
    array1 - the first array whose elements are added to the new array.
    
    array2 - the second array whose elements are added to the new array.
    
    Returns:
    
    The new char[] array.
    
    Since:
    
    2.1
  - addAll
```
public static byte[] addAll(byte[] array1,
                            byte... array2)
```
    Adds all the elements of the given arrays into a new array.
    The new array contains all of the element of array1 followed by all of the elements array2. When an array is returned, it is always a new array.
```
 ArrayUtils.addAll(array1, null)   = cloned copy of array1
 ArrayUtils.addAll(null, array2)   = cloned copy of array2
 ArrayUtils.addAll([], [])         = []
 
```
    Parameters:
    
    array1 - the first array whose elements are added to the new array.
    
    array2 - the second array whose elements are added to the new array.
    
    Returns:
    
    The new byte[] array.
    
    Since:
    
    2.1
  - addAll
```
public static short[] addAll(short[] array1,
                             short... array2)
```
    Adds all the elements of the given arrays into a new array.
    The new array contains all of the element of array1 followed by all of the elements array2. When an array is returned, it is always a new array.
```
 ArrayUtils.addAll(array1, null)   = cloned copy of array1
 ArrayUtils.addAll(null, array2)   = cloned copy of array2
 ArrayUtils.addAll([], [])         = []
 
```
    Parameters:
    
    array1 - the first array whose elements are added to the new array.
    
    array2 - the second array whose elements are added to the new array.
    
    Returns:
    
    The new short[] array.
    
    Since:
    
    2.1
  - addAll
```
public static int[] addAll(int[] array1,
                           int... array2)
```
    Adds all the elements of the given arrays into a new array.
    The new array contains all of the element of array1 followed by all of the elements array2. When an array is returned, it is always a new array.
```
 ArrayUtils.addAll(array1, null)   = cloned copy of array1
 ArrayUtils.addAll(null, array2)   = cloned copy of array2
 ArrayUtils.addAll([], [])         = []
 
```
    Parameters:
    
    array1 - the first array whose elements are added to the new array.
    
    array2 - the second array whose elements are added to the new array.
    
    Returns:
    
    The new int[] array.
    
    Since:
    
    2.1
  - addAll
```
public static long[] addAll(long[] array1,
                            long... array2)
```
    Adds all the elements of the given arrays into a new array.
    The new array contains all of the element of array1 followed by all of the elements array2. When an array is returned, it is always a new array.
```
 ArrayUtils.addAll(array1, null)   = cloned copy of array1
 ArrayUtils.addAll(null, array2)   = cloned copy of array2
 ArrayUtils.addAll([], [])         = []
 
```
    Parameters:
    
    array1 - the first array whose elements are added to the new array.
    
    array2 - the second array whose elements are added to the new array.
    
    Returns:
    
    The new long[] array.
    
    Since:
    
    2.1
  - addAll
```
public static float[] addAll(float[] array1,
                             float... array2)
```
    Adds all the elements of the given arrays into a new array.
    The new array contains all of the element of array1 followed by all of the elements array2. When an array is returned, it is always a new array.
```
 ArrayUtils.addAll(array1, null)   = cloned copy of array1
 ArrayUtils.addAll(null, array2)   = cloned copy of array2
 ArrayUtils.addAll([], [])         = []
 
```
    Parameters:
    
    array1 - the first array whose elements are added to the new array.
    
    array2 - the second array whose elements are added to the new array.
    
    Returns:
    
    The new float[] array.
    
    Since:
    
    2.1
  - addAll
```
public static double[] addAll(double[] array1,
                              double... array2)
```
    Adds all the elements of the given arrays into a new array.
    The new array contains all of the element of array1 followed by all of the elements array2. When an array is returned, it is always a new array.
```
 ArrayUtils.addAll(array1, null)   = cloned copy of array1
 ArrayUtils.addAll(null, array2)   = cloned copy of array2
 ArrayUtils.addAll([], [])         = []
 
```
    Parameters:
    
    array1 - the first array whose elements are added to the new array.
    
    array2 - the second array whose elements are added to the new array.
    
    Returns:
    
    The new double[] array.
    
    Since:
    
    2.1
  - add
```
public static <T> T[] add(T[] array,
                          T element)
```
    Copies the given array and adds the given element at the end of the new array.
    The new array contains the same elements of the input array plus the given element in the last position. The component type of the new array is the same as that of the input array.
    If the input array is null, a new one element array is returned whose component type is the same as the element, unless the element itself is null, in which case the return type is Object[]
```
 ArrayUtils.add(null, null)      = IllegalArgumentException
 ArrayUtils.add(null, "a")       = ["a"]
 ArrayUtils.add(["a"], null)     = ["a", null]
 ArrayUtils.add(["a"], "b")      = ["a", "b"]
 ArrayUtils.add(["a", "b"], "c") = ["a", "b", "c"]
 
```
    Type Parameters:
    
    T - the component type of the array
    
    Parameters:
    
    array - the array to "add" the element to, may be null
    
    element - the object to add, may be null
    
    Returns:
    
    A new array containing the existing elements plus the new element The returned array type will be that of the input array (unless null), in which case it will have the same type as the element. If both are null, an IllegalArgumentException is thrown
    
    Throws:
    
    IllegalArgumentException - if both arguments are null
    
    Since:
    
    2.1
  - add
```
public static boolean[] add(boolean[] array,
                            boolean element)
```
    Copies the given array and adds the given element at the end of the new array.
    The new array contains the same elements of the input array plus the given element in the last position. The component type of the new array is the same as that of the input array.
    If the input array is null, a new one element array is returned whose component type is the same as the element.
```
 ArrayUtils.add(null, true)          = [true]
 ArrayUtils.add([true], false)       = [true, false]
 ArrayUtils.add([true, false], true) = [true, false, true]
 
```
    Parameters:
    
    array - the array to copy and add the element to, may be null
    
    element - the object to add at the last index of the new array
    
    Returns:
    
    A new array containing the existing elements plus the new element
    
    Since:
    
    2.1
  - add
```
public static byte[] add(byte[] array,
                         byte element)
```
    Copies the given array and adds the given element at the end of the new array.
    The new array contains the same elements of the input array plus the given element in the last position. The component type of the new array is the same as that of the input array.
    If the input array is null, a new one element array is returned whose component type is the same as the element.
```
 ArrayUtils.add(null, 0)   = [0]
 ArrayUtils.add([1], 0)    = [1, 0]
 ArrayUtils.add([1, 0], 1) = [1, 0, 1]
 
```
    Parameters:
    
    array - the array to copy and add the element to, may be null
    
    element - the object to add at the last index of the new array
    
    Returns:
    
    A new array containing the existing elements plus the new element
    
    Since:
    
    2.1
  - add
```
public static char[] add(char[] array,
                         char element)
```
    Copies the given array and adds the given element at the end of the new array.
    The new array contains the same elements of the input array plus the given element in the last position. The component type of the new array is the same as that of the input array.
    If the input array is null, a new one element array is returned whose component type is the same as the element.
```
 ArrayUtils.add(null, '0')       = ['0']
 ArrayUtils.add(['1'], '0')      = ['1', '0']
 ArrayUtils.add(['1', '0'], '1') = ['1', '0', '1']
 
```
    Parameters:
    
    array - the array to copy and add the element to, may be null
    
    element - the object to add at the last index of the new array
    
    Returns:
    
    A new array containing the existing elements plus the new element
    
    Since:
    
    2.1
  - add
```
public static double[] add(double[] array,
                           double element)
```
    Copies the given array and adds the given element at the end of the new array.
    The new array contains the same elements of the input array plus the given element in the last position. The component type of the new array is the same as that of the input array.
    If the input array is null, a new one element array is returned whose component type is the same as the element.
```
 ArrayUtils.add(null, 0)   = [0]
 ArrayUtils.add([1], 0)    = [1, 0]
 ArrayUtils.add([1, 0], 1) = [1, 0, 1]
 
```
    Parameters:
    
    array - the array to copy and add the element to, may be null
    
    element - the object to add at the last index of the new array
    
    Returns:
    
    A new array containing the existing elements plus the new element
    
    Since:
    
    2.1
  - add
```
public static float[] add(float[] array,
                          float element)
```
    Copies the given array and adds the given element at the end of the new array.
    The new array contains the same elements of the input array plus the given element in the last position. The component type of the new array is the same as that of the input array.
    If the input array is null, a new one element array is returned whose component type is the same as the element.
```
 ArrayUtils.add(null, 0)   = [0]
 ArrayUtils.add([1], 0)    = [1, 0]
 ArrayUtils.add([1, 0], 1) = [1, 0, 1]
 
```
    Parameters:
    
    array - the array to copy and add the element to, may be null
    
    element - the object to add at the last index of the new array
    
    Returns:
    
    A new array containing the existing elements plus the new element
    
    Since:
    
    2.1
  - add
```
public static int[] add(int[] array,
                        int element)
```
    Copies the given array and adds the given element at the end of the new array.
    The new array contains the same elements of the input array plus the given element in the last position. The component type of the new array is the same as that of the input array.
    If the input array is null, a new one element array is returned whose component type is the same as the element.
```
 ArrayUtils.add(null, 0)   = [0]
 ArrayUtils.add([1], 0)    = [1, 0]
 ArrayUtils.add([1, 0], 1) = [1, 0, 1]
 
```
    Parameters:
    
    array - the array to copy and add the element to, may be null
    
    element - the object to add at the last index of the new array
    
    Returns:
    
    A new array containing the existing elements plus the new element
    
    Since:
    
    2.1
  - add
```
public static long[] add(long[] array,
                         long element)
```
    Copies the given array and adds the given element at the end of the new array.
    The new array contains the same elements of the input array plus the given element in the last position. The component type of the new array is the same as that of the input array.
    If the input array is null, a new one element array is returned whose component type is the same as the element.
```
 ArrayUtils.add(null, 0)   = [0]
 ArrayUtils.add([1], 0)    = [1, 0]
 ArrayUtils.add([1, 0], 1) = [1, 0, 1]
 
```
    Parameters:
    
    array - the array to copy and add the element to, may be null
    
    element - the object to add at the last index of the new array
    
    Returns:
    
    A new array containing the existing elements plus the new element
    
    Since:
    
    2.1
  - add
```
public static short[] add(short[] array,
                          short element)
```
    Copies the given array and adds the given element at the end of the new array.
    The new array contains the same elements of the input array plus the given element in the last position. The component type of the new array is the same as that of the input array.
    If the input array is null, a new one element array is returned whose component type is the same as the element.
```
 ArrayUtils.add(null, 0)   = [0]
 ArrayUtils.add([1], 0)    = [1, 0]
 ArrayUtils.add([1, 0], 1) = [1, 0, 1]
 
```
    Parameters:
    
    array - the array to copy and add the element to, may be null
    
    element - the object to add at the last index of the new array
    
    Returns:
    
    A new array containing the existing elements plus the new element
    
    Since:
    
    2.1
  - add
```
public static <T> T[] add(T[] array,
                          int index,
                          T element)
```
    Inserts the specified element at the specified position in the array. Shifts the element currently at that position (if any) and any subsequent elements to the right (adds one to their indices).
    This method returns a new array with the same elements of the input array plus the given element on the specified position. The component type of the returned array is always the same as that of the input array.
    If the input array is null, a new one element array is returned whose component type is the same as the element.
```
 ArrayUtils.add(null, 0, null)      = IllegalArgumentException
 ArrayUtils.add(null, 0, "a")       = ["a"]
 ArrayUtils.add(["a"], 1, null)     = ["a", null]
 ArrayUtils.add(["a"], 1, "b")      = ["a", "b"]
 ArrayUtils.add(["a", "b"], 3, "c") = ["a", "b", "c"]
 
```
    Type Parameters:
    
    T - the component type of the array
    
    Parameters:
    
    array - the array to add the element to, may be null
    
    index - the position of the new object
    
    element - the object to add
    
    Returns:
    
    A new array containing the existing elements and the new element
    
    Throws:
    
    IndexOutOfBoundsException - if the index is out of range (index < 0 || index > array.length).
    
    IllegalArgumentException - if both array and element are null may be removed in a future release. Please note the handling of null input arrays differs in the new method: inserting X into a null array results in null not X.
  - add
```
public static boolean[] add(boolean[] array,
                            int index,
                            boolean element)
```
    Inserts the specified element at the specified position in the array. Shifts the element currently at that position (if any) and any subsequent elements to the right (adds one to their indices).
    This method returns a new array with the same elements of the input array plus the given element on the specified position. The component type of the returned array is always the same as that of the input array.
    If the input array is null, a new one element array is returned whose component type is the same as the element.
```
 ArrayUtils.add(null, 0, true)          = [true]
 ArrayUtils.add([true], 0, false)       = [false, true]
 ArrayUtils.add([false], 1, true)       = [false, true]
 ArrayUtils.add([true, false], 1, true) = [true, true, false]
 
```
    Parameters:
    
    array - the array to add the element to, may be null
    
    index - the position of the new object
    
    element - the object to add
    
    Returns:
    
    A new array containing the existing elements and the new element
    
    Throws:
    
    IndexOutOfBoundsException - if the index is out of range (index < 0 || index > array.length). may be removed in a future release. Please note the handling of null input arrays differs in the new method: inserting X into a null array results in null not X.
  - add
```
public static char[] add(char[] array,
                         int index,
                         char element)
```
    Inserts the specified element at the specified position in the array. Shifts the element currently at that position (if any) and any subsequent elements to the right (adds one to their indices).
    This method returns a new array with the same elements of the input array plus the given element on the specified position. The component type of the returned array is always the same as that of the input array.
    If the input array is null, a new one element array is returned whose component type is the same as the element.
```
 ArrayUtils.add(null, 0, 'a')            = ['a']
 ArrayUtils.add(['a'], 0, 'b')           = ['b', 'a']
 ArrayUtils.add(['a', 'b'], 0, 'c')      = ['c', 'a', 'b']
 ArrayUtils.add(['a', 'b'], 1, 'k')      = ['a', 'k', 'b']
 ArrayUtils.add(['a', 'b', 'c'], 1, 't') = ['a', 't', 'b', 'c']
 
```
    Parameters:
    
    array - the array to add the element to, may be null
    
    index - the position of the new object
    
    element - the object to add
    
    Returns:
    
    A new array containing the existing elements and the new element
    
    Throws:
    
    IndexOutOfBoundsException - if the index is out of range (index < 0 || index > array.length).
  - add
```
public static byte[] add(byte[] array,
                         int index,
                         byte element)
```
    Inserts the specified element at the specified position in the array. Shifts the element currently at that position (if any) and any subsequent elements to the right (adds one to their indices).
    This method returns a new array with the same elements of the input array plus the given element on the specified position. The component type of the returned array is always the same as that of the input array.
    If the input array is null, a new one element array is returned whose component type is the same as the element.
```
 ArrayUtils.add([1], 0, 2)         = [2, 1]
 ArrayUtils.add([2, 6], 2, 3)      = [2, 6, 3]
 ArrayUtils.add([2, 6], 0, 1)      = [1, 2, 6]
 ArrayUtils.add([2, 6, 3], 2, 1)   = [2, 6, 1, 3]
 
```
    Parameters:
    
    array - the array to add the element to, may be null
    
    index - the position of the new object
    
    element - the object to add
    
    Returns:
    
    A new array containing the existing elements and the new element
    
    Throws:
    
    IndexOutOfBoundsException - if the index is out of range (index < 0 || index > array.length).
  - add
```
public static short[] add(short[] array,
                          int index,
                          short element)
```
    Inserts the specified element at the specified position in the array. Shifts the element currently at that position (if any) and any subsequent elements to the right (adds one to their indices).
    This method returns a new array with the same elements of the input array plus the given element on the specified position. The component type of the returned array is always the same as that of the input array.
    If the input array is null, a new one element array is returned whose component type is the same as the element.
```
 ArrayUtils.add([1], 0, 2)         = [2, 1]
 ArrayUtils.add([2, 6], 2, 10)     = [2, 6, 10]
 ArrayUtils.add([2, 6], 0, -4)     = [-4, 2, 6]
 ArrayUtils.add([2, 6, 3], 2, 1)   = [2, 6, 1, 3]
 
```
    Parameters:
    
    array - the array to add the element to, may be null
    
    index - the position of the new object
    
    element - the object to add
    
    Returns:
    
    A new array containing the existing elements and the new element
    
    Throws:
    
    IndexOutOfBoundsException - if the index is out of range (index < 0 || index > array.length).
  - add
```
public static int[] add(int[] array,
                        int index,
                        int element)
```
    Inserts the specified element at the specified position in the array. Shifts the element currently at that position (if any) and any subsequent elements to the right (adds one to their indices).
    This method returns a new array with the same elements of the input array plus the given element on the specified position. The component type of the returned array is always the same as that of the input array.
    If the input array is null, a new one element array is returned whose component type is the same as the element.
```
 ArrayUtils.add([1], 0, 2)         = [2, 1]
 ArrayUtils.add([2, 6], 2, 10)     = [2, 6, 10]
 ArrayUtils.add([2, 6], 0, -4)     = [-4, 2, 6]
 ArrayUtils.add([2, 6, 3], 2, 1)   = [2, 6, 1, 3]
 
```
    Parameters:
    
    array - the array to add the element to, may be null
    
    index - the position of the new object
    
    element - the object to add
    
    Returns:
    
    A new array containing the existing elements and the new element
    
    Throws:
    
    IndexOutOfBoundsException - if the index is out of range (index < 0 || index > array.length).
  - add
```
public static long[] add(long[] array,
                         int index,
                         long element)
```
    Inserts the specified element at the specified position in the array. Shifts the element currently at that position (if any) and any subsequent elements to the right (adds one to their indices).
    This method returns a new array with the same elements of the input array plus the given element on the specified position. The component type of the returned array is always the same as that of the input array.
    If the input array is null, a new one element array is returned whose component type is the same as the element.
```
 ArrayUtils.add([1L], 0, 2L)           = [2L, 1L]
 ArrayUtils.add([2L, 6L], 2, 10L)      = [2L, 6L, 10L]
 ArrayUtils.add([2L, 6L], 0, -4L)      = [-4L, 2L, 6L]
 ArrayUtils.add([2L, 6L, 3L], 2, 1L)   = [2L, 6L, 1L, 3L]
 
```
    Parameters:
    
    array - the array to add the element to, may be null
    
    index - the position of the new object
    
    element - the object to add
    
    Returns:
    
    A new array containing the existing elements and the new element
    
    Throws:
    
    IndexOutOfBoundsException - if the index is out of range (index < 0 || index > array.length).
  - add
```
public static float[] add(float[] array,
                          int index,
                          float element)
```
    Inserts the specified element at the specified position in the array. Shifts the element currently at that position (if any) and any subsequent elements to the right (adds one to their indices).
    This method returns a new array with the same elements of the input array plus the given element on the specified position. The component type of the returned array is always the same as that of the input array.
    If the input array is null, a new one element array is returned whose component type is the same as the element.
```
 ArrayUtils.add([1.1f], 0, 2.2f)               = [2.2f, 1.1f]
 ArrayUtils.add([2.3f, 6.4f], 2, 10.5f)        = [2.3f, 6.4f, 10.5f]
 ArrayUtils.add([2.6f, 6.7f], 0, -4.8f)        = [-4.8f, 2.6f, 6.7f]
 ArrayUtils.add([2.9f, 6.0f, 0.3f], 2, 1.0f)   = [2.9f, 6.0f, 1.0f, 0.3f]
 
```
    Parameters:
    
    array - the array to add the element to, may be null
    
    index - the position of the new object
    
    element - the object to add
    
    Returns:
    
    A new array containing the existing elements and the new element
    
    Throws:
    
    IndexOutOfBoundsException - if the index is out of range (index < 0 || index > array.length).
  - add
```
public static double[] add(double[] array,
                           int index,
                           double element)
```
    Inserts the specified element at the specified position in the array. Shifts the element currently at that position (if any) and any subsequent elements to the right (adds one to their indices).
    This method returns a new array with the same elements of the input array plus the given element on the specified position. The component type of the returned array is always the same as that of the input array.
    If the input array is null, a new one element array is returned whose component type is the same as the element.
```
 ArrayUtils.add([1.1], 0, 2.2)              = [2.2, 1.1]
 ArrayUtils.add([2.3, 6.4], 2, 10.5)        = [2.3, 6.4, 10.5]
 ArrayUtils.add([2.6, 6.7], 0, -4.8)        = [-4.8, 2.6, 6.7]
 ArrayUtils.add([2.9, 6.0, 0.3], 2, 1.0)    = [2.9, 6.0, 1.0, 0.3]
 
```
    Parameters:
    
    array - the array to add the element to, may be null
    
    index - the position of the new object
    
    element - the object to add
    
    Returns:
    
    A new array containing the existing elements and the new element
    
    Throws:
    
    IndexOutOfBoundsException - if the index is out of range (index < 0 || index > array.length).
  - remove
```
public static <T> T[] remove(T[] array,
                             int index)
```
    Removes the element at the specified position from the specified array. All subsequent elements are shifted to the left (subtracts one from their indices).
    This method returns a new array with the same elements of the input array except the element on the specified position. The component type of the returned array is always the same as that of the input array.
    If the input array is null, an IndexOutOfBoundsException will be thrown, because in that case no valid index can be specified.
```
 ArrayUtils.remove(["a"], 0)           = []
 ArrayUtils.remove(["a", "b"], 0)      = ["b"]
 ArrayUtils.remove(["a", "b"], 1)      = ["a"]
 ArrayUtils.remove(["a", "b", "c"], 1) = ["a", "c"]
 
```
    Type Parameters:
    
    T - the component type of the array
    
    Parameters:
    
    array - the array to remove the element from, may not be null
    
    index - the position of the element to be removed
    
    Returns:
    
    A new array containing the existing elements except the element at the specified position.
    
    Throws:
    
    IndexOutOfBoundsException - if the index is out of range (index < 0 || index >= array.length), or if the array is null.
  - removeElement
```
public static <T> T[] removeElement(T[] array,
                                    Object element)
```
    Removes the first occurrence of the specified element from the specified array. All subsequent elements are shifted to the left (subtracts one from their indices). If the array doesn't contains such an element, no elements are removed from the array.
    This method returns a new array with the same elements of the input array except the first occurrence of the specified element. The component type of the returned array is always the same as that of the input array.
```
 ArrayUtils.removeElement(null, "a")            = null
 ArrayUtils.removeElement([], "a")              = []
 ArrayUtils.removeElement(["a"], "b")           = ["a"]
 ArrayUtils.removeElement(["a", "b"], "a")      = ["b"]
 ArrayUtils.removeElement(["a", "b", "a"], "a") = ["b", "a"]
 
```
    Type Parameters:
    
    T - the component type of the array
    
    Parameters:
    
    array - the array to remove the element from, may be null
    
    element - the element to be removed
    
    Returns:
    
    A new array containing the existing elements except the first occurrence of the specified element.
    
    Since:
    
    2.1
  - remove
```
public static boolean[] remove(boolean[] array,
                               int index)
```
    Removes the element at the specified position from the specified array. All subsequent elements are shifted to the left (subtracts one from their indices).
    This method returns a new array with the same elements of the input array except the element on the specified position. The component type of the returned array is always the same as that of the input array.
    If the input array is null, an IndexOutOfBoundsException will be thrown, because in that case no valid index can be specified.
```
 ArrayUtils.remove([true], 0)              = []
 ArrayUtils.remove([true, false], 0)       = [false]
 ArrayUtils.remove([true, false], 1)       = [true]
 ArrayUtils.remove([true, true, false], 1) = [true, false]
 
```
    Parameters:
    
    array - the array to remove the element from, may not be null
    
    index - the position of the element to be removed
    
    Returns:
    
    A new array containing the existing elements except the element at the specified position.
    
    Throws:
    
    IndexOutOfBoundsException - if the index is out of range (index < 0 || index >= array.length), or if the array is null.
    
    Since:
    
    2.1
  - removeElement
```
public static boolean[] removeElement(boolean[] array,
                                      boolean element)
```
    Removes the first occurrence of the specified element from the specified array. All subsequent elements are shifted to the left (subtracts one from their indices). If the array doesn't contains such an element, no elements are removed from the array.
    This method returns a new array with the same elements of the input array except the first occurrence of the specified element. The component type of the returned array is always the same as that of the input array.
```
 ArrayUtils.removeElement(null, true)                = null
 ArrayUtils.removeElement([], true)                  = []
 ArrayUtils.removeElement([true], false)             = [true]
 ArrayUtils.removeElement([true, false], false)      = [true]
 ArrayUtils.removeElement([true, false, true], true) = [false, true]
 
```
    Parameters:
    
    array - the array to remove the element from, may be null
    
    element - the element to be removed
    
    Returns:
    
    A new array containing the existing elements except the first occurrence of the specified element.
    
    Since:
    
    2.1
  - remove
```
public static byte[] remove(byte[] array,
                            int index)
```
    Removes the element at the specified position from the specified array. All subsequent elements are shifted to the left (subtracts one from their indices).
    This method returns a new array with the same elements of the input array except the element on the specified position. The component type of the returned array is always the same as that of the input array.
    If the input array is null, an IndexOutOfBoundsException will be thrown, because in that case no valid index can be specified.
```
 ArrayUtils.remove([1], 0)          = []
 ArrayUtils.remove([1, 0], 0)       = [0]
 ArrayUtils.remove([1, 0], 1)       = [1]
 ArrayUtils.remove([1, 0, 1], 1)    = [1, 1]
 
```
    Parameters:
    
    array - the array to remove the element from, may not be null
    
    index - the position of the element to be removed
    
    Returns:
    
    A new array containing the existing elements except the element at the specified position.
    
    Throws:
    
    IndexOutOfBoundsException - if the index is out of range (index < 0 || index >= array.length), or if the array is null.
    
    Since:
    
    2.1
  - removeElement
```
public static byte[] removeElement(byte[] array,
                                   byte element)
```
    Removes the first occurrence of the specified element from the specified array. All subsequent elements are shifted to the left (subtracts one from their indices). If the array doesn't contains such an element, no elements are removed from the array.
    This method returns a new array with the same elements of the input array except the first occurrence of the specified element. The component type of the returned array is always the same as that of the input array.
```
 ArrayUtils.removeElement(null, 1)        = null
 ArrayUtils.removeElement([], 1)          = []
 ArrayUtils.removeElement([1], 0)         = [1]
 ArrayUtils.removeElement([1, 0], 0)      = [1]
 ArrayUtils.removeElement([1, 0, 1], 1)   = [0, 1]
 
```
    Parameters:
    
    array - the array to remove the element from, may be null
    
    element - the element to be removed
    
    Returns:
    
    A new array containing the existing elements except the first occurrence of the specified element.
    
    Since:
    
    2.1
  - remove
```
public static char[] remove(char[] array,
                            int index)
```
    Removes the element at the specified position from the specified array. All subsequent elements are shifted to the left (subtracts one from their indices).
    This method returns a new array with the same elements of the input array except the element on the specified position. The component type of the returned array is always the same as that of the input array.
    If the input array is null, an IndexOutOfBoundsException will be thrown, because in that case no valid index can be specified.
```
 ArrayUtils.remove(['a'], 0)           = []
 ArrayUtils.remove(['a', 'b'], 0)      = ['b']
 ArrayUtils.remove(['a', 'b'], 1)      = ['a']
 ArrayUtils.remove(['a', 'b', 'c'], 1) = ['a', 'c']
 
```
    Parameters:
    
    array - the array to remove the element from, may not be null
    
    index - the position of the element to be removed
    
    Returns:
    
    A new array containing the existing elements except the element at the specified position.
    
    Throws:
    
    IndexOutOfBoundsException - if the index is out of range (index < 0 || index >= array.length), or if the array is null.
    
    Since:
    
    2.1
  - removeElement
```
public static char[] removeElement(char[] array,
                                   char element)
```
    Removes the first occurrence of the specified element from the specified array. All subsequent elements are shifted to the left (subtracts one from their indices). If the array doesn't contains such an element, no elements are removed from the array.
    This method returns a new array with the same elements of the input array except the first occurrence of the specified element. The component type of the returned array is always the same as that of the input array.
```
 ArrayUtils.removeElement(null, 'a')            = null
 ArrayUtils.removeElement([], 'a')              = []
 ArrayUtils.removeElement(['a'], 'b')           = ['a']
 ArrayUtils.removeElement(['a', 'b'], 'a')      = ['b']
 ArrayUtils.removeElement(['a', 'b', 'a'], 'a') = ['b', 'a']
 
```
    Parameters:
    
    array - the array to remove the element from, may be null
    
    element - the element to be removed
    
    Returns:
    
    A new array containing the existing elements except the first occurrence of the specified element.
    
    Since:
    
    2.1
  - remove
```
public static double[] remove(double[] array,
                              int index)
```
    Removes the element at the specified position from the specified array. All subsequent elements are shifted to the left (subtracts one from their indices).
    This method returns a new array with the same elements of the input array except the element on the specified position. The component type of the returned array is always the same as that of the input array.
    If the input array is null, an IndexOutOfBoundsException will be thrown, because in that case no valid index can be specified.
```
 ArrayUtils.remove([1.1], 0)           = []
 ArrayUtils.remove([2.5, 6.0], 0)      = [6.0]
 ArrayUtils.remove([2.5, 6.0], 1)      = [2.5]
 ArrayUtils.remove([2.5, 6.0, 3.8], 1) = [2.5, 3.8]
 
```
    Parameters:
    
    array - the array to remove the element from, may not be null
    
    index - the position of the element to be removed
    
    Returns:
    
    A new array containing the existing elements except the element at the specified position.
    
    Throws:
    
    IndexOutOfBoundsException - if the index is out of range (index < 0 || index >= array.length), or if the array is null.
    
    Since:
    
    2.1
  - removeElement
```
public static double[] removeElement(double[] array,
                                     double element)
```
    Removes the first occurrence of the specified element from the specified array. All subsequent elements are shifted to the left (subtracts one from their indices). If the array doesn't contains such an element, no elements are removed from the array.
    This method returns a new array with the same elements of the input array except the first occurrence of the specified element. The component type of the returned array is always the same as that of the input array.
```
 ArrayUtils.removeElement(null, 1.1)            = null
 ArrayUtils.removeElement([], 1.1)              = []
 ArrayUtils.removeElement([1.1], 1.2)           = [1.1]
 ArrayUtils.removeElement([1.1, 2.3], 1.1)      = [2.3]
 ArrayUtils.removeElement([1.1, 2.3, 1.1], 1.1) = [2.3, 1.1]
 
```
    Parameters:
    
    array - the array to remove the element from, may be null
    
    element - the element to be removed
    
    Returns:
    
    A new array containing the existing elements except the first occurrence of the specified element.
    
    Since:
    
    2.1
  - remove
```
public static float[] remove(float[] array,
                             int index)
```
    Removes the element at the specified position from the specified array. All subsequent elements are shifted to the left (subtracts one from their indices).
    This method returns a new array with the same elements of the input array except the element on the specified position. The component type of the returned array is always the same as that of the input array.
    If the input array is null, an IndexOutOfBoundsException will be thrown, because in that case no valid index can be specified.
```
 ArrayUtils.remove([1.1], 0)           = []
 ArrayUtils.remove([2.5, 6.0], 0)      = [6.0]
 ArrayUtils.remove([2.5, 6.0], 1)      = [2.5]
 ArrayUtils.remove([2.5, 6.0, 3.8], 1) = [2.5, 3.8]
 
```
    Parameters:
    
    array - the array to remove the element from, may not be null
    
    index - the position of the element to be removed
    
    Returns:
    
    A new array containing the existing elements except the element at the specified position.
    
    Throws:
    
    IndexOutOfBoundsException - if the index is out of range (index < 0 || index >= array.length), or if the array is null.
    
    Since:
    
    2.1
  - removeElement
```
public static float[] removeElement(float[] array,
                                    float element)
```
    Removes the first occurrence of the specified element from the specified array. All subsequent elements are shifted to the left (subtracts one from their indices). If the array doesn't contains such an element, no elements are removed from the array.
    This method returns a new array with the same elements of the input array except the first occurrence of the specified element. The component type of the returned array is always the same as that of the input array.
```
 ArrayUtils.removeElement(null, 1.1)            = null
 ArrayUtils.removeElement([], 1.1)              = []
 ArrayUtils.removeElement([1.1], 1.2)           = [1.1]
 ArrayUtils.removeElement([1.1, 2.3], 1.1)      = [2.3]
 ArrayUtils.removeElement([1.1, 2.3, 1.1], 1.1) = [2.3, 1.1]
 
```
    Parameters:
    
    array - the array to remove the element from, may be null
    
    element - the element to be removed
    
    Returns:
    
    A new array containing the existing elements except the first occurrence of the specified element.
    
    Since:
    
    2.1
  - remove
```
public static int[] remove(int[] array,
                           int index)
```
    Removes the element at the specified position from the specified array. All subsequent elements are shifted to the left (subtracts one from their indices).
    This method returns a new array with the same elements of the input array except the element on the specified position. The component type of the returned array is always the same as that of the input array.
    If the input array is null, an IndexOutOfBoundsException will be thrown, because in that case no valid index can be specified.
```
 ArrayUtils.remove([1], 0)         = []
 ArrayUtils.remove([2, 6], 0)      = [6]
 ArrayUtils.remove([2, 6], 1)      = [2]
 ArrayUtils.remove([2, 6, 3], 1)   = [2, 3]
 
```
    Parameters:
    
    array - the array to remove the element from, may not be null
    
    index - the position of the element to be removed
    
    Returns:
    
    A new array containing the existing elements except the element at the specified position.
    
    Throws:
    
    IndexOutOfBoundsException - if the index is out of range (index < 0 || index >= array.length), or if the array is null.
    
    Since:
    
    2.1
  - removeElement
```
public static int[] removeElement(int[] array,
                                  int element)
```
    Removes the first occurrence of the specified element from the specified array. All subsequent elements are shifted to the left (subtracts one from their indices). If the array doesn't contains such an element, no elements are removed from the array.
    This method returns a new array with the same elements of the input array except the first occurrence of the specified element. The component type of the returned array is always the same as that of the input array.
```
 ArrayUtils.removeElement(null, 1)      = null
 ArrayUtils.removeElement([], 1)        = []
 ArrayUtils.removeElement([1], 2)       = [1]
 ArrayUtils.removeElement([1, 3], 1)    = [3]
 ArrayUtils.removeElement([1, 3, 1], 1) = [3, 1]
 
```
    Parameters:
    
    array - the array to remove the element from, may be null
    
    element - the element to be removed
    
    Returns:
    
    A new array containing the existing elements except the first occurrence of the specified element.
    
    Since:
    
    2.1
  - remove
```
public static long[] remove(long[] array,
                            int index)
```
    Removes the element at the specified position from the specified array. All subsequent elements are shifted to the left (subtracts one from their indices).
    This method returns a new array with the same elements of the input array except the element on the specified position. The component type of the returned array is always the same as that of the input array.
    If the input array is null, an IndexOutOfBoundsException will be thrown, because in that case no valid index can be specified.
```
 ArrayUtils.remove([1], 0)         = []
 ArrayUtils.remove([2, 6], 0)      = [6]
 ArrayUtils.remove([2, 6], 1)      = [2]
 ArrayUtils.remove([2, 6, 3], 1)   = [2, 3]
 
```
    Parameters:
    
    array - the array to remove the element from, may not be null
    
    index - the position of the element to be removed
    
    Returns:
    
    A new array containing the existing elements except the element at the specified position.
    
    Throws:
    
    IndexOutOfBoundsException - if the index is out of range (index < 0 || index >= array.length), or if the array is null.
    
    Since:
    
    2.1
  - removeElement
```
public static long[] removeElement(long[] array,
                                   long element)
```
    Removes the first occurrence of the specified element from the specified array. All subsequent elements are shifted to the left (subtracts one from their indices). If the array doesn't contains such an element, no elements are removed from the array.
    This method returns a new array with the same elements of the input array except the first occurrence of the specified element. The component type of the returned array is always the same as that of the input array.
```
 ArrayUtils.removeElement(null, 1)      = null
 ArrayUtils.removeElement([], 1)        = []
 ArrayUtils.removeElement([1], 2)       = [1]
 ArrayUtils.removeElement([1, 3], 1)    = [3]
 ArrayUtils.removeElement([1, 3, 1], 1) = [3, 1]
 
```
    Parameters:
    
    array - the array to remove the element from, may be null
    
    element - the element to be removed
    
    Returns:
    
    A new array containing the existing elements except the first occurrence of the specified element.
    
    Since:
    
    2.1
  - remove
```
public static short[] remove(short[] array,
                             int index)
```
    Removes the element at the specified position from the specified array. All subsequent elements are shifted to the left (subtracts one from their indices).
    This method returns a new array with the same elements of the input array except the element on the specified position. The component type of the returned array is always the same as that of the input array.
    If the input array is null, an IndexOutOfBoundsException will be thrown, because in that case no valid index can be specified.
```
 ArrayUtils.remove([1], 0)         = []
 ArrayUtils.remove([2, 6], 0)      = [6]
 ArrayUtils.remove([2, 6], 1)      = [2]
 ArrayUtils.remove([2, 6, 3], 1)   = [2, 3]
 
```
    Parameters:
    
    array - the array to remove the element from, may not be null
    
    index - the position of the element to be removed
    
    Returns:
    
    A new array containing the existing elements except the element at the specified position.
    
    Throws:
    
    IndexOutOfBoundsException - if the index is out of range (index < 0 || index >= array.length), or if the array is null.
    
    Since:
    
    2.1
  - removeElement
```
public static short[] removeElement(short[] array,
                                    short element)
```
    Removes the first occurrence of the specified element from the specified array. All subsequent elements are shifted to the left (subtracts one from their indices). If the array doesn't contains such an element, no elements are removed from the array.
    This method returns a new array with the same elements of the input array except the first occurrence of the specified element. The component type of the returned array is always the same as that of the input array.
```
 ArrayUtils.removeElement(null, 1)      = null
 ArrayUtils.removeElement([], 1)        = []
 ArrayUtils.removeElement([1], 2)       = [1]
 ArrayUtils.removeElement([1, 3], 1)    = [3]
 ArrayUtils.removeElement([1, 3, 1], 1) = [3, 1]
 
```
    Parameters:
    
    array - the array to remove the element from, may be null
    
    element - the element to be removed
    
    Returns:
    
    A new array containing the existing elements except the first occurrence of the specified element.
    
    Since:
    
    2.1
  - removeAll
```
public static <T> T[] removeAll(T[] array,
                                int... indices)
```
    Removes the elements at the specified positions from the specified array. All remaining elements are shifted to the left.
    This method returns a new array with the same elements of the input array except those at the specified positions. The component type of the returned array is always the same as that of the input array.
    If the input array is null, an IndexOutOfBoundsException will be thrown, because in that case no valid index can be specified.
```
 ArrayUtils.removeAll(["a", "b", "c"], 0, 2) = ["b"]
 ArrayUtils.removeAll(["a", "b", "c"], 1, 2) = ["a"]
 
```
    Type Parameters:
    
    T - the component type of the array
    
    Parameters:
    
    array - the array to remove the element from, may not be null
    
    indices - the positions of the elements to be removed
    
    Returns:
    
    A new array containing the existing elements except those at the specified positions.
    
    Throws:
    
    IndexOutOfBoundsException - if any index is out of range (index < 0 || index >= array.length), or if the array is null.
    
    Since:
    
    3.0.1
  - removeElements
```
public static <T> T[] removeElements(T[] array,
                                     T... values)
```
    Removes occurrences of specified elements, in specified quantities, from the specified array. All subsequent elements are shifted left. For any element-to-be-removed specified in greater quantities than contained in the original array, no change occurs beyond the removal of the existing matching items.
    This method returns a new array with the same elements of the input array except for the earliest-encountered occurrences of the specified elements. The component type of the returned array is always the same as that of the input array.
```
 ArrayUtils.removeElements(null, "a", "b")            = null
 ArrayUtils.removeElements([], "a", "b")              = []
 ArrayUtils.removeElements(["a"], "b", "c")           = ["a"]
 ArrayUtils.removeElements(["a", "b"], "a", "c")      = ["b"]
 ArrayUtils.removeElements(["a", "b", "a"], "a")      = ["b", "a"]
 ArrayUtils.removeElements(["a", "b", "a"], "a", "a") = ["b"]
 
```
    Type Parameters:
    
    T - the component type of the array
    
    Parameters:
    
    array - the array to remove the element from, may be null
    
    values - the elements to be removed
    
    Returns:
    
    A new array containing the existing elements except the earliest-encountered occurrences of the specified elements.
    
    Since:
    
    3.0.1
  - removeAll
```
public static byte[] removeAll(byte[] array,
                               int... indices)
```
    Removes the elements at the specified positions from the specified array. All remaining elements are shifted to the left.
    This method returns a new array with the same elements of the input array except those at the specified positions. The component type of the returned array is always the same as that of the input array.
    If the input array is null, an IndexOutOfBoundsException will be thrown, because in that case no valid index can be specified.
```
 ArrayUtils.removeAll([1], 0)             = []
 ArrayUtils.removeAll([2, 6], 0)          = [6]
 ArrayUtils.removeAll([2, 6], 0, 1)       = []
 ArrayUtils.removeAll([2, 6, 3], 1, 2)    = [2]
 ArrayUtils.removeAll([2, 6, 3], 0, 2)    = [6]
 ArrayUtils.removeAll([2, 6, 3], 0, 1, 2) = []
 
```
    Parameters:
    
    array - the array to remove the element from, may not be null
    
    indices - the positions of the elements to be removed
    
    Returns:
    
    A new array containing the existing elements except those at the specified positions.
    
    Throws:
    
    IndexOutOfBoundsException - if any index is out of range (index < 0 || index >= array.length), or if the array is null.
    
    Since:
    
    3.0.1
  - removeElements
```
public static byte[] removeElements(byte[] array,
                                    byte... values)
```
    Removes occurrences of specified elements, in specified quantities, from the specified array. All subsequent elements are shifted left. For any element-to-be-removed specified in greater quantities than contained in the original array, no change occurs beyond the removal of the existing matching items.
    This method returns a new array with the same elements of the input array except for the earliest-encountered occurrences of the specified elements. The component type of the returned array is always the same as that of the input array.
```
 ArrayUtils.removeElements(null, 1, 2)      = null
 ArrayUtils.removeElements([], 1, 2)        = []
 ArrayUtils.removeElements([1], 2, 3)       = [1]
 ArrayUtils.removeElements([1, 3], 1, 2)    = [3]
 ArrayUtils.removeElements([1, 3, 1], 1)    = [3, 1]
 ArrayUtils.removeElements([1, 3, 1], 1, 1) = [3]
 
```
    Parameters:
    
    array - the array to remove the element from, may be null
    
    values - the elements to be removed
    
    Returns:
    
    A new array containing the existing elements except the earliest-encountered occurrences of the specified elements.
    
    Since:
    
    3.0.1
  - removeAll
```
public static short[] removeAll(short[] array,
                                int... indices)
```
    Removes the elements at the specified positions from the specified array. All remaining elements are shifted to the left.
    This method returns a new array with the same elements of the input array except those at the specified positions. The component type of the returned array is always the same as that of the input array.
    If the input array is null, an IndexOutOfBoundsException will be thrown, because in that case no valid index can be specified.
```
 ArrayUtils.removeAll([1], 0)             = []
 ArrayUtils.removeAll([2, 6], 0)          = [6]
 ArrayUtils.removeAll([2, 6], 0, 1)       = []
 ArrayUtils.removeAll([2, 6, 3], 1, 2)    = [2]
 ArrayUtils.removeAll([2, 6, 3], 0, 2)    = [6]
 ArrayUtils.removeAll([2, 6, 3], 0, 1, 2) = []
 
```
    Parameters:
    
    array - the array to remove the element from, may not be null
    
    indices - the positions of the elements to be removed
    
    Returns:
    
    A new array containing the existing elements except those at the specified positions.
    
    Throws:
    
    IndexOutOfBoundsException - if any index is out of range (index < 0 || index >= array.length), or if the array is null.
    
    Since:
    
    3.0.1
  - removeElements
```
public static short[] removeElements(short[] array,
                                     short... values)
```
    Removes occurrences of specified elements, in specified quantities, from the specified array. All subsequent elements are shifted left. For any element-to-be-removed specified in greater quantities than contained in the original array, no change occurs beyond the removal of the existing matching items.
    This method returns a new array with the same elements of the input array except for the earliest-encountered occurrences of the specified elements. The component type of the returned array is always the same as that of the input array.
```
 ArrayUtils.removeElements(null, 1, 2)      = null
 ArrayUtils.removeElements([], 1, 2)        = []
 ArrayUtils.removeElements([1], 2, 3)       = [1]
 ArrayUtils.removeElements([1, 3], 1, 2)    = [3]
 ArrayUtils.removeElements([1, 3, 1], 1)    = [3, 1]
 ArrayUtils.removeElements([1, 3, 1], 1, 1) = [3]
 
```
    Parameters:
    
    array - the array to remove the element from, may be null
    
    values - the elements to be removed
    
    Returns:
    
    A new array containing the existing elements except the earliest-encountered occurrences of the specified elements.
    
    Since:
    
    3.0.1
  - removeAll
```
public static int[] removeAll(int[] array,
                              int... indices)
```
    Removes the elements at the specified positions from the specified array. All remaining elements are shifted to the left.
    This method returns a new array with the same elements of the input array except those at the specified positions. The component type of the returned array is always the same as that of the input array.
    If the input array is null, an IndexOutOfBoundsException will be thrown, because in that case no valid index can be specified.
```
 ArrayUtils.removeAll([1], 0)             = []
 ArrayUtils.removeAll([2, 6], 0)          = [6]
 ArrayUtils.removeAll([2, 6], 0, 1)       = []
 ArrayUtils.removeAll([2, 6, 3], 1, 2)    = [2]
 ArrayUtils.removeAll([2, 6, 3], 0, 2)    = [6]
 ArrayUtils.removeAll([2, 6, 3], 0, 1, 2) = []
 
```
    Parameters:
    
    array - the array to remove the element from, may not be null
    
    indices - the positions of the elements to be removed
    
    Returns:
    
    A new array containing the existing elements except those at the specified positions.
    
    Throws:
    
    IndexOutOfBoundsException - if any index is out of range (index < 0 || index >= array.length), or if the array is null.
    
    Since:
    
    3.0.1
  - removeElements
```
public static int[] removeElements(int[] array,
                                   int... values)
```
    Removes occurrences of specified elements, in specified quantities, from the specified array. All subsequent elements are shifted left. For any element-to-be-removed specified in greater quantities than contained in the original array, no change occurs beyond the removal of the existing matching items.
    This method returns a new array with the same elements of the input array except for the earliest-encountered occurrences of the specified elements. The component type of the returned array is always the same as that of the input array.
```
 ArrayUtils.removeElements(null, 1, 2)      = null
 ArrayUtils.removeElements([], 1, 2)        = []
 ArrayUtils.removeElements([1], 2, 3)       = [1]
 ArrayUtils.removeElements([1, 3], 1, 2)    = [3]
 ArrayUtils.removeElements([1, 3, 1], 1)    = [3, 1]
 ArrayUtils.removeElements([1, 3, 1], 1, 1) = [3]
 
```
    Parameters:
    
    array - the array to remove the element from, may be null
    
    values - the elements to be removed
    
    Returns:
    
    A new array containing the existing elements except the earliest-encountered occurrences of the specified elements.
    
    Since:
    
    3.0.1
  - removeAll
```
public static char[] removeAll(char[] array,
                               int... indices)
```
    Removes the elements at the specified positions from the specified array. All remaining elements are shifted to the left.
    This method returns a new array with the same elements of the input array except those at the specified positions. The component type of the returned array is always the same as that of the input array.
    If the input array is null, an IndexOutOfBoundsException will be thrown, because in that case no valid index can be specified.
```
 ArrayUtils.removeAll([1], 0)             = []
 ArrayUtils.removeAll([2, 6], 0)          = [6]
 ArrayUtils.removeAll([2, 6], 0, 1)       = []
 ArrayUtils.removeAll([2, 6, 3], 1, 2)    = [2]
 ArrayUtils.removeAll([2, 6, 3], 0, 2)    = [6]
 ArrayUtils.removeAll([2, 6, 3], 0, 1, 2) = []
 
```
    Parameters:
    
    array - the array to remove the element from, may not be null
    
    indices - the positions of the elements to be removed
    
    Returns:
    
    A new array containing the existing elements except those at the specified positions.
    
    Throws:
    
    IndexOutOfBoundsException - if any index is out of range (index < 0 || index >= array.length), or if the array is null.
    
    Since:
    
    3.0.1
  - removeElements
```
public static char[] removeElements(char[] array,
                                    char... values)
```
    Removes occurrences of specified elements, in specified quantities, from the specified array. All subsequent elements are shifted left. For any element-to-be-removed specified in greater quantities than contained in the original array, no change occurs beyond the removal of the existing matching items.
    This method returns a new array with the same elements of the input array except for the earliest-encountered occurrences of the specified elements. The component type of the returned array is always the same as that of the input array.
```
 ArrayUtils.removeElements(null, 1, 2)      = null
 ArrayUtils.removeElements([], 1, 2)        = []
 ArrayUtils.removeElements([1], 2, 3)       = [1]
 ArrayUtils.removeElements([1, 3], 1, 2)    = [3]
 ArrayUtils.removeElements([1, 3, 1], 1)    = [3, 1]
 ArrayUtils.removeElements([1, 3, 1], 1, 1) = [3]
 
```
    Parameters:
    
    array - the array to remove the element from, may be null
    
    values - the elements to be removed
    
    Returns:
    
    A new array containing the existing elements except the earliest-encountered occurrences of the specified elements.
    
    Since:
    
    3.0.1
  - removeAll
```
public static long[] removeAll(long[] array,
                               int... indices)
```
    Removes the elements at the specified positions from the specified array. All remaining elements are shifted to the left.
    This method returns a new array with the same elements of the input array except those at the specified positions. The component type of the returned array is always the same as that of the input array.
    If the input array is null, an IndexOutOfBoundsException will be thrown, because in that case no valid index can be specified.
```
 ArrayUtils.removeAll([1], 0)             = []
 ArrayUtils.removeAll([2, 6], 0)          = [6]
 ArrayUtils.removeAll([2, 6], 0, 1)       = []
 ArrayUtils.removeAll([2, 6, 3], 1, 2)    = [2]
 ArrayUtils.removeAll([2, 6, 3], 0, 2)    = [6]
 ArrayUtils.removeAll([2, 6, 3], 0, 1, 2) = []
 
```
    Parameters:
    
    array - the array to remove the element from, may not be null
    
    indices - the positions of the elements to be removed
    
    Returns:
    
    A new array containing the existing elements except those at the specified positions.
    
    Throws:
    
    IndexOutOfBoundsException - if any index is out of range (index < 0 || index >= array.length), or if the array is null.
    
    Since:
    
    3.0.1
  - removeElements
```
public static long[] removeElements(long[] array,
                                    long... values)
```
    Removes occurrences of specified elements, in specified quantities, from the specified array. All subsequent elements are shifted left. For any element-to-be-removed specified in greater quantities than contained in the original array, no change occurs beyond the removal of the existing matching items.
    This method returns a new array with the same elements of the input array except for the earliest-encountered occurrences of the specified elements. The component type of the returned array is always the same as that of the input array.
```
 ArrayUtils.removeElements(null, 1, 2)      = null
 ArrayUtils.removeElements([], 1, 2)        = []
 ArrayUtils.removeElements([1], 2, 3)       = [1]
 ArrayUtils.removeElements([1, 3], 1, 2)    = [3]
 ArrayUtils.removeElements([1, 3, 1], 1)    = [3, 1]
 ArrayUtils.removeElements([1, 3, 1], 1, 1) = [3]
 
```
    Parameters:
    
    array - the array to remove the element from, may be null
    
    values - the elements to be removed
    
    Returns:
    
    A new array containing the existing elements except the earliest-encountered occurrences of the specified elements.
    
    Since:
    
    3.0.1
  - removeAll
```
public static float[] removeAll(float[] array,
                                int... indices)
```
    Removes the elements at the specified positions from the specified array. All remaining elements are shifted to the left.
    This method returns a new array with the same elements of the input array except those at the specified positions. The component type of the returned array is always the same as that of the input array.
    If the input array is null, an IndexOutOfBoundsException will be thrown, because in that case no valid index can be specified.
```
 ArrayUtils.removeAll([1], 0)             = []
 ArrayUtils.removeAll([2, 6], 0)          = [6]
 ArrayUtils.removeAll([2, 6], 0, 1)       = []
 ArrayUtils.removeAll([2, 6, 3], 1, 2)    = [2]
 ArrayUtils.removeAll([2, 6, 3], 0, 2)    = [6]
 ArrayUtils.removeAll([2, 6, 3], 0, 1, 2) = []
 
```
    Parameters:
    
    array - the array to remove the element from, may not be null
    
    indices - the positions of the elements to be removed
    
    Returns:
    
    A new array containing the existing elements except those at the specified positions.
    
    Throws:
    
    IndexOutOfBoundsException - if any index is out of range (index < 0 || index >= array.length), or if the array is null.
    
    Since:
    
    3.0.1
  - removeElements
```
public static float[] removeElements(float[] array,
                                     float... values)
```
    Removes occurrences of specified elements, in specified quantities, from the specified array. All subsequent elements are shifted left. For any element-to-be-removed specified in greater quantities than contained in the original array, no change occurs beyond the removal of the existing matching items.
    This method returns a new array with the same elements of the input array except for the earliest-encountered occurrences of the specified elements. The component type of the returned array is always the same as that of the input array.
```
 ArrayUtils.removeElements(null, 1, 2)      = null
 ArrayUtils.removeElements([], 1, 2)        = []
 ArrayUtils.removeElements([1], 2, 3)       = [1]
 ArrayUtils.removeElements([1, 3], 1, 2)    = [3]
 ArrayUtils.removeElements([1, 3, 1], 1)    = [3, 1]
 ArrayUtils.removeElements([1, 3, 1], 1, 1) = [3]
 
```
    Parameters:
    
    array - the array to remove the element from, may be null
    
    values - the elements to be removed
    
    Returns:
    
    A new array containing the existing elements except the earliest-encountered occurrences of the specified elements.
    
    Since:
    
    3.0.1
  - removeAll
```
public static double[] removeAll(double[] array,
                                 int... indices)
```
    Removes the elements at the specified positions from the specified array. All remaining elements are shifted to the left.
    This method returns a new array with the same elements of the input array except those at the specified positions. The component type of the returned array is always the same as that of the input array.
    If the input array is null, an IndexOutOfBoundsException will be thrown, because in that case no valid index can be specified.
```
 ArrayUtils.removeAll([1], 0)             = []
 ArrayUtils.removeAll([2, 6], 0)          = [6]
 ArrayUtils.removeAll([2, 6], 0, 1)       = []
 ArrayUtils.removeAll([2, 6, 3], 1, 2)    = [2]
 ArrayUtils.removeAll([2, 6, 3], 0, 2)    = [6]
 ArrayUtils.removeAll([2, 6, 3], 0, 1, 2) = []
 
```
    Parameters:
    
    array - the array to remove the element from, may not be null
    
    indices - the positions of the elements to be removed
    
    Returns:
    
    A new array containing the existing elements except those at the specified positions.
    
    Throws:
    
    IndexOutOfBoundsException - if any index is out of range (index < 0 || index >= array.length), or if the array is null.
    
    Since:
    
    3.0.1
  - removeElements
```
public static double[] removeElements(double[] array,
                                      double... values)
```
    Removes occurrences of specified elements, in specified quantities, from the specified array. All subsequent elements are shifted left. For any element-to-be-removed specified in greater quantities than contained in the original array, no change occurs beyond the removal of the existing matching items.
    This method returns a new array with the same elements of the input array except for the earliest-encountered occurrences of the specified elements. The component type of the returned array is always the same as that of the input array.
```
 ArrayUtils.removeElements(null, 1, 2)      = null
 ArrayUtils.removeElements([], 1, 2)        = []
 ArrayUtils.removeElements([1], 2, 3)       = [1]
 ArrayUtils.removeElements([1, 3], 1, 2)    = [3]
 ArrayUtils.removeElements([1, 3, 1], 1)    = [3, 1]
 ArrayUtils.removeElements([1, 3, 1], 1, 1) = [3]
 
```
    Parameters:
    
    array - the array to remove the element from, may be null
    
    values - the elements to be removed
    
    Returns:
    
    A new array containing the existing elements except the earliest-encountered occurrences of the specified elements.
    
    Since:
    
    3.0.1
  - removeAll
```
public static boolean[] removeAll(boolean[] array,
                                  int... indices)
```
    Removes the elements at the specified positions from the specified array. All remaining elements are shifted to the left.
    This method returns a new array with the same elements of the input array except those at the specified positions. The component type of the returned array is always the same as that of the input array.
    If the input array is null, an IndexOutOfBoundsException will be thrown, because in that case no valid index can be specified.
```
 ArrayUtils.removeAll([true, false, true], 0, 2) = [false]
 ArrayUtils.removeAll([true, false, true], 1, 2) = [true]
 
```
    Parameters:
    
    array - the array to remove the element from, may not be null
    
    indices - the positions of the elements to be removed
    
    Returns:
    
    A new array containing the existing elements except those at the specified positions.
    
    Throws:
    
    IndexOutOfBoundsException - if any index is out of range (index < 0 || index >= array.length), or if the array is null.
    
    Since:
    
    3.0.1
  - removeElements
```
public static boolean[] removeElements(boolean[] array,
                                       boolean... values)
```
    Removes occurrences of specified elements, in specified quantities, from the specified array. All subsequent elements are shifted left. For any element-to-be-removed specified in greater quantities than contained in the original array, no change occurs beyond the removal of the existing matching items.
    This method returns a new array with the same elements of the input array except for the earliest-encountered occurrences of the specified elements. The component type of the returned array is always the same as that of the input array.
```
 ArrayUtils.removeElements(null, true, false)               = null
 ArrayUtils.removeElements([], true, false)                 = []
 ArrayUtils.removeElements([true], false, false)            = [true]
 ArrayUtils.removeElements([true, false], true, true)       = [false]
 ArrayUtils.removeElements([true, false, true], true)       = [false, true]
 ArrayUtils.removeElements([true, false, true], true, true) = [false]
 
```
    Parameters:
    
    array - the array to remove the element from, may be null
    
    values - the elements to be removed
    
    Returns:
    
    A new array containing the existing elements except the earliest-encountered occurrences of the specified elements.
    
    Since:
    
    3.0.1
  - isSorted
```
public static <T extends Comparable<? super T>> boolean isSorted(T[] array)
```
    This method checks whether the provided array is sorted according to the class's compareTo method.
    
    Type Parameters:
    
    T - the datatype of the array to check, it must implement Comparable
    
    Parameters:
    
    array - the array to check
    
    Returns:
    
    whether the array is sorted
    
    Since:
    
    3.4
  - isSorted
```
public static <T> boolean isSorted(T[] array,
                                   Comparator<T> comparator)
```
    This method checks whether the provided array is sorted according to the provided Comparator.
    
    Type Parameters:
    
    T - the datatype of the array
    
    Parameters:
    
    array - the array to check
    
    comparator - the Comparator to compare over
    
    Returns:
    
    whether the array is sorted
    
    Since:
    
    3.4
  - isSorted
```
public static boolean isSorted(int[] array)
```
    This method checks whether the provided array is sorted according to natural ordering.
    
    Parameters:
    
    array - the array to check
    
    Returns:
    
    whether the array is sorted according to natural ordering
    
    Since:
    
    3.4
  - isSorted
```
public static boolean isSorted(long[] array)
```
    This method checks whether the provided array is sorted according to natural ordering.
    
    Parameters:
    
    array - the array to check
    
    Returns:
    
    whether the array is sorted according to natural ordering
    
    Since:
    
    3.4
  - isSorted
```
public static boolean isSorted(short[] array)
```
    This method checks whether the provided array is sorted according to natural ordering.
    
    Parameters:
    
    array - the array to check
    
    Returns:
    
    whether the array is sorted according to natural ordering
    
    Since:
    
    3.4
  - isSorted
```
public static boolean isSorted(double[] array)
```
    This method checks whether the provided array is sorted according to natural ordering.
    
    Parameters:
    
    array - the array to check
    
    Returns:
    
    whether the array is sorted according to natural ordering
    
    Since:
    
    3.4
  - isSorted
```
public static boolean isSorted(float[] array)
```
    This method checks whether the provided array is sorted according to natural ordering.
    
    Parameters:
    
    array - the array to check
    
    Returns:
    
    whether the array is sorted according to natural ordering
    
    Since:
    
    3.4
  - isSorted
```
public static boolean isSorted(byte[] array)
```
    This method checks whether the provided array is sorted according to natural ordering.
    
    Parameters:
    
    array - the array to check
    
    Returns:
    
    whether the array is sorted according to natural ordering
    
    Since:
    
    3.4
  - isSorted
```
public static boolean isSorted(char[] array)
```
    This method checks whether the provided array is sorted according to natural ordering.
    
    Parameters:
    
    array - the array to check
    
    Returns:
    
    whether the array is sorted according to natural ordering
    
    Since:
    
    3.4
  - isSorted
```
public static boolean isSorted(boolean[] array)
```
    This method checks whether the provided array is sorted according to natural ordering (false before true).
    
    Parameters:
    
    array - the array to check
    
    Returns:
    
    whether the array is sorted according to natural ordering
    
    Since:
    
    3.4
  - removeAllOccurences
```
public static boolean[] removeAllOccurences(boolean[] array,
                                            boolean element)
```
    Removes the occurrences of the specified element from the specified boolean array.
    All subsequent elements are shifted to the left (subtracts one from their indices). If the array doesn't contains such an element, no elements are removed from the array. null will be returned if the input array is null.
    
    Parameters:
    
    element - the element to remove
    
    array - the input array
    
    Returns:
    
    A new array containing the existing elements except the occurrences of the specified element.
    
    Since:
    
    3.5
  - removeAllOccurences
```
public static char[] removeAllOccurences(char[] array,
                                         char element)
```
    Removes the occurrences of the specified element from the specified char array.
    All subsequent elements are shifted to the left (subtracts one from their indices). If the array doesn't contains such an element, no elements are removed from the array. null will be returned if the input array is null.
    
    Parameters:
    
    element - the element to remove
    
    array - the input array
    
    Returns:
    
    A new array containing the existing elements except the occurrences of the specified element.
    
    Since:
    
    3.5
  - removeAllOccurences
```
public static byte[] removeAllOccurences(byte[] array,
                                         byte element)
```
    Removes the occurrences of the specified element from the specified byte array.
    All subsequent elements are shifted to the left (subtracts one from their indices). If the array doesn't contains such an element, no elements are removed from the array. null will be returned if the input array is null.
    
    Parameters:
    
    element - the element to remove
    
    array - the input array
    
    Returns:
    
    A new array containing the existing elements except the occurrences of the specified element.
    
    Since:
    
    3.5
  - removeAllOccurences
```
public static short[] removeAllOccurences(short[] array,
                                          short element)
```
    Removes the occurrences of the specified element from the specified short array.
    All subsequent elements are shifted to the left (subtracts one from their indices). If the array doesn't contains such an element, no elements are removed from the array. null will be returned if the input array is null.
    
    Parameters:
    
    element - the element to remove
    
    array - the input array
    
    Returns:
    
    A new array containing the existing elements except the occurrences of the specified element.
    
    Since:
    
    3.5
  - removeAllOccurences
```
public static int[] removeAllOccurences(int[] array,
                                        int element)
```
    Removes the occurrences of the specified element from the specified int array.
    All subsequent elements are shifted to the left (subtracts one from their indices). If the array doesn't contains such an element, no elements are removed from the array. null will be returned if the input array is null.
    
    Parameters:
    
    element - the element to remove
    
    array - the input array
    
    Returns:
    
    A new array containing the existing elements except the occurrences of the specified element.
    
    Since:
    
    3.5
  - removeAllOccurences
```
public static long[] removeAllOccurences(long[] array,
                                         long element)
```
    Removes the occurrences of the specified element from the specified long array.
    All subsequent elements are shifted to the left (subtracts one from their indices). If the array doesn't contains such an element, no elements are removed from the array. null will be returned if the input array is null.
    
    Parameters:
    
    element - the element to remove
    
    array - the input array
    
    Returns:
    
    A new array containing the existing elements except the occurrences of the specified element.
    
    Since:
    
    3.5
  - removeAllOccurences
```
public static float[] removeAllOccurences(float[] array,
                                          float element)
```
    Removes the occurrences of the specified element from the specified float array.
    All subsequent elements are shifted to the left (subtracts one from their indices). If the array doesn't contains such an element, no elements are removed from the array. null will be returned if the input array is null.
    
    Parameters:
    
    element - the element to remove
    
    array - the input array
    
    Returns:
    
    A new array containing the existing elements except the occurrences of the specified element.
    
    Since:
    
    3.5
  - removeAllOccurences
```
public static double[] removeAllOccurences(double[] array,
                                           double element)
```
    Removes the occurrences of the specified element from the specified double array.
    All subsequent elements are shifted to the left (subtracts one from their indices). If the array doesn't contains such an element, no elements are removed from the array. null will be returned if the input array is null.
    
    Parameters:
    
    element - the element to remove
    
    array - the input array
    
    Returns:
    
    A new array containing the existing elements except the occurrences of the specified element.
    
    Since:
    
    3.5
  - removeAllOccurences
```
public static <T> T[] removeAllOccurences(T[] array,
                                          T element)
```
    Removes the occurrences of the specified element from the specified array.
    All subsequent elements are shifted to the left (subtracts one from their indices). If the array doesn't contains such an element, no elements are removed from the array. null will be returned if the input array is null.
    
    Type Parameters:
    
    T - the type of object in the array
    
    Parameters:
    
    element - the element to remove
    
    array - the input array
    
    Returns:
    
    A new array containing the existing elements except the occurrences of the specified element.
    
    Since:
    
    3.5
  - toStringArray
```
public static String[] toStringArray(Object[] array)
```
    Returns an array containing the string representation of each element in the argument array.
    
    This method returns null for a null input array.
    
    Parameters:
    
    array - the Object[] to be processed, may be null
    
    Returns:
    
    String[] of the same size as the source with its element's string representation, null if null array input
    
    Throws:
    
    NullPointerException - if array contains null
    
    Since:
    
    3.6
  - toStringArray
```
public static String[] toStringArray(Object[] array,
                                     String valueForNullElements)
```
    Returns an array containing the string representation of each element in the argument array handling null elements.
    
    This method returns null for a null input array.
    
    Parameters:
    
    array - the Object[] to be processed, may be null
    
    valueForNullElements - the value to insert if null is found
    
    Returns:
    
    a String array, null if null array input
    
    Since:
    
    3.6
  - insert
```
public static <T> Object insert(Object array,
                                int index,
                                T... newElements)
```
    将新元素插入到到已有数组中的某个位置
    添加新元素会生成一个新的数组，不影响原数组
    如果插入位置为为负数，从原数组从后向前计数，若大于原数组长度，则空白处用null填充
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 已有数组
    
    index - 插入位置，此位置为对应此位置元素之前的空档
    
    newElements - 新元素
    
    Returns:
    
    新数组
    
    Since:
    
    4.0.8
  - insert
```
public static boolean[] insert(int index,
                               boolean[] array,
                               boolean... values)
```
    Inserts elements into an array at the given index (starting from zero).
    
    When an array is returned, it is always a new array.
```
 ArrayUtils.insert(index, null, null)      = null
 ArrayUtils.insert(index, array, null)     = cloned copy of 'array'
 ArrayUtils.insert(index, null, values)    = null
 
```
    Parameters:
    
    index - the position within array to insert the new values
    
    array - the array to insert the values into, may be null
    
    values - the new values to insert, may be null
    
    Returns:
    
    The new array.
    
    Throws:
    
    IndexOutOfBoundsException - if array is provided and either index < 0 or index > array.length
    
    Since:
    
    3.6
  - insert
```
public static byte[] insert(int index,
                            byte[] array,
                            byte... values)
```
    Inserts elements into an array at the given index (starting from zero).
    
    When an array is returned, it is always a new array.
```
 ArrayUtils.insert(index, null, null)      = null
 ArrayUtils.insert(index, array, null)     = cloned copy of 'array'
 ArrayUtils.insert(index, null, values)    = null
 
```
    Parameters:
    
    index - the position within array to insert the new values
    
    array - the array to insert the values into, may be null
    
    values - the new values to insert, may be null
    
    Returns:
    
    The new array.
    
    Throws:
    
    IndexOutOfBoundsException - if array is provided and either index < 0 or index > array.length
    
    Since:
    
    3.6
  - insert
```
public static char[] insert(int index,
                            char[] array,
                            char... values)
```
    Inserts elements into an array at the given index (starting from zero).
    
    When an array is returned, it is always a new array.
```
 ArrayUtils.insert(index, null, null)      = null
 ArrayUtils.insert(index, array, null)     = cloned copy of 'array'
 ArrayUtils.insert(index, null, values)    = null
 
```
    Parameters:
    
    index - the position within array to insert the new values
    
    array - the array to insert the values into, may be null
    
    values - the new values to insert, may be null
    
    Returns:
    
    The new array.
    
    Throws:
    
    IndexOutOfBoundsException - if array is provided and either index < 0 or index > array.length
    
    Since:
    
    3.6
  - insert
```
public static double[] insert(int index,
                              double[] array,
                              double... values)
```
    Inserts elements into an array at the given index (starting from zero).
    
    When an array is returned, it is always a new array.
```
 ArrayUtils.insert(index, null, null)      = null
 ArrayUtils.insert(index, array, null)     = cloned copy of 'array'
 ArrayUtils.insert(index, null, values)    = null
 
```
    Parameters:
    
    index - the position within array to insert the new values
    
    array - the array to insert the values into, may be null
    
    values - the new values to insert, may be null
    
    Returns:
    
    The new array.
    
    Throws:
    
    IndexOutOfBoundsException - if array is provided and either index < 0 or index > array.length
    
    Since:
    
    3.6
  - insert
```
public static float[] insert(int index,
                             float[] array,
                             float... values)
```
    Inserts elements into an array at the given index (starting from zero).
    
    When an array is returned, it is always a new array.
```
 ArrayUtils.insert(index, null, null)      = null
 ArrayUtils.insert(index, array, null)     = cloned copy of 'array'
 ArrayUtils.insert(index, null, values)    = null
 
```
    Parameters:
    
    index - the position within array to insert the new values
    
    array - the array to insert the values into, may be null
    
    values - the new values to insert, may be null
    
    Returns:
    
    The new array.
    
    Throws:
    
    IndexOutOfBoundsException - if array is provided and either index < 0 or index > array.length
    
    Since:
    
    3.6
  - insert
```
public static int[] insert(int index,
                           int[] array,
                           int... values)
```
    Inserts elements into an array at the given index (starting from zero).
    
    When an array is returned, it is always a new array.
```
 ArrayUtils.insert(index, null, null)      = null
 ArrayUtils.insert(index, array, null)     = cloned copy of 'array'
 ArrayUtils.insert(index, null, values)    = null
 
```
    Parameters:
    
    index - the position within array to insert the new values
    
    array - the array to insert the values into, may be null
    
    values - the new values to insert, may be null
    
    Returns:
    
    The new array.
    
    Throws:
    
    IndexOutOfBoundsException - if array is provided and either index < 0 or index > array.length
    
    Since:
    
    3.6
  - insert
```
public static long[] insert(int index,
                            long[] array,
                            long... values)
```
    Inserts elements into an array at the given index (starting from zero).
    
    When an array is returned, it is always a new array.
```
 ArrayUtils.insert(index, null, null)      = null
 ArrayUtils.insert(index, array, null)     = cloned copy of 'array'
 ArrayUtils.insert(index, null, values)    = null
 
```
    Parameters:
    
    index - the position within array to insert the new values
    
    array - the array to insert the values into, may be null
    
    values - the new values to insert, may be null
    
    Returns:
    
    The new array.
    
    Throws:
    
    IndexOutOfBoundsException - if array is provided and either index < 0 or index > array.length
    
    Since:
    
    3.6
  - insert
```
public static short[] insert(int index,
                             short[] array,
                             short... values)
```
    Inserts elements into an array at the given index (starting from zero).
    
    When an array is returned, it is always a new array.
```
 ArrayUtils.insert(index, null, null)      = null
 ArrayUtils.insert(index, array, null)     = cloned copy of 'array'
 ArrayUtils.insert(index, null, values)    = null
 
```
    Parameters:
    
    index - the position within array to insert the new values
    
    array - the array to insert the values into, may be null
    
    values - the new values to insert, may be null
    
    Returns:
    
    The new array.
    
    Throws:
    
    IndexOutOfBoundsException - if array is provided and either index < 0 or index > array.length
    
    Since:
    
    3.6
  - insert
```
public static <T> T[] insert(int index,
                             T[] array,
                             T... values)
```
    Inserts elements into an array at the given index (starting from zero).
    
    When an array is returned, it is always a new array.
```
 ArrayUtils.insert(index, null, null)      = null
 ArrayUtils.insert(index, array, null)     = cloned copy of 'array'
 ArrayUtils.insert(index, null, values)    = null
 
```
    Type Parameters:
    
    T - The type of elements in array and values
    
    Parameters:
    
    index - the position within array to insert the new values
    
    array - the array to insert the values into, may be null
    
    values - the new values to insert, may be null
    
    Returns:
    
    The new array.
    
    Throws:
    
    IndexOutOfBoundsException - if array is provided and either index < 0 or index > array.length
    
    Since:
    
    3.6
  - shuffle
```
public static void shuffle(Object[] array)
```
    Randomly permutes the elements of the specified array using the Fisher-Yates algorithm.
    
    Parameters:
    
    array - the array to shuffle
    
    Since:
    
    3.6
    
    See Also:
    
    Fisher-Yates shuffle algorithm
  - shuffle
```
public static void shuffle(Object[] array,
                           Random random)
```
    Randomly permutes the elements of the specified array using the Fisher-Yates algorithm.
    
    Parameters:
    
    array - the array to shuffle
    
    random - the source of randomness used to permute the elements
    
    Since:
    
    3.6
    
    See Also:
    
    Fisher-Yates shuffle algorithm
  - shuffle
```
public static void shuffle(boolean[] array)
```
    Randomly permutes the elements of the specified array using the Fisher-Yates algorithm.
    
    Parameters:
    
    array - the array to shuffle
    
    Since:
    
    3.6
    
    See Also:
    
    Fisher-Yates shuffle algorithm
  - shuffle
```
public static void shuffle(boolean[] array,
                           Random random)
```
    Randomly permutes the elements of the specified array using the Fisher-Yates algorithm.
    
    Parameters:
    
    array - the array to shuffle
    
    random - the source of randomness used to permute the elements
    
    Since:
    
    3.6
    
    See Also:
    
    Fisher-Yates shuffle algorithm
  - shuffle
```
public static void shuffle(byte[] array)
```
    Randomly permutes the elements of the specified array using the Fisher-Yates algorithm.
    
    Parameters:
    
    array - the array to shuffle
    
    Since:
    
    3.6
    
    See Also:
    
    Fisher-Yates shuffle algorithm
  - shuffle
```
public static void shuffle(byte[] array,
                           Random random)
```
    Randomly permutes the elements of the specified array using the Fisher-Yates algorithm.
    
    Parameters:
    
    array - the array to shuffle
    
    random - the source of randomness used to permute the elements
    
    Since:
    
    3.6
    
    See Also:
    
    Fisher-Yates shuffle algorithm
  - shuffle
```
public static void shuffle(char[] array)
```
    Randomly permutes the elements of the specified array using the Fisher-Yates algorithm.
    
    Parameters:
    
    array - the array to shuffle
    
    Since:
    
    3.6
    
    See Also:
    
    Fisher-Yates shuffle algorithm
  - shuffle
```
public static void shuffle(char[] array,
                           Random random)
```
    Randomly permutes the elements of the specified array using the Fisher-Yates algorithm.
    
    Parameters:
    
    array - the array to shuffle
    
    random - the source of randomness used to permute the elements
    
    Since:
    
    3.6
    
    See Also:
    
    Fisher-Yates shuffle algorithm
  - shuffle
```
public static void shuffle(short[] array)
```
    Randomly permutes the elements of the specified array using the Fisher-Yates algorithm.
    
    Parameters:
    
    array - the array to shuffle
    
    Since:
    
    3.6
    
    See Also:
    
    Fisher-Yates shuffle algorithm
  - shuffle
```
public static void shuffle(short[] array,
                           Random random)
```
    Randomly permutes the elements of the specified array using the Fisher-Yates algorithm.
    
    Parameters:
    
    array - the array to shuffle
    
    random - the source of randomness used to permute the elements
    
    Since:
    
    3.6
    
    See Also:
    
    Fisher-Yates shuffle algorithm
  - shuffle
```
public static void shuffle(int[] array)
```
    Randomly permutes the elements of the specified array using the Fisher-Yates algorithm.
    
    Parameters:
    
    array - the array to shuffle
    
    Since:
    
    3.6
    
    See Also:
    
    Fisher-Yates shuffle algorithm
  - shuffle
```
public static void shuffle(int[] array,
                           Random random)
```
    Randomly permutes the elements of the specified array using the Fisher-Yates algorithm.
    
    Parameters:
    
    array - the array to shuffle
    
    random - the source of randomness used to permute the elements
    
    Since:
    
    3.6
    
    See Also:
    
    Fisher-Yates shuffle algorithm
  - shuffle
```
public static void shuffle(long[] array)
```
    Randomly permutes the elements of the specified array using the Fisher-Yates algorithm.
    
    Parameters:
    
    array - the array to shuffle
    
    Since:
    
    3.6
    
    See Also:
    
    Fisher-Yates shuffle algorithm
  - shuffle
```
public static void shuffle(long[] array,
                           Random random)
```
    Randomly permutes the elements of the specified array using the Fisher-Yates algorithm.
    
    Parameters:
    
    array - the array to shuffle
    
    random - the source of randomness used to permute the elements
    
    Since:
    
    3.6
    
    See Also:
    
    Fisher-Yates shuffle algorithm
  - shuffle
```
public static void shuffle(float[] array)
```
    Randomly permutes the elements of the specified array using the Fisher-Yates algorithm.
    
    Parameters:
    
    array - the array to shuffle
    
    Since:
    
    3.6
    
    See Also:
    
    Fisher-Yates shuffle algorithm
  - shuffle
```
public static void shuffle(float[] array,
                           Random random)
```
    Randomly permutes the elements of the specified array using the Fisher-Yates algorithm.
    
    Parameters:
    
    array - the array to shuffle
    
    random - the source of randomness used to permute the elements
    
    Since:
    
    3.6
    
    See Also:
    
    Fisher-Yates shuffle algorithm
  - shuffle
```
public static void shuffle(double[] array)
```
    Randomly permutes the elements of the specified array using the Fisher-Yates algorithm.
    
    Parameters:
    
    array - the array to shuffle
    
    Since:
    
    3.6
    
    See Also:
    
    Fisher-Yates shuffle algorithm
  - shuffle
```
public static void shuffle(double[] array,
                           Random random)
```
    Randomly permutes the elements of the specified array using the Fisher-Yates algorithm.
    
    Parameters:
    
    array - the array to shuffle
    
    random - the source of randomness used to permute the elements
    
    Since:
    
    3.6
    
    See Also:
    
    Fisher-Yates shuffle algorithm
  - isArrayIndexValid
```
public static <T> boolean isArrayIndexValid(T[] array,
                                            int index)
```
    Returns whether a given array can safely be accessed at the given index.
    
    Type Parameters:
    
    T - the component type of the array
    
    Parameters:
    
    array - the array to inspect, may be null
    
    index - the index of the array to be inspected
    
    Returns:
    
    Whether the given index is safely-accessible in the given array
    
    Since:
    
    3.8
  - hasNull
```
public static <T> boolean hasNull(T... array)
```
    是否包含null元素
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 被检查的数组
    
    Returns:
    
    是否包含null元素
    
    Since:
    
    3.0.7
  - firstNonNull
```
public static <T> T firstNonNull(T... array)
```
    返回数组中第一个非空元素
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    非空元素，如果不存在非空元素或数组为空，返回null
    
    Since:
    
    3.0.7
  - 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:
    
    空数组
    
    Since:
    
    3.3.0
  - getComponentType
```
public static Class<?> getComponentType(Object array)
```
    获取数组对象的元素类型
    
    Parameters:
    
    array - 数组对象
    
    Returns:
    
    元素类型
    
    Since:
    
    3.2.2
  - getComponentType
```
public static Class<?> getComponentType(Class<?> arrayClass)
```
    获取数组对象的元素类型
    
    Parameters:
    
    arrayClass - 数组类
    
    Returns:
    
    元素类型
    
    Since:
    
    3.2.2
  - getArrayType
```
public static Class<?> getArrayType(Class<?> componentType)
```
    根据数组元素类型，获取数组的类型
    方法是通过创建一个空数组从而获取其类型
    
    Parameters:
    
    componentType - 数组元素类型
    
    Returns:
    
    数组类型
    
    Since:
    
    3.2.2
  - cast
```
public static Object[] cast(Class<?> type,
                            Object arrayObj)
                     throws NullPointerException,
                            IllegalArgumentException
```
    强转数组类型
    强制转换的前提是数组元素类型可被强制转换
    强制转换后会生成一个新数组
    
    Parameters:
    
    type - 数组类型或数组元素类型
    
    arrayObj - 原数组
    
    Returns:
    
    转换后的数组类型
    
    Throws:
    
    NullPointerException - 提供参数为空
    
    IllegalArgumentException - 参数arrayObj不是数组
    
    Since:
    
    3.0.6
  - 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:
    
    新数组或原有数组
    
    Since:
    
    4.1.2
  - setOrAppend
```
public static Object setOrAppend(Object array,
                                 int index,
                                 Object value)
```
    将元素值设置为数组的某个位置，当给定的index大于数组长度，则追加
    
    Parameters:
    
    array - 已有数组
    
    index - 位置，大于长度追加，否则替换
    
    value - 新值
    
    Returns:
    
    新数组或原有数组
    
    Since:
    
    4.1.2
  - insert
```
public static <T> T[] insert(T[] array,
                             int index,
                             T... newElements)
```
  - 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:
    
    调整后的新数组
  - addAll
```
public static <T> T[] addAll(T[]... arrays)
```
    将多个数组合并在一起
    忽略null的数组
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    arrays - 数组集合
    
    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:
    
    目标数组
    
    Since:
    
    3.0.6
  - copy
```
public static Object copy(Object src,
                          Object dest,
                          int length)
```
    包装 System.arraycopy(Object, int, Object, int, int)
    数组复制，缘数组和目标数组都是从位置0开始复制
    
    Parameters:
    
    src - 源数组
    
    dest - 目标数组
    
    length - 拷贝数组长度
    
    Returns:
    
    目标数组
    
    Since:
    
    3.0.6
  - 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:
    
    数字列表
  - split
```
public static byte[][] split(byte[] array,
                             int len)
```
    拆分byte数组为几个等份（最后一份可能小于len）
    
    Parameters:
    
    array - 数组
    
    len - 每个小节的长度
    
    Returns:
    
    拆分后的数组
  - indexOfIgnoreCase
```
public static int indexOfIgnoreCase(CharSequence[] array,
                                    CharSequence value)
```
    返回数组中指定元素所在位置，忽略大小写，未找到返回INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    Since:
    
    3.1.2
  - 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:
    
    CommonException - 对象为非数组
  - isArray
```
public static boolean isArray(Object obj)
```
    对象是否为数组对象
    
    Parameters:
    
    obj - 对象
    
    Returns:
    
    是否为数组对象，如果为null 返回false
  - get
```
public static <T> T get(Object array,
                        int index)
```
    获取数组对象中指定index的值，支持负数，例如-1表示倒数第一个值
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组对象
    
    index - 下标，支持负数
    
    Returns:
    
    值
    
    Since:
    
    4.0.6
  - getAny
```
public static <T> T[] getAny(Object array,
                             int... indexes)
```
    获取数组中指定多个下标元素值，组成新数组
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组
    
    indexes - 下标列表
    
    Returns:
    
    结果
  - sub
```
public static Object[] sub(Object array,
                           int start,
                           int end)
```
    获取子数组
    
    Parameters:
    
    array - 数组
    
    start - 开始位置（包括）
    
    end - 结束位置（不包括）
    
    Returns:
    
    新的数组
    
    Since:
    
    4.0.6
  - sub
```
public static Object[] sub(Object array,
                           int start,
                           int end,
                           int step)
```
    获取子数组
    
    Parameters:
    
    array - 数组
    
    start - 开始位置（包括）
    
    end - 结束位置（不包括）
    
    step - 步进
    
    Returns:
    
    新的数组
    
    Since:
    
    4.0.6
  - length
```
public static int length(Object array)
                  throws IllegalArgumentException
```
    获取数组长度
    如果参数为null，返回0
```
 ArrayUtils.length(null)            = 0
 ArrayUtils.length([])              = 0
 ArrayUtils.length([null])          = 1
 ArrayUtils.length([true, false])   = 2
 ArrayUtils.length([1, 2, 3])       = 3
 ArrayUtils.length(["a", "b", "c"]) = 3
 
```
    Parameters:
    
    array - 数组对象
    
    Returns:
    
    数组长度
    
    Throws:
    
    IllegalArgumentException - 如果参数不为数组，抛出此异常
    
    Since:
    
    3.0.8
    
    See Also:
    
    Array.getLength(Object)
  - join
```
public static String join(long[] array,
                          CharSequence conjunction)
```
    以 conjunction 为分隔符将数组转换为字符串
    
    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:
    
    连接后的字符串
    
    Since:
    
    4.0.10
  - 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:
    
    连接后的字符串
  - toArray
```
public static byte[] toArray(ByteBuffer bytebuffer)
```
    ByteBuffer 转byte数组
    
    Parameters:
    
    bytebuffer - ByteBuffer
    
    Returns:
    
    byte数组
    
    Since:
    
    3.0.1
  - toArray
```
public static <T> T[] toArray(Collection<T> collection,
                              Class<T> componentType)
```
    将集合转为数组
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    collection - 集合
    
    componentType - 集合元素类型
    
    Returns:
    
    数组
    
    Since:
    
    3.0.9
  - min
```
public static <T extends Comparable<? super T>> T min(T[] numberArray)
```
    取最小值
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    numberArray - 数字数组
    
    Returns:
    
    最小值
    
    Since:
    
    3.0.9
  - min
```
public static long min(long... numberArray)
```
    取最小值
    
    Parameters:
    
    numberArray - 数字数组
    
    Returns:
    
    最小值
    
    Since:
    
    3.0.9
  - min
```
public static int min(int... numberArray)
```
    取最小值
    
    Parameters:
    
    numberArray - 数字数组
    
    Returns:
    
    最小值
    
    Since:
    
    3.0.9
  - min
```
public static short min(short... numberArray)
```
    取最小值
    
    Parameters:
    
    numberArray - 数字数组
    
    Returns:
    
    最小值
    
    Since:
    
    3.0.9
  - min
```
public static char min(char... numberArray)
```
    取最小值
    
    Parameters:
    
    numberArray - 数字数组
    
    Returns:
    
    最小值
    
    Since:
    
    3.0.9
  - min
```
public static byte min(byte... numberArray)
```
    取最小值
    
    Parameters:
    
    numberArray - 数字数组
    
    Returns:
    
    最小值
    
    Since:
    
    3.0.9
  - min
```
public static double min(double... numberArray)
```
    取最小值
    
    Parameters:
    
    numberArray - 数字数组
    
    Returns:
    
    最小值
    
    Since:
    
    3.0.9
  - min
```
public static float min(float... numberArray)
```
    取最小值
    
    Parameters:
    
    numberArray - 数字数组
    
    Returns:
    
    最小值
    
    Since:
    
    3.0.9
  - max
```
public static <T extends Comparable<? super T>> T max(T[] numberArray)
```
    取最大值
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    numberArray - 数字数组
    
    Returns:
    
    最大值
    
    Since:
    
    3.0.9
  - max
```
public static long max(long... numberArray)
```
    取最大值
    
    Parameters:
    
    numberArray - 数字数组
    
    Returns:
    
    最大值
    
    Since:
    
    3.0.9
  - max
```
public static int max(int... numberArray)
```
    取最大值
    
    Parameters:
    
    numberArray - 数字数组
    
    Returns:
    
    最大值
    
    Since:
    
    3.0.9
  - max
```
public static short max(short... numberArray)
```
    取最大值
    
    Parameters:
    
    numberArray - 数字数组
    
    Returns:
    
    最大值
    
    Since:
    
    3.0.9
  - max
```
public static char max(char... numberArray)
```
    取最大值
    
    Parameters:
    
    numberArray - 数字数组
    
    Returns:
    
    最大值
    
    Since:
    
    3.0.9
  - max
```
public static byte max(byte... numberArray)
```
    取最大值
    
    Parameters:
    
    numberArray - 数字数组
    
    Returns:
    
    最大值
    
    Since:
    
    3.0.9
  - max
```
public static double max(double... numberArray)
```
    取最大值
    
    Parameters:
    
    numberArray - 数字数组
    
    Returns:
    
    最大值
    
    Since:
    
    3.0.9
  - max
```
public static float max(float... numberArray)
```
    取最大值
    
    Parameters:
    
    numberArray - 数字数组
    
    Returns:
    
    最大值
    
    Since:
    
    3.0.9
  - 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
    
    Since:
    
    3.0.4
  - 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:
    
    过滤后的数组
    
    Since:
    
    3.2.1
  - containsIgnoreCase
```
public static boolean containsIgnoreCase(CharSequence[] array,
                                         CharSequence value)
```
    数组中是否包含元素，忽略大小写
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    是否包含
    
    Since:
    
    3.1.2
  - firstNotNullElem
```
public static Optional<Object> firstNotNullElem(Object[] objects)
```
    找到第一个不为 null 的元素
    
    Parameters:
    
    objects - 对象
    
    Returns:
    
    不为 null 的元素
    
    Since:
    
    0.1.18

Class ArrayUtils

Field Summary

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Field Detail

EMPTY_OBJECT_ARRAY

EMPTY_CLASS_ARRAY

EMPTY_STRING_ARRAY

EMPTY_LONG_ARRAY

EMPTY_LONG_OBJECT_ARRAY

EMPTY_INT_ARRAY

EMPTY_INTEGER_OBJECT_ARRAY

EMPTY_SHORT_ARRAY

EMPTY_SHORT_OBJECT_ARRAY

EMPTY_BYTE_ARRAY

EMPTY_BYTE_OBJECT_ARRAY

EMPTY_DOUBLE_ARRAY

EMPTY_DOUBLE_OBJECT_ARRAY

EMPTY_FLOAT_ARRAY

EMPTY_FLOAT_OBJECT_ARRAY

EMPTY_BOOLEAN_ARRAY

EMPTY_BOOLEAN_OBJECT_ARRAY

EMPTY_CHAR_ARRAY

EMPTY_CHARACTER_OBJECT_ARRAY

INDEX_NOT_FOUND

Constructor Detail

ArrayUtils

Method Detail

toString

toString

hashCode

toMap

toArray

clone

clone

clone

clone

clone

clone

clone

clone

clone

clone

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

nullToEmpty

subarray

subarray

subarray

subarray

subarray

subarray

subarray

subarray

subarray

isSameLength

isSameLength

isSameLength

isSameLength

isSameLength

isSameLength

isSameLength