ArrayUtil (easytools 1.0.0 API)

java.lang.Object
- javacommon.easytools.core.util.ArrayUtil

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

字段概要

字段
限定符和类型字段和说明

static int INDEX_NOT_FOUND
数组中元素未找到的下标，值为-1

字段
限定符和类型	字段和说明
`static int`	`INDEX_NOT_FOUND` 数组中元素未找到的下标，值为-1

构造器概要

构造器
构造器和说明

ArrayUtil()

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

方法概要

所有方法静态方法具体方法
限定符和类型	方法和说明
`static <T> T[]`	`addAll(T[]... arrays)` 将多个数组合并在一起忽略null的数组
`static <T> T[]`	`append(T[] buffer, T... newElements)` 将新元素添加到已有数组中添加新元素会生成一个新的数组，不影响原数组
`static Object[]`	`cast(Class<?> type, Object arrayObj)` 强转数组类型强制转换的前提是数组元素类型可被强制转换强制转换后会生成一个新数组
`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(float[] array, float value)` 数组中是否包含元素
`static boolean`	`contains(int[] array, int value)` 数组中是否包含元素
`static boolean`	`contains(long[] array, long value)` 数组中是否包含元素
`static boolean`	`contains(short[] array, short value)` 数组中是否包含元素
`static <T> boolean`	`contains(T[] array, T 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实现可以实现以下功能： 1、过滤出需要的对象，如果返回null表示这个元素对象抛弃 2、修改元素对象，返回集合中为修改后的对象
`static <T> T[]`	`filter(T[] array, Filter<T> filter)` 过滤过滤过程通过传入的Filter实现来过滤返回需要的元素内容，这个Editor实现可以实现以下功能： 1、过滤出需要的对象，`Filter.accept(Object)`方法返回true的对象将被加入结果集合中
`static <T> T`	`firstNonNull(T... array)` 返回数组中第一个非空元素
`static Class<?>`	`getArrayType(Class<?> componentType)` 根据数组元素类型，获取数组的类型方法是通过创建一个空数组从而获取其类型
`static Class<?>`	`getComponentType(Class<?> arrayClass)` 获取数组对象的元素类型
`static Class<?>`	`getComponentType(Object array)` 获取数组对象的元素类型
`static <T> boolean`	`hasNull(T... array)` 是否包含`null`元素
`static int`	`indexOf(boolean[] array, boolean value)` 返回数组中指定元素所在位置，未找到返回`INDEX_NOT_FOUND`
`static int`	`indexOf(byte[] array, byte value)` 返回数组中指定元素所在位置，未找到返回`INDEX_NOT_FOUND`
`static int`	`indexOf(char[] array, char value)` 返回数组中指定元素所在位置，未找到返回`INDEX_NOT_FOUND`
`static int`	`indexOf(double[] array, double value)` 返回数组中指定元素所在位置，未找到返回`INDEX_NOT_FOUND`
`static int`	`indexOf(float[] array, float value)` 返回数组中指定元素所在位置，未找到返回`INDEX_NOT_FOUND`
`static int`	`indexOf(int[] array, int value)` 返回数组中指定元素所在位置，未找到返回`INDEX_NOT_FOUND`
`static int`	`indexOf(long[] array, long value)` 返回数组中指定元素所在位置，未找到返回`INDEX_NOT_FOUND`
`static int`	`indexOf(short[] array, short value)` 返回数组中指定元素所在位置，未找到返回`INDEX_NOT_FOUND`
`static <T> int`	`indexOf(T[] array, Object value)` 返回数组中指定元素所在位置，未找到返回`INDEX_NOT_FOUND`
`static int`	`indexOfIgnoreCase(CharSequence[] array, CharSequence value)` 返回数组中指定元素所在位置，忽略大小写，未找到返回`INDEX_NOT_FOUND`
`static boolean`	`isArray(Object obj)` 对象是否为数组对象
`static boolean`	`isEmpty(boolean... array)` 数组是否为空
`static boolean`	`isEmpty(byte... array)` 数组是否为空
`static boolean`	`isEmpty(char... array)` 数组是否为空
`static boolean`	`isEmpty(double... array)` 数组是否为空
`static boolean`	`isEmpty(float... array)` 数组是否为空
`static boolean`	`isEmpty(int... array)` 数组是否为空
`static boolean`	`isEmpty(long... array)` 数组是否为空
`static boolean`	`isEmpty(Object array)` 数组是否为空此方法会匹配单一对象，如果此对象为`null`则返回true 如果此对象为非数组，理解为此对象为数组的第一个元素，则返回false 如果此对象为数组对象，数组长度大于0情况下返回false，否则返回true
`static boolean`	`isEmpty(short... array)` 数组是否为空
`static <T> boolean`	`isEmpty(T... array)` 数组是否为空
`static boolean`	`isNotEmpty(boolean... array)` 数组是否为非空
`static boolean`	`isNotEmpty(byte... array)` 数组是否为非空
`static boolean`	`isNotEmpty(char... array)` 数组是否为非空
`static boolean`	`isNotEmpty(double... array)` 数组是否为非空
`static boolean`	`isNotEmpty(float... array)` 数组是否为非空
`static boolean`	`isNotEmpty(int... array)` 数组是否为非空
`static boolean`	`isNotEmpty(long... array)` 数组是否为非空
`static boolean`	`isNotEmpty(Object array)` 数组是否为非空此方法会匹配单一对象，如果此对象为`null`则返回false 如果此对象为非数组，理解为此对象为数组的第一个元素，则返回true 如果此对象为数组对象，数组长度大于0情况下返回true，否则返回false
`static boolean`	`isNotEmpty(short... array)` 数组是否为非空
`static <T> boolean`	`isNotEmpty(T... array)` 数组是否为非空
`static String`	`join(boolean[] array, String conjunction)` 以 conjunction 为分隔符将数组转换为字符串
`static String`	`join(byte[] array, String conjunction)` 以 conjunction 为分隔符将数组转换为字符串
`static String`	`join(char[] array, String conjunction)` 以 conjunction 为分隔符将数组转换为字符串
`static String`	`join(double[] array, String conjunction)` 以 conjunction 为分隔符将数组转换为字符串
`static String`	`join(float[] array, String conjunction)` 以 conjunction 为分隔符将数组转换为字符串
`static String`	`join(int[] array, String conjunction)` 以 conjunction 为分隔符将数组转换为字符串
`static String`	`join(long[] array, String conjunction)` 以 conjunction 为分隔符将数组转换为字符串
`static String`	`join(Object array, CharSequence conjunction)` 以 conjunction 为分隔符将数组转换为字符串
`static String`	`join(short[] array, String conjunction)` 以 conjunction 为分隔符将数组转换为字符串
`static <T> String`	`join(T[] array, CharSequence conjunction)` 以 conjunction 为分隔符将数组转换为字符串
`static int`	`lastIndexOf(boolean[] array, boolean value)` 返回数组中指定元素所在最后的位置，未找到返回`INDEX_NOT_FOUND`
`static int`	`lastIndexOf(byte[] array, byte value)` 返回数组中指定元素所在最后的位置，未找到返回`INDEX_NOT_FOUND`
`static int`	`lastIndexOf(char[] array, char value)` 返回数组中指定元素所在最后的位置，未找到返回`INDEX_NOT_FOUND`
`static int`	`lastIndexOf(double[] array, double value)` 返回数组中指定元素所在最后的位置，未找到返回`INDEX_NOT_FOUND`
`static int`	`lastIndexOf(float[] array, float value)` 返回数组中指定元素所在最后的位置，未找到返回`INDEX_NOT_FOUND`
`static int`	`lastIndexOf(int[] array, int value)` 返回数组中指定元素所在最后的位置，未找到返回`INDEX_NOT_FOUND`
`static int`	`lastIndexOf(long[] array, long value)` 返回数组中指定元素所在最后的位置，未找到返回`INDEX_NOT_FOUND`
`static int`	`lastIndexOf(short[] array, short value)` 返回数组中指定元素所在最后的位置，未找到返回`INDEX_NOT_FOUND`
`static <T> int`	`lastIndexOf(T[] array, Object value)` 返回数组中指定元素所在最后的位置，未找到返回`INDEX_NOT_FOUND`
`static int`	`length(Object array)` 获取数组长度如果参数为`null`，返回0 ArrayUtil.length(null) = 0 ArrayUtil.length([]) = 0 ArrayUtil.length([null]) = 1 ArrayUtil.length([true, false]) = 2 ArrayUtil.length([1, 2, 3]) = 3 ArrayUtil.length(["a", "b", "c"]) = 3
`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 String[]`	`nullToEmpty(String[] array)` 数组元素中的null转换为""
`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)` 移除数组中对应位置的元素 copy from commons-lang
`static byte[]`	`remove(byte[] array, int index)` 移除数组中对应位置的元素 copy from commons-lang
`static char[]`	`remove(char[] array, int index)` 移除数组中对应位置的元素 copy from commons-lang
`static double[]`	`remove(double[] array, int index)` 移除数组中对应位置的元素 copy from commons-lang
`static float[]`	`remove(float[] array, int index)` 移除数组中对应位置的元素 copy from commons-lang
`static int[]`	`remove(int[] array, int index)` 移除数组中对应位置的元素 copy from commons-lang
`static long[]`	`remove(long[] array, int index)` 移除数组中对应位置的元素 copy from commons-lang
`static Object`	`remove(Object array, int index)` 移除数组中对应位置的元素 copy from commons-lang
`static short[]`	`remove(short[] array, int index)` 移除数组中对应位置的元素 copy from commons-lang
`static <T> T[]`	`remove(T[] array, int index)` 移除数组中对应位置的元素 copy from commons-lang
`static <T extends CharSequence> T[]`	`removeBlank(T[] array)` 去除`null`或者""或者空白字符串元素
`static boolean[]`	`removeEle(boolean[] array, boolean element)` 移除数组中指定的元素只会移除匹配到的第一个元素 copy from commons-lang
`static byte[]`	`removeEle(byte[] array, byte element)` 移除数组中指定的元素只会移除匹配到的第一个元素 copy from commons-lang
`static char[]`	`removeEle(char[] array, char element)` 移除数组中指定的元素只会移除匹配到的第一个元素 copy from commons-lang
`static double[]`	`removeEle(double[] array, double element)` 移除数组中指定的元素只会移除匹配到的第一个元素 copy from commons-lang
`static float[]`	`removeEle(float[] array, float element)` 移除数组中指定的元素只会移除匹配到的第一个元素 copy from commons-lang
`static int[]`	`removeEle(int[] array, int element)` 移除数组中指定的元素只会移除匹配到的第一个元素 copy from commons-lang
`static long[]`	`removeEle(long[] array, long element)` 移除数组中指定的元素只会移除匹配到的第一个元素 copy from commons-lang
`static short[]`	`removeEle(short[] array, short element)` 移除数组中指定的元素只会移除匹配到的第一个元素 copy from commons-lang
`static <T> T[]`	`removeEle(T[] array, T element)` 移除数组中指定的元素只会移除匹配到的第一个元素 copy from commons-lang
`static <T extends CharSequence> T[]`	`removeEmpty(T[] array)` 去除`null`或者"" 元素
`static <T> T[]`	`removeNull(T[] array)` 去除`null` 元素
`static <T> T[]`	`resize(T[] buffer, int newSize)` 生成一个新的重新设置大小的数组新数组的类型为原数组的类型，调整大小后拷贝原数组到新数组下。
`static <T> T[]`	`resize(T[] buffer, int newSize, Class<?> componentType)` 生成一个新的重新设置大小的数组调整大小后拷贝原数组到新数组下。
`static boolean[]`	`reverse(boolean[] array)` 反转数组，会变更原数组
`static boolean[]`	`reverse(boolean[] array, int startIndexInclusive, int endIndexExclusive)` 反转数组，会变更原数组
`static byte[]`	`reverse(byte[] array)` 反转数组，会变更原数组
`static byte[]`	`reverse(byte[] array, int startIndexInclusive, int endIndexExclusive)` 反转数组，会变更原数组
`static char[]`	`reverse(char[] array)` 反转数组，会变更原数组
`static char[]`	`reverse(char[] array, int startIndexInclusive, int endIndexExclusive)` 反转数组，会变更原数组
`static double[]`	`reverse(double[] array)` 反转数组，会变更原数组
`static double[]`	`reverse(double[] array, int startIndexInclusive, int endIndexExclusive)` 反转数组，会变更原数组
`static float[]`	`reverse(float[] array)` 反转数组，会变更原数组
`static float[]`	`reverse(float[] array, int startIndexInclusive, int endIndexExclusive)` 反转数组，会变更原数组
`static int[]`	`reverse(int[] array)` 反转数组，会变更原数组
`static int[]`	`reverse(int[] array, int startIndexInclusive, int endIndexExclusive)` 反转数组，会变更原数组
`static long[]`	`reverse(long[] array)` 反转数组，会变更原数组
`static long[]`	`reverse(long[] array, int startIndexInclusive, int endIndexExclusive)` 反转数组，会变更原数组
`static short[]`	`reverse(short[] array)` 反转数组，会变更原数组
`static short[]`	`reverse(short[] array, int startIndexInclusive, int endIndexExclusive)` 反转数组，会变更原数组
`static <T> T[]`	`reverse(T[] array)` 反转数组，会变更原数组
`static <T> T[]`	`reverse(T[] array, int startIndexInclusive, int endIndexExclusive)` 反转数组，会变更原数组
`static byte[][]`	`split(byte[] array, int len)` 拆分byte数组为几个等份（最后一份可能小于len）
`static byte[]`	`toArray(ByteBuffer bytebuffer)` `ByteBuffer` 转byte数组
`static <T> T[]`	`toArray(Collection<T> collection, Class<T> componentType)` 将集合转为数组
`static <T> T[]`	`toArray(Iterable<T> iterable, Class<T> componentType)` 将集合转为数组
`static <T> T[]`	`toArray(Iterator<T> iterator, Class<T> componentType)` 将集合转为数组
`static String`	`toString(Object obj)` 数组或集合转String
`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 Integer[]`	`wrap(int... values)` 将原始类型数组包装为包装类型
`static Long[]`	`wrap(long... values)` 将原始类型数组包装为包装类型
`static Object[]`	`wrap(Object obj)` 包装数组对象
`static Short[]`	`wrap(short... values)` 将原始类型数组包装为包装类型
`static <K,V> Map<K,V>`	`zip(K[] keys, V[] values)` 映射键值（参考Python的zip()函数），返回Map无序例如： keys = [a,b,c,d] values = [1,2,3,4] 则得到的Map是 {a=1, b=2, c=3, d=4} 如果两个数组长度不同，则只对应最短部分
`static <K,V> Map<K,V>`	`zip(K[] keys, V[] values, boolean isOrder)` 映射键值（参考Python的zip()函数）例如： keys = [a,b,c,d] values = [1,2,3,4] 则得到的Map是 {a=1, b=2, c=3, d=4} 如果两个数组长度不同，则只对应最短部分

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

- 字段详细资料
  - INDEX_NOT_FOUND
```
public static final int INDEX_NOT_FOUND
```
    数组中元素未找到的下标，值为-1
    
    另请参阅:
    
    常量字段值
- 构造器详细资料
  - ArrayUtil
```
public ArrayUtil()
```
- 方法详细资料
  - isEmpty
```
public static <T> boolean isEmpty(T... array)
```
    数组是否为空
    
    类型参数:
    
    T - 数组元素类型
    
    参数:
    
    array - 数组
    
    返回:
    
    是否为空
  - isEmpty
```
public static boolean isEmpty(Object array)
```
    数组是否为空
    此方法会匹配单一对象，如果此对象为null则返回true
    如果此对象为非数组，理解为此对象为数组的第一个元素，则返回false
    如果此对象为数组对象，数组长度大于0情况下返回false，否则返回true
    
    参数:
    
    array - 数组
    
    返回:
    
    是否为空
  - isEmpty
```
public static boolean isEmpty(long... array)
```
    数组是否为空
    
    参数:
    
    array - 数组
    
    返回:
    
    是否为空
  - isEmpty
```
public static boolean isEmpty(int... array)
```
    数组是否为空
    
    参数:
    
    array - 数组
    
    返回:
    
    是否为空
  - isEmpty
```
public static boolean isEmpty(short... array)
```
    数组是否为空
    
    参数:
    
    array - 数组
    
    返回:
    
    是否为空
  - isEmpty
```
public static boolean isEmpty(char... array)
```
    数组是否为空
    
    参数:
    
    array - 数组
    
    返回:
    
    是否为空
  - isEmpty
```
public static boolean isEmpty(byte... array)
```
    数组是否为空
    
    参数:
    
    array - 数组
    
    返回:
    
    是否为空
  - isEmpty
```
public static boolean isEmpty(double... array)
```
    数组是否为空
    
    参数:
    
    array - 数组
    
    返回:
    
    是否为空
  - isEmpty
```
public static boolean isEmpty(float... array)
```
    数组是否为空
    
    参数:
    
    array - 数组
    
    返回:
    
    是否为空
  - isEmpty
```
public static boolean isEmpty(boolean... array)
```
    数组是否为空
    
    参数:
    
    array - 数组
    
    返回:
    
    是否为空
  - isNotEmpty
```
public static <T> boolean isNotEmpty(T... array)
```
    数组是否为非空
    
    类型参数:
    
    T - 数组元素类型
    
    参数:
    
    array - 数组
    
    返回:
    
    是否为非空
  - isNotEmpty
```
public static boolean isNotEmpty(Object array)
```
    数组是否为非空
    此方法会匹配单一对象，如果此对象为null则返回false
    如果此对象为非数组，理解为此对象为数组的第一个元素，则返回true
    如果此对象为数组对象，数组长度大于0情况下返回true，否则返回false
    
    参数:
    
    array - 数组
    
    返回:
    
    是否为非空
  - isNotEmpty
```
public static boolean isNotEmpty(long... array)
```
    数组是否为非空
    
    参数:
    
    array - 数组
    
    返回:
    
    是否为非空
  - isNotEmpty
```
public static boolean isNotEmpty(int... array)
```
    数组是否为非空
    
    参数:
    
    array - 数组
    
    返回:
    
    是否为非空
  - isNotEmpty
```
public static boolean isNotEmpty(short... array)
```
    数组是否为非空
    
    参数:
    
    array - 数组
    
    返回:
    
    是否为非空
  - isNotEmpty
```
public static boolean isNotEmpty(char... array)
```
    数组是否为非空
    
    参数:
    
    array - 数组
    
    返回:
    
    是否为非空
  - isNotEmpty
```
public static boolean isNotEmpty(byte... array)
```
    数组是否为非空
    
    参数:
    
    array - 数组
    
    返回:
    
    是否为非空
  - isNotEmpty
```
public static boolean isNotEmpty(double... array)
```
    数组是否为非空
    
    参数:
    
    array - 数组
    
    返回:
    
    是否为非空
  - isNotEmpty
```
public static boolean isNotEmpty(float... array)
```
    数组是否为非空
    
    参数:
    
    array - 数组
    
    返回:
    
    是否为非空
  - isNotEmpty
```
public static boolean isNotEmpty(boolean... array)
```
    数组是否为非空
    
    参数:
    
    array - 数组
    
    返回:
    
    是否为非空
  - hasNull
```
public static <T> boolean hasNull(T... array)
```
    是否包含null元素
    
    类型参数:
    
    T - 数组元素类型
    
    参数:
    
    array - 被检查的数组
    
    返回:
    
    是否包含null元素
    
    从以下版本开始:
    
    3.0.7
  - firstNonNull
```
public static <T> T firstNonNull(T... array)
```
    返回数组中第一个非空元素
    
    类型参数:
    
    T - 数组元素类型
    
    参数:
    
    array - 数组
    
    返回:
    
    非空元素，如果不存在非空元素或数组为空，返回null
    
    从以下版本开始:
    
    3.0.7
  - newArray
```
public static <T> T[] newArray(Class<?> componentType,
                               int newSize)
```
    新建一个空数组
    
    类型参数:
    
    T - 数组元素类型
    
    参数:
    
    componentType - 元素类型
    
    newSize - 大小
    
    返回:
    
    空数组
  - newArray
```
public static <T> T[] newArray(int newSize)
```
    新建一个空数组
    
    类型参数:
    
    T - 数组元素类型
    
    参数:
    
    newSize - 大小
    
    返回:
    
    空数组
    
    从以下版本开始:
    
    3.3.0
  - getComponentType
```
public static Class<?> getComponentType(Object array)
```
    获取数组对象的元素类型
    
    参数:
    
    array - 数组对象
    
    返回:
    
    元素类型
    
    从以下版本开始:
    
    3.2.2
  - getComponentType
```
public static Class<?> getComponentType(Class<?> arrayClass)
```
    获取数组对象的元素类型
    
    参数:
    
    arrayClass - 数组类
    
    返回:
    
    元素类型
    
    从以下版本开始:
    
    3.2.2
  - getArrayType
```
public static Class<?> getArrayType(Class<?> componentType)
```
    根据数组元素类型，获取数组的类型
    方法是通过创建一个空数组从而获取其类型
    
    参数:
    
    componentType - 数组元素类型
    
    返回:
    
    数组类型
    
    从以下版本开始:
    
    3.2.2
  - cast
```
public static Object[] cast(Class<?> type,
                            Object arrayObj)
                     throws NullPointerException,
                            IllegalArgumentException
```
    强转数组类型
    强制转换的前提是数组元素类型可被强制转换
    强制转换后会生成一个新数组
    
    参数:
    
    type - 数组类型或数组元素类型
    
    arrayObj - 原数组
    
    返回:
    
    转换后的数组类型
    
    抛出:
    
    NullPointerException - 提供参数为空
    
    IllegalArgumentException - 参数arrayObj不是数组
    
    从以下版本开始:
    
    3.0.6
  - append
```
@SafeVarargs
public static <T> T[] append(T[] buffer,
                                           T... newElements)
```
    将新元素添加到已有数组中
    添加新元素会生成一个新的数组，不影响原数组
    
    类型参数:
    
    T - 数组元素类型
    
    参数:
    
    buffer - 已有数组
    
    newElements - 新元素
    
    返回:
    
    新数组
  - resize
```
public static <T> T[] resize(T[] buffer,
                             int newSize,
                             Class<?> componentType)
```
    生成一个新的重新设置大小的数组
    调整大小后拷贝原数组到新数组下。扩大则占位前N个位置，缩小则截断
    
    类型参数:
    
    T - 数组元素类型
    
    参数:
    
    buffer - 原数组
    
    newSize - 新的数组大小
    
    componentType - 数组元素类型
    
    返回:
    
    调整后的新数组
  - resize
```
public static <T> T[] resize(T[] buffer,
                             int newSize)
```
    生成一个新的重新设置大小的数组
    新数组的类型为原数组的类型，调整大小后拷贝原数组到新数组下。扩大则占位前N个位置，缩小则截断
    
    类型参数:
    
    T - 数组元素类型
    
    参数:
    
    buffer - 原数组
    
    newSize - 新的数组大小
    
    返回:
    
    调整后的新数组
  - addAll
```
@SafeVarargs
public static <T> T[] addAll(T[]... arrays)
```
    将多个数组合并在一起
    忽略null的数组
    
    类型参数:
    
    T - 数组元素类型
    
    参数:
    
    arrays - 数组集合
    
    返回:
    
    合并后的数组
  - copy
```
public static Object copy(Object src,
                          int srcPos,
                          Object dest,
                          int destPos,
                          int length)
```
    包装 System.arraycopy(Object, int, Object, int, int)
    数组复制
    
    参数:
    
    src - 源数组
    
    srcPos - 源数组开始位置
    
    dest - 目标数组
    
    destPos - 目标数组开始位置
    
    length - 拷贝数组长度
    
    返回:
    
    目标数组
    
    从以下版本开始:
    
    3.0.6
  - copy
```
public static Object copy(Object src,
                          Object dest,
                          int length)
```
    包装 System.arraycopy(Object, int, Object, int, int)
    数组复制，缘数组和目标数组都是从位置0开始复制
    
    参数:
    
    src - 源数组
    
    dest - 目标数组
    
    length - 拷贝数组长度
    
    返回:
    
    目标数组
    
    从以下版本开始:
    
    3.0.6
  - clone
```
public static <T> T[] clone(T[] array)
```
    克隆数组
    
    类型参数:
    
    T - 数组元素类型
    
    参数:
    
    array - 被克隆的数组
    
    返回:
    
    新数组
  - clone
```
public static <T> T clone(T obj)
```
    克隆数组，如果非数组返回null
    
    类型参数:
    
    T - 数组元素类型
    
    参数:
    
    obj - 数组对象
    
    返回:
    
    克隆后的数组对象
  - range
```
public static int[] range(int excludedEnd)
```
    生成一个从0开始的数字列表
    
    参数:
    
    excludedEnd - 结束的数字（不包含）
    
    返回:
    
    数字列表
  - range
```
public static int[] range(int includedStart,
                          int excludedEnd)
```
    生成一个数字列表
    自动判定正序反序
    
    参数:
    
    includedStart - 开始的数字（包含）
    
    excludedEnd - 结束的数字（不包含）
    
    返回:
    
    数字列表
  - range
```
public static int[] range(int includedStart,
                          int excludedEnd,
                          int step)
```
    生成一个数字列表
    自动判定正序反序
    
    参数:
    
    includedStart - 开始的数字（包含）
    
    excludedEnd - 结束的数字（不包含）
    
    step - 步进
    
    返回:
    
    数字列表
  - split
```
public static byte[][] split(byte[] array,
                             int len)
```
    拆分byte数组为几个等份（最后一份可能小于len）
    
    参数:
    
    array - 数组
    
    len - 每个小节的长度
    
    返回:
    
    拆分后的数组
  - filter
```
public static <T> T[] filter(T[] array,
                             Editor<T> editor)
```
    过滤
    过滤过程通过传入的Editor实现来返回需要的元素内容，这个Editor实现可以实现以下功能：
```
 1、过滤出需要的对象，如果返回null表示这个元素对象抛弃
 2、修改元素对象，返回集合中为修改后的对象
 
```
    类型参数:
    
    T - 数组元素类型
    
    参数:
    
    array - 数组
    
    editor - 编辑器接口
    
    返回:
    
    过滤后的数组
  - filter
```
public static <T> T[] filter(T[] array,
                             Filter<T> filter)
```
    过滤
    过滤过程通过传入的Filter实现来过滤返回需要的元素内容，这个Editor实现可以实现以下功能：
```
 1、过滤出需要的对象，Filter.accept(Object)方法返回true的对象将被加入结果集合中
 
```
    类型参数:
    
    T - 数组元素类型
    
    参数:
    
    array - 数组
    
    filter - 过滤器接口，用于定义过滤规则
    
    返回:
    
    过滤后的数组
    
    从以下版本开始:
    
    3.2.1
  - removeNull
```
public static <T> T[] removeNull(T[] array)
```
    去除null 元素
    
    参数:
    
    array - 数组
    
    返回:
    
    处理后的数组
    
    从以下版本开始:
    
    3.2.2
  - removeEmpty
```
public static <T extends CharSequence> T[] removeEmpty(T[] array)
```
    去除null或者"" 元素
    
    参数:
    
    array - 数组
    
    返回:
    
    处理后的数组
    
    从以下版本开始:
    
    3.2.2
  - removeBlank
```
public static <T extends CharSequence> T[] removeBlank(T[] array)
```
    去除null或者""或者空白字符串元素
    
    参数:
    
    array - 数组
    
    返回:
    
    处理后的数组
    
    从以下版本开始:
    
    3.2.2
  - nullToEmpty
```
public static String[] nullToEmpty(String[] array)
```
    数组元素中的null转换为""
    
    参数:
    
    array - 数组
    
    返回:
    
    新数组
    
    从以下版本开始:
    
    3.2.1
  - 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}
    如果两个数组长度不同，则只对应最短部分
    
    类型参数:
    
    K - Key类型
    
    V - Value类型
    
    参数:
    
    keys - 键列表
    
    values - 值列表
    
    isOrder - 是否有序
    
    返回:
    
    Map
    
    从以下版本开始:
    
    3.0.4
  - zip
```
public static <K,V> Map<K,V> zip(K[] keys,
                                 V[] values)
```
    映射键值（参考Python的zip()函数），返回Map无序
    例如：
    keys = [a,b,c,d]
    values = [1,2,3,4]
    则得到的Map是 {a=1, b=2, c=3, d=4}
    如果两个数组长度不同，则只对应最短部分
    
    类型参数:
    
    K - Key类型
    
    V - Value类型
    
    参数:
    
    keys - 键列表
    
    values - 值列表
    
    返回:
    
    Map
  - indexOf
```
public static <T> int indexOf(T[] array,
                              Object value)
```
    返回数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    类型参数:
    
    T - 数组类型
    
    参数:
    
    array - 数组
    
    value - 被检查的元素
    
    返回:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    从以下版本开始:
    
    3.0.7
  - indexOfIgnoreCase
```
public static int indexOfIgnoreCase(CharSequence[] array,
                                    CharSequence value)
```
    返回数组中指定元素所在位置，忽略大小写，未找到返回INDEX_NOT_FOUND
    
    参数:
    
    array - 数组
    
    value - 被检查的元素
    
    返回:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    从以下版本开始:
    
    3.1.2
  - lastIndexOf
```
public static <T> int lastIndexOf(T[] array,
                                  Object value)
```
    返回数组中指定元素所在最后的位置，未找到返回INDEX_NOT_FOUND
    
    类型参数:
    
    T - 数组类型
    
    参数:
    
    array - 数组
    
    value - 被检查的元素
    
    返回:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    从以下版本开始:
    
    3.0.7
  - contains
```
public static <T> boolean contains(T[] array,
                                   T value)
```
    数组中是否包含元素
    
    类型参数:
    
    T - 数组元素类型
    
    参数:
    
    array - 数组
    
    value - 被检查的元素
    
    返回:
    
    是否包含
  - containsIgnoreCase
```
public static boolean containsIgnoreCase(CharSequence[] array,
                                         CharSequence value)
```
    数组中是否包含元素，忽略大小写
    
    参数:
    
    array - 数组
    
    value - 被检查的元素
    
    返回:
    
    是否包含
    
    从以下版本开始:
    
    3.1.2
  - indexOf
```
public static int indexOf(long[] array,
                          long value)
```
    返回数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    参数:
    
    array - 数组
    
    value - 被检查的元素
    
    返回:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    从以下版本开始:
    
    3.0.7
  - lastIndexOf
```
public static int lastIndexOf(long[] array,
                              long value)
```
    返回数组中指定元素所在最后的位置，未找到返回INDEX_NOT_FOUND
    
    参数:
    
    array - 数组
    
    value - 被检查的元素
    
    返回:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    从以下版本开始:
    
    3.0.7
  - contains
```
public static boolean contains(long[] array,
                               long value)
```
    数组中是否包含元素
    
    参数:
    
    array - 数组
    
    value - 被检查的元素
    
    返回:
    
    是否包含
    
    从以下版本开始:
    
    3.0.7
  - indexOf
```
public static int indexOf(int[] array,
                          int value)
```
    返回数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    参数:
    
    array - 数组
    
    value - 被检查的元素
    
    返回:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    从以下版本开始:
    
    3.0.7
  - lastIndexOf
```
public static int lastIndexOf(int[] array,
                              int value)
```
    返回数组中指定元素所在最后的位置，未找到返回INDEX_NOT_FOUND
    
    参数:
    
    array - 数组
    
    value - 被检查的元素
    
    返回:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    从以下版本开始:
    
    3.0.7
  - contains
```
public static boolean contains(int[] array,
                               int value)
```
    数组中是否包含元素
    
    参数:
    
    array - 数组
    
    value - 被检查的元素
    
    返回:
    
    是否包含
    
    从以下版本开始:
    
    3.0.7
  - indexOf
```
public static int indexOf(short[] array,
                          short value)
```
    返回数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    参数:
    
    array - 数组
    
    value - 被检查的元素
    
    返回:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    从以下版本开始:
    
    3.0.7
  - lastIndexOf
```
public static int lastIndexOf(short[] array,
                              short value)
```
    返回数组中指定元素所在最后的位置，未找到返回INDEX_NOT_FOUND
    
    参数:
    
    array - 数组
    
    value - 被检查的元素
    
    返回:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    从以下版本开始:
    
    3.0.7
  - contains
```
public static boolean contains(short[] array,
                               short value)
```
    数组中是否包含元素
    
    参数:
    
    array - 数组
    
    value - 被检查的元素
    
    返回:
    
    是否包含
    
    从以下版本开始:
    
    3.0.7
  - indexOf
```
public static int indexOf(char[] array,
                          char value)
```
    返回数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    参数:
    
    array - 数组
    
    value - 被检查的元素
    
    返回:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    从以下版本开始:
    
    3.0.7
  - lastIndexOf
```
public static int lastIndexOf(char[] array,
                              char value)
```
    返回数组中指定元素所在最后的位置，未找到返回INDEX_NOT_FOUND
    
    参数:
    
    array - 数组
    
    value - 被检查的元素
    
    返回:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    从以下版本开始:
    
    3.0.7
  - contains
```
public static boolean contains(char[] array,
                               char value)
```
    数组中是否包含元素
    
    参数:
    
    array - 数组
    
    value - 被检查的元素
    
    返回:
    
    是否包含
    
    从以下版本开始:
    
    3.0.7
  - indexOf
```
public static int indexOf(byte[] array,
                          byte value)
```
    返回数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    参数:
    
    array - 数组
    
    value - 被检查的元素
    
    返回:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    从以下版本开始:
    
    3.0.7
  - lastIndexOf
```
public static int lastIndexOf(byte[] array,
                              byte value)
```
    返回数组中指定元素所在最后的位置，未找到返回INDEX_NOT_FOUND
    
    参数:
    
    array - 数组
    
    value - 被检查的元素
    
    返回:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    从以下版本开始:
    
    3.0.7
  - contains
```
public static boolean contains(byte[] array,
                               byte value)
```
    数组中是否包含元素
    
    参数:
    
    array - 数组
    
    value - 被检查的元素
    
    返回:
    
    是否包含
    
    从以下版本开始:
    
    3.0.7
  - indexOf
```
public static int indexOf(double[] array,
                          double value)
```
    返回数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    参数:
    
    array - 数组
    
    value - 被检查的元素
    
    返回:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    从以下版本开始:
    
    3.0.7
  - lastIndexOf
```
public static int lastIndexOf(double[] array,
                              double value)
```
    返回数组中指定元素所在最后的位置，未找到返回INDEX_NOT_FOUND
    
    参数:
    
    array - 数组
    
    value - 被检查的元素
    
    返回:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    从以下版本开始:
    
    3.0.7
  - contains
```
public static boolean contains(double[] array,
                               double value)
```
    数组中是否包含元素
    
    参数:
    
    array - 数组
    
    value - 被检查的元素
    
    返回:
    
    是否包含
    
    从以下版本开始:
    
    3.0.7
  - indexOf
```
public static int indexOf(float[] array,
                          float value)
```
    返回数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    参数:
    
    array - 数组
    
    value - 被检查的元素
    
    返回:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    从以下版本开始:
    
    3.0.7
  - lastIndexOf
```
public static int lastIndexOf(float[] array,
                              float value)
```
    返回数组中指定元素所在最后的位置，未找到返回INDEX_NOT_FOUND
    
    参数:
    
    array - 数组
    
    value - 被检查的元素
    
    返回:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    从以下版本开始:
    
    3.0.7
  - contains
```
public static boolean contains(float[] array,
                               float value)
```
    数组中是否包含元素
    
    参数:
    
    array - 数组
    
    value - 被检查的元素
    
    返回:
    
    是否包含
    
    从以下版本开始:
    
    3.0.7
  - indexOf
```
public static int indexOf(boolean[] array,
                          boolean value)
```
    返回数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    参数:
    
    array - 数组
    
    value - 被检查的元素
    
    返回:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    从以下版本开始:
    
    3.0.7
  - lastIndexOf
```
public static int lastIndexOf(boolean[] array,
                              boolean value)
```
    返回数组中指定元素所在最后的位置，未找到返回INDEX_NOT_FOUND
    
    参数:
    
    array - 数组
    
    value - 被检查的元素
    
    返回:
    
    数组中指定元素所在位置，未找到返回INDEX_NOT_FOUND
    
    从以下版本开始:
    
    3.0.7
  - contains
```
public static boolean contains(boolean[] array,
                               boolean value)
```
    数组中是否包含元素
    
    参数:
    
    array - 数组
    
    value - 被检查的元素
    
    返回:
    
    是否包含
    
    从以下版本开始:
    
    3.0.7
  - wrap
```
public static Integer[] wrap(int... values)
```
    将原始类型数组包装为包装类型
    
    参数:
    
    values - 原始类型数组
    
    返回:
    
    包装类型数组
  - unWrap
```
public static int[] unWrap(Integer... values)
```
    包装类数组转为原始类型数组
    
    参数:
    
    values - 包装类型数组
    
    返回:
    
    原始类型数组
  - wrap
```
public static Long[] wrap(long... values)
```
    将原始类型数组包装为包装类型
    
    参数:
    
    values - 原始类型数组
    
    返回:
    
    包装类型数组
  - unWrap
```
public static long[] unWrap(Long... values)
```
    包装类数组转为原始类型数组
    
    参数:
    
    values - 包装类型数组
    
    返回:
    
    原始类型数组
  - wrap
```
public static Character[] wrap(char... values)
```
    将原始类型数组包装为包装类型
    
    参数:
    
    values - 原始类型数组
    
    返回:
    
    包装类型数组
  - unWrap
```
public static char[] unWrap(Character... values)
```
    包装类数组转为原始类型数组
    
    参数:
    
    values - 包装类型数组
    
    返回:
    
    原始类型数组
  - wrap
```
public static Byte[] wrap(byte... values)
```
    将原始类型数组包装为包装类型
    
    参数:
    
    values - 原始类型数组
    
    返回:
    
    包装类型数组
  - unWrap
```
public static byte[] unWrap(Byte... values)
```
    包装类数组转为原始类型数组
    
    参数:
    
    values - 包装类型数组
    
    返回:
    
    原始类型数组
  - wrap
```
public static Short[] wrap(short... values)
```
    将原始类型数组包装为包装类型
    
    参数:
    
    values - 原始类型数组
    
    返回:
    
    包装类型数组
  - unWrap
```
public static short[] unWrap(Short... values)
```
    包装类数组转为原始类型数组
    
    参数:
    
    values - 包装类型数组
    
    返回:
    
    原始类型数组
  - wrap
```
public static Float[] wrap(float... values)
```
    将原始类型数组包装为包装类型
    
    参数:
    
    values - 原始类型数组
    
    返回:
    
    包装类型数组
  - unWrap
```
public static float[] unWrap(Float... values)
```
    包装类数组转为原始类型数组
    
    参数:
    
    values - 包装类型数组
    
    返回:
    
    原始类型数组
  - wrap
```
public static Double[] wrap(double... values)
```
    将原始类型数组包装为包装类型
    
    参数:
    
    values - 原始类型数组
    
    返回:
    
    包装类型数组
  - unWrap
```
public static double[] unWrap(Double... values)
```
    包装类数组转为原始类型数组
    
    参数:
    
    values - 包装类型数组
    
    返回:
    
    原始类型数组
  - wrap
```
public static Boolean[] wrap(boolean... values)
```
    将原始类型数组包装为包装类型
    
    参数:
    
    values - 原始类型数组
    
    返回:
    
    包装类型数组
  - unWrap
```
public static boolean[] unWrap(Boolean... values)
```
    包装类数组转为原始类型数组
    
    参数:
    
    values - 包装类型数组
    
    返回:
    
    原始类型数组
  - wrap
```
public static Object[] wrap(Object obj)
```
    包装数组对象
    
    参数:
    
    obj - 对象，可以是对象数组或者基本类型数组
    
    返回:
    
    包装类型数组或对象数组
    
    抛出:
    
    UtilException - 对象为非数组
  - isArray
```
public static boolean isArray(Object obj)
```
    对象是否为数组对象
    
    参数:
    
    obj - 对象
    
    返回:
    
    是否为数组对象，如果为null 返回false
  - toString
```
public static String toString(Object obj)
```
    数组或集合转String
    
    参数:
    
    obj - 集合或数组对象
    
    返回:
    
    数组字符串，与集合转字符串格式相同
  - length
```
public static int length(Object array)
                  throws IllegalArgumentException
```
    获取数组长度
    如果参数为null，返回0
```
 ArrayUtil.length(null)            = 0
 ArrayUtil.length([])              = 0
 ArrayUtil.length([null])          = 1
 ArrayUtil.length([true, false])   = 2
 ArrayUtil.length([1, 2, 3])       = 3
 ArrayUtil.length(["a", "b", "c"]) = 3
 
```
    参数:
    
    array - 数组对象
    
    返回:
    
    数组长度
    
    抛出:
    
    IllegalArgumentException - 如果参数不为数组，抛出此异常
    
    从以下版本开始:
    
    3.0.8
    
    另请参阅:
    
    Array.getLength(Object)
  - join
```
public static <T> String join(T[] array,
                              CharSequence conjunction)
```
    以 conjunction 为分隔符将数组转换为字符串
    
    类型参数:
    
    T - 被处理的集合
    
    参数:
    
    array - 数组
    
    conjunction - 分隔符
    
    返回:
    
    连接后的字符串
  - join
```
public static String join(long[] array,
                          String conjunction)
```
    以 conjunction 为分隔符将数组转换为字符串
    
    参数:
    
    array - 数组
    
    conjunction - 分隔符
    
    返回:
    
    连接后的字符串
  - join
```
public static String join(int[] array,
                          String conjunction)
```
    以 conjunction 为分隔符将数组转换为字符串
    
    参数:
    
    array - 数组
    
    conjunction - 分隔符
    
    返回:
    
    连接后的字符串
  - join
```
public static String join(short[] array,
                          String conjunction)
```
    以 conjunction 为分隔符将数组转换为字符串
    
    参数:
    
    array - 数组
    
    conjunction - 分隔符
    
    返回:
    
    连接后的字符串
  - join
```
public static String join(char[] array,
                          String conjunction)
```
    以 conjunction 为分隔符将数组转换为字符串
    
    参数:
    
    array - 数组
    
    conjunction - 分隔符
    
    返回:
    
    连接后的字符串
  - join
```
public static String join(byte[] array,
                          String conjunction)
```
    以 conjunction 为分隔符将数组转换为字符串
    
    参数:
    
    array - 数组
    
    conjunction - 分隔符
    
    返回:
    
    连接后的字符串
  - join
```
public static String join(boolean[] array,
                          String conjunction)
```
    以 conjunction 为分隔符将数组转换为字符串
    
    参数:
    
    array - 数组
    
    conjunction - 分隔符
    
    返回:
    
    连接后的字符串
  - join
```
public static String join(float[] array,
                          String conjunction)
```
    以 conjunction 为分隔符将数组转换为字符串
    
    参数:
    
    array - 数组
    
    conjunction - 分隔符
    
    返回:
    
    连接后的字符串
  - join
```
public static String join(double[] array,
                          String conjunction)
```
    以 conjunction 为分隔符将数组转换为字符串
    
    参数:
    
    array - 数组
    
    conjunction - 分隔符
    
    返回:
    
    连接后的字符串
  - join
```
public static String join(Object array,
                          CharSequence conjunction)
```
    以 conjunction 为分隔符将数组转换为字符串
    
    参数:
    
    array - 数组
    
    conjunction - 分隔符
    
    返回:
    
    连接后的字符串
  - toArray
```
public static byte[] toArray(ByteBuffer bytebuffer)
```
    ByteBuffer 转byte数组
    
    参数:
    
    bytebuffer - ByteBuffer
    
    返回:
    
    byte数组
    
    从以下版本开始:
    
    3.0.1
  - toArray
```
public static <T> T[] toArray(Iterator<T> iterator,
                              Class<T> componentType)
```
    将集合转为数组
    
    类型参数:
    
    T - 数组元素类型
    
    参数:
    
    iterator - Iterator
    
    componentType - 集合元素类型
    
    返回:
    
    数组
    
    从以下版本开始:
    
    3.0.9
  - toArray
```
public static <T> T[] toArray(Iterable<T> iterable,
                              Class<T> componentType)
```
    将集合转为数组
    
    类型参数:
    
    T - 数组元素类型
    
    参数:
    
    iterable - Iterable
    
    componentType - 集合元素类型
    
    返回:
    
    数组
    
    从以下版本开始:
    
    3.0.9
  - toArray
```
public static <T> T[] toArray(Collection<T> collection,
                              Class<T> componentType)
```
    将集合转为数组
    
    类型参数:
    
    T - 数组元素类型
    
    参数:
    
    collection - 集合
    
    componentType - 集合元素类型
    
    返回:
    
    数组
    
    从以下版本开始:
    
    3.0.9
  - remove
```
public static <T> T[] remove(T[] array,
                             int index)
                      throws IllegalArgumentException
```
    移除数组中对应位置的元素
    copy from commons-lang
    
    类型参数:
    
    T - 数组元素类型
    
    参数:
    
    array - 数组对象，可以是对象数组，也可以原始类型数组
    
    index - 位置，如果位置小于0或者大于长度，返回原数组
    
    返回:
    
    去掉指定元素后的新数组或原数组
    
    抛出:
    
    IllegalArgumentException - 参数对象不为数组对象
    
    从以下版本开始:
    
    3.0.8
  - remove
```
public static long[] remove(long[] array,
                            int index)
                     throws IllegalArgumentException
```
    移除数组中对应位置的元素
    copy from commons-lang
    
    参数:
    
    array - 数组对象，可以是对象数组，也可以原始类型数组
    
    index - 位置，如果位置小于0或者大于长度，返回原数组
    
    返回:
    
    去掉指定元素后的新数组或原数组
    
    抛出:
    
    IllegalArgumentException - 参数对象不为数组对象
    
    从以下版本开始:
    
    3.0.8
  - remove
```
public static int[] remove(int[] array,
                           int index)
                    throws IllegalArgumentException
```
    移除数组中对应位置的元素
    copy from commons-lang
    
    参数:
    
    array - 数组对象，可以是对象数组，也可以原始类型数组
    
    index - 位置，如果位置小于0或者大于长度，返回原数组
    
    返回:
    
    去掉指定元素后的新数组或原数组
    
    抛出:
    
    IllegalArgumentException - 参数对象不为数组对象
    
    从以下版本开始:
    
    3.0.8
  - remove
```
public static short[] remove(short[] array,
                             int index)
                      throws IllegalArgumentException
```
    移除数组中对应位置的元素
    copy from commons-lang
    
    参数:
    
    array - 数组对象，可以是对象数组，也可以原始类型数组
    
    index - 位置，如果位置小于0或者大于长度，返回原数组
    
    返回:
    
    去掉指定元素后的新数组或原数组
    
    抛出:
    
    IllegalArgumentException - 参数对象不为数组对象
    
    从以下版本开始:
    
    3.0.8
  - remove
```
public static char[] remove(char[] array,
                            int index)
                     throws IllegalArgumentException
```
    移除数组中对应位置的元素
    copy from commons-lang
    
    参数:
    
    array - 数组对象，可以是对象数组，也可以原始类型数组
    
    index - 位置，如果位置小于0或者大于长度，返回原数组
    
    返回:
    
    去掉指定元素后的新数组或原数组
    
    抛出:
    
    IllegalArgumentException - 参数对象不为数组对象
    
    从以下版本开始:
    
    3.0.8
  - remove
```
public static byte[] remove(byte[] array,
                            int index)
                     throws IllegalArgumentException
```
    移除数组中对应位置的元素
    copy from commons-lang
    
    参数:
    
    array - 数组对象，可以是对象数组，也可以原始类型数组
    
    index - 位置，如果位置小于0或者大于长度，返回原数组
    
    返回:
    
    去掉指定元素后的新数组或原数组
    
    抛出:
    
    IllegalArgumentException - 参数对象不为数组对象
    
    从以下版本开始:
    
    3.0.8
  - remove
```
public static double[] remove(double[] array,
                              int index)
                       throws IllegalArgumentException
```
    移除数组中对应位置的元素
    copy from commons-lang
    
    参数:
    
    array - 数组对象，可以是对象数组，也可以原始类型数组
    
    index - 位置，如果位置小于0或者大于长度，返回原数组
    
    返回:
    
    去掉指定元素后的新数组或原数组
    
    抛出:
    
    IllegalArgumentException - 参数对象不为数组对象
    
    从以下版本开始:
    
    3.0.8
  - remove
```
public static float[] remove(float[] array,
                             int index)
                      throws IllegalArgumentException
```
    移除数组中对应位置的元素
    copy from commons-lang
    
    参数:
    
    array - 数组对象，可以是对象数组，也可以原始类型数组
    
    index - 位置，如果位置小于0或者大于长度，返回原数组
    
    返回:
    
    去掉指定元素后的新数组或原数组
    
    抛出:
    
    IllegalArgumentException - 参数对象不为数组对象
    
    从以下版本开始:
    
    3.0.8
  - remove
```
public static boolean[] remove(boolean[] array,
                               int index)
                        throws IllegalArgumentException
```
    移除数组中对应位置的元素
    copy from commons-lang
    
    参数:
    
    array - 数组对象，可以是对象数组，也可以原始类型数组
    
    index - 位置，如果位置小于0或者大于长度，返回原数组
    
    返回:
    
    去掉指定元素后的新数组或原数组
    
    抛出:
    
    IllegalArgumentException - 参数对象不为数组对象
    
    从以下版本开始:
    
    3.0.8
  - remove
```
public static Object remove(Object array,
                            int index)
                     throws IllegalArgumentException
```
    移除数组中对应位置的元素
    copy from commons-lang
    
    参数:
    
    array - 数组对象，可以是对象数组，也可以原始类型数组
    
    index - 位置，如果位置小于0或者大于长度，返回原数组
    
    返回:
    
    去掉指定元素后的新数组或原数组
    
    抛出:
    
    IllegalArgumentException - 参数对象不为数组对象
    
    从以下版本开始:
    
    3.0.8
  - removeEle
```
public static <T> T[] removeEle(T[] array,
                                T element)
                         throws IllegalArgumentException
```
    移除数组中指定的元素
    只会移除匹配到的第一个元素 copy from commons-lang
    
    类型参数:
    
    T - 数组元素类型
    
    参数:
    
    array - 数组对象，可以是对象数组，也可以原始类型数组
    
    element - 要移除的元素
    
    返回:
    
    去掉指定元素后的新数组或原数组
    
    抛出:
    
    IllegalArgumentException - 参数对象不为数组对象
    
    从以下版本开始:
    
    3.0.8
  - removeEle
```
public static long[] removeEle(long[] array,
                               long element)
                        throws IllegalArgumentException
```
    移除数组中指定的元素
    只会移除匹配到的第一个元素 copy from commons-lang
    
    参数:
    
    array - 数组对象，可以是对象数组，也可以原始类型数组
    
    element - 要移除的元素
    
    返回:
    
    去掉指定元素后的新数组或原数组
    
    抛出:
    
    IllegalArgumentException - 参数对象不为数组对象
    
    从以下版本开始:
    
    3.0.8
  - removeEle
```
public static int[] removeEle(int[] array,
                              int element)
                       throws IllegalArgumentException
```
    移除数组中指定的元素
    只会移除匹配到的第一个元素 copy from commons-lang
    
    参数:
    
    array - 数组对象，可以是对象数组，也可以原始类型数组
    
    element - 要移除的元素
    
    返回:
    
    去掉指定元素后的新数组或原数组
    
    抛出:
    
    IllegalArgumentException - 参数对象不为数组对象
    
    从以下版本开始:
    
    3.0.8
  - removeEle
```
public static short[] removeEle(short[] array,
                                short element)
                         throws IllegalArgumentException
```
    移除数组中指定的元素
    只会移除匹配到的第一个元素 copy from commons-lang
    
    参数:
    
    array - 数组对象，可以是对象数组，也可以原始类型数组
    
    element - 要移除的元素
    
    返回:
    
    去掉指定元素后的新数组或原数组
    
    抛出:
    
    IllegalArgumentException - 参数对象不为数组对象
    
    从以下版本开始:
    
    3.0.8
  - removeEle
```
public static char[] removeEle(char[] array,
                               char element)
                        throws IllegalArgumentException
```
    移除数组中指定的元素
    只会移除匹配到的第一个元素 copy from commons-lang
    
    参数:
    
    array - 数组对象，可以是对象数组，也可以原始类型数组
    
    element - 要移除的元素
    
    返回:
    
    去掉指定元素后的新数组或原数组
    
    抛出:
    
    IllegalArgumentException - 参数对象不为数组对象
    
    从以下版本开始:
    
    3.0.8
  - removeEle
```
public static byte[] removeEle(byte[] array,
                               byte element)
                        throws IllegalArgumentException
```
    移除数组中指定的元素
    只会移除匹配到的第一个元素 copy from commons-lang
    
    参数:
    
    array - 数组对象，可以是对象数组，也可以原始类型数组
    
    element - 要移除的元素
    
    返回:
    
    去掉指定元素后的新数组或原数组
    
    抛出:
    
    IllegalArgumentException - 参数对象不为数组对象
    
    从以下版本开始:
    
    3.0.8
  - removeEle
```
public static double[] removeEle(double[] array,
                                 double element)
                          throws IllegalArgumentException
```
    移除数组中指定的元素
    只会移除匹配到的第一个元素 copy from commons-lang
    
    参数:
    
    array - 数组对象，可以是对象数组，也可以原始类型数组
    
    element - 要移除的元素
    
    返回:
    
    去掉指定元素后的新数组或原数组
    
    抛出:
    
    IllegalArgumentException - 参数对象不为数组对象
    
    从以下版本开始:
    
    3.0.8
  - removeEle
```
public static float[] removeEle(float[] array,
                                float element)
                         throws IllegalArgumentException
```
    移除数组中指定的元素
    只会移除匹配到的第一个元素 copy from commons-lang
    
    参数:
    
    array - 数组对象，可以是对象数组，也可以原始类型数组
    
    element - 要移除的元素
    
    返回:
    
    去掉指定元素后的新数组或原数组
    
    抛出:
    
    IllegalArgumentException - 参数对象不为数组对象
    
    从以下版本开始:
    
    3.0.8
  - removeEle
```
public static boolean[] removeEle(boolean[] array,
                                  boolean element)
                           throws IllegalArgumentException
```
    移除数组中指定的元素
    只会移除匹配到的第一个元素 copy from commons-lang
    
    参数:
    
    array - 数组对象，可以是对象数组，也可以原始类型数组
    
    element - 要移除的元素
    
    返回:
    
    去掉指定元素后的新数组或原数组
    
    抛出:
    
    IllegalArgumentException - 参数对象不为数组对象
    
    从以下版本开始:
    
    3.0.8
  - reverse
```
public static <T> T[] reverse(T[] array,
                              int startIndexInclusive,
                              int endIndexExclusive)
```
    反转数组，会变更原数组
    
    类型参数:
    
    T - 数组元素类型
    
    参数:
    
    array - 数组，会变更
    
    startIndexInclusive - 其实位置（包含）
    
    endIndexExclusive - 结束位置（不包含）
    
    返回:
    
    变更后的原数组
    
    从以下版本开始:
    
    3.0.9
  - reverse
```
public static <T> T[] reverse(T[] array)
```
    反转数组，会变更原数组
    
    类型参数:
    
    T - 数组元素类型
    
    参数:
    
    array - 数组，会变更
    
    返回:
    
    变更后的原数组
    
    从以下版本开始:
    
    3.0.9
  - reverse
```
public static long[] reverse(long[] array,
                             int startIndexInclusive,
                             int endIndexExclusive)
```
    反转数组，会变更原数组
    
    参数:
    
    array - 数组，会变更
    
    startIndexInclusive - 其实位置（包含）
    
    endIndexExclusive - 结束位置（不包含）
    
    返回:
    
    变更后的原数组
    
    从以下版本开始:
    
    3.0.9
  - reverse
```
public static long[] reverse(long[] array)
```
    反转数组，会变更原数组
    
    参数:
    
    array - 数组，会变更
    
    返回:
    
    变更后的原数组
    
    从以下版本开始:
    
    3.0.9
  - reverse
```
public static int[] reverse(int[] array,
                            int startIndexInclusive,
                            int endIndexExclusive)
```
    反转数组，会变更原数组
    
    参数:
    
    array - 数组，会变更
    
    startIndexInclusive - 其实位置（包含）
    
    endIndexExclusive - 结束位置（不包含）
    
    返回:
    
    变更后的原数组
    
    从以下版本开始:
    
    3.0.9
  - reverse
```
public static int[] reverse(int[] array)
```
    反转数组，会变更原数组
    
    参数:
    
    array - 数组，会变更
    
    返回:
    
    变更后的原数组
    
    从以下版本开始:
    
    3.0.9
  - reverse
```
public static short[] reverse(short[] array,
                              int startIndexInclusive,
                              int endIndexExclusive)
```
    反转数组，会变更原数组
    
    参数:
    
    array - 数组，会变更
    
    startIndexInclusive - 其实位置（包含）
    
    endIndexExclusive - 结束位置（不包含）
    
    返回:
    
    变更后的原数组
    
    从以下版本开始:
    
    3.0.9
  - reverse
```
public static short[] reverse(short[] array)
```
    反转数组，会变更原数组
    
    参数:
    
    array - 数组，会变更
    
    返回:
    
    变更后的原数组
    
    从以下版本开始:
    
    3.0.9
  - reverse
```
public static char[] reverse(char[] array,
                             int startIndexInclusive,
                             int endIndexExclusive)
```
    反转数组，会变更原数组
    
    参数:
    
    array - 数组，会变更
    
    startIndexInclusive - 其实位置（包含）
    
    endIndexExclusive - 结束位置（不包含）
    
    返回:
    
    变更后的原数组
    
    从以下版本开始:
    
    3.0.9
  - reverse
```
public static char[] reverse(char[] array)
```
    反转数组，会变更原数组
    
    参数:
    
    array - 数组，会变更
    
    返回:
    
    变更后的原数组
    
    从以下版本开始:
    
    3.0.9
  - reverse
```
public static byte[] reverse(byte[] array,
                             int startIndexInclusive,
                             int endIndexExclusive)
```
    反转数组，会变更原数组
    
    参数:
    
    array - 数组，会变更
    
    startIndexInclusive - 其实位置（包含）
    
    endIndexExclusive - 结束位置（不包含）
    
    返回:
    
    变更后的原数组
    
    从以下版本开始:
    
    3.0.9
  - reverse
```
public static byte[] reverse(byte[] array)
```
    反转数组，会变更原数组
    
    参数:
    
    array - 数组，会变更
    
    返回:
    
    变更后的原数组
    
    从以下版本开始:
    
    3.0.9
  - reverse
```
public static double[] reverse(double[] array,
                               int startIndexInclusive,
                               int endIndexExclusive)
```
    反转数组，会变更原数组
    
    参数:
    
    array - 数组，会变更
    
    startIndexInclusive - 其实位置（包含）
    
    endIndexExclusive - 结束位置（不包含）
    
    返回:
    
    变更后的原数组
    
    从以下版本开始:
    
    3.0.9
  - reverse
```
public static double[] reverse(double[] array)
```
    反转数组，会变更原数组
    
    参数:
    
    array - 数组，会变更
    
    返回:
    
    变更后的原数组
    
    从以下版本开始:
    
    3.0.9
  - reverse
```
public static float[] reverse(float[] array,
                              int startIndexInclusive,
                              int endIndexExclusive)
```
    反转数组，会变更原数组
    
    参数:
    
    array - 数组，会变更
    
    startIndexInclusive - 其实位置（包含）
    
    endIndexExclusive - 结束位置（不包含）
    
    返回:
    
    变更后的原数组
    
    从以下版本开始:
    
    3.0.9
  - reverse
```
public static float[] reverse(float[] array)
```
    反转数组，会变更原数组
    
    参数:
    
    array - 数组，会变更
    
    返回:
    
    变更后的原数组
    
    从以下版本开始:
    
    3.0.9
  - reverse
```
public static boolean[] reverse(boolean[] array,
                                int startIndexInclusive,
                                int endIndexExclusive)
```
    反转数组，会变更原数组
    
    参数:
    
    array - 数组，会变更
    
    startIndexInclusive - 其实位置（包含）
    
    endIndexExclusive - 结束位置（不包含）
    
    返回:
    
    变更后的原数组
    
    从以下版本开始:
    
    3.0.9
  - reverse
```
public static boolean[] reverse(boolean[] array)
```
    反转数组，会变更原数组
    
    参数:
    
    array - 数组，会变更
    
    返回:
    
    变更后的原数组
    
    从以下版本开始:
    
    3.0.9
  - min
```
public static <T extends Comparable<? super T>> T min(T[] numberArray)
```
    取最小值
    
    类型参数:
    
    T - 元素类型
    
    参数:
    
    numberArray - 数字数组
    
    返回:
    
    最小值
    
    从以下版本开始:
    
    3.0.9
  - min
```
public static long min(long[] numberArray)
```
    取最小值
    
    参数:
    
    numberArray - 数字数组
    
    返回:
    
    最小值
    
    从以下版本开始:
    
    3.0.9
  - min
```
public static int min(int[] numberArray)
```
    取最小值
    
    参数:
    
    numberArray - 数字数组
    
    返回:
    
    最小值
    
    从以下版本开始:
    
    3.0.9
  - min
```
public static short min(short[] numberArray)
```
    取最小值
    
    参数:
    
    numberArray - 数字数组
    
    返回:
    
    最小值
    
    从以下版本开始:
    
    3.0.9
  - min
```
public static char min(char[] numberArray)
```
    取最小值
    
    参数:
    
    numberArray - 数字数组
    
    返回:
    
    最小值
    
    从以下版本开始:
    
    3.0.9
  - min
```
public static byte min(byte[] numberArray)
```
    取最小值
    
    参数:
    
    numberArray - 数字数组
    
    返回:
    
    最小值
    
    从以下版本开始:
    
    3.0.9
  - min
```
public static double min(double[] numberArray)
```
    取最小值
    
    参数:
    
    numberArray - 数字数组
    
    返回:
    
    最小值
    
    从以下版本开始:
    
    3.0.9
  - min
```
public static float min(float[] numberArray)
```
    取最小值
    
    参数:
    
    numberArray - 数字数组
    
    返回:
    
    最小值
    
    从以下版本开始:
    
    3.0.9
  - max
```
public static <T extends Comparable<? super T>> T max(T[] numberArray)
```
    取最大值
    
    类型参数:
    
    T - 元素类型
    
    参数:
    
    numberArray - 数字数组
    
    返回:
    
    最大值
    
    从以下版本开始:
    
    3.0.9
  - max
```
public static long max(long[] numberArray)
```
    取最大值
    
    参数:
    
    numberArray - 数字数组
    
    返回:
    
    最大值
    
    从以下版本开始:
    
    3.0.9
  - max
```
public static int max(int[] numberArray)
```
    取最大值
    
    参数:
    
    numberArray - 数字数组
    
    返回:
    
    最大值
    
    从以下版本开始:
    
    3.0.9
  - max
```
public static short max(short[] numberArray)
```
    取最大值
    
    参数:
    
    numberArray - 数字数组
    
    返回:
    
    最大值
    
    从以下版本开始:
    
    3.0.9
  - max
```
public static char max(char[] numberArray)
```
    取最大值
    
    参数:
    
    numberArray - 数字数组
    
    返回:
    
    最大值
    
    从以下版本开始:
    
    3.0.9
  - max
```
public static byte max(byte[] numberArray)
```
    取最大值
    
    参数:
    
    numberArray - 数字数组
    
    返回:
    
    最大值
    
    从以下版本开始:
    
    3.0.9
  - max
```
public static double max(double[] numberArray)
```
    取最大值
    
    参数:
    
    numberArray - 数字数组
    
    返回:
    
    最大值
    
    从以下版本开始:
    
    3.0.9
  - max
```
public static float max(float[] numberArray)
```
    取最大值
    
    参数:
    
    numberArray - 数字数组
    
    返回:
    
    最大值
    
    从以下版本开始:
    
    3.0.9

类 ArrayUtil

字段概要

构造器概要

方法概要

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

字段详细资料

INDEX_NOT_FOUND

构造器详细资料

ArrayUtil

方法详细资料

isEmpty

isEmpty

isEmpty

isEmpty

isEmpty

isEmpty

isEmpty

isEmpty

isEmpty

isEmpty

isNotEmpty

isNotEmpty

isNotEmpty

isNotEmpty

isNotEmpty

isNotEmpty

isNotEmpty

isNotEmpty

isNotEmpty

isNotEmpty

hasNull

firstNonNull

newArray

newArray

getComponentType

getComponentType

getArrayType

cast

append

resize

resize

addAll

copy

copy

clone

clone

range

range

range

split

filter

filter

removeNull

removeEmpty

removeBlank

nullToEmpty

zip

zip

indexOf

indexOfIgnoreCase

lastIndexOf

contains

containsIgnoreCase

indexOf

lastIndexOf

contains

indexOf

lastIndexOf

contains

indexOf

lastIndexOf

contains

indexOf

lastIndexOf

contains

indexOf

lastIndexOf

contains

indexOf

lastIndexOf