ArrayUtil (hutool 5.8.33 API)

java.lang.Object
- cn.hutool.core.util.PrimitiveArrayUtil
- - cn.hutool.core.util.ArrayUtil

public class ArrayUtil
extends PrimitiveArrayUtil

数组工具类

Author:: Looly

Field Summary
- Fields inherited from class cn.hutool.core.util.PrimitiveArrayUtil
  INDEX_NOT_FOUND

Constructor Summary

Constructors
Constructor and Description

ArrayUtil()

Constructors
Constructor and Description
`ArrayUtil()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static <T> T[]`	`addAll(T[]... arrays)` 将多个数组合并在一起忽略null的数组
`static <T> Object`	`append(Object array, T... newElements)` 将新元素添加到已有数组中添加新元素会生成一个新的数组，不影响原数组
`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 <T> boolean`	`contains(T[] array, T value)` 数组中是否包含元素
`static <T> boolean`	`containsAll(T[] array, T... values)` 数组中是否包含指定元素中的全部
`static <T> boolean`	`containsAny(T[] array, T... values)` 数组中是否包含指定元素中的任意一个
`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[]`	`defaultIfEmpty(T[] array, T[] defaultArray)` 如果给定数组为空，返回默认数组
`static <T> T[]`	`distinct(T[] array)` 去重数组中的元素，去重后生成新的数组，原数组不变此方法通过`LinkedHashSet` 去重
`static <T,K> T[]`	`distinct(T[] array, Function<T,K> uniqueGenerator, boolean override)` 去重数组中的元素，去重后生成新的数组，原数组不变此方法通过`LinkedHashSet` 去重
`static <T> T[]`	`edit(T[] array, Editor<T> editor)` 编辑数组编辑过程通过传入的Editor实现来返回需要的元素内容，这个Editor实现可以实现以下功能： 1、过滤出需要的对象，如果返回 `null`表示这个元素对象抛弃 2、修改元素对象，返回集合中为修改后的对象
`static int`	`emptyCount(Object... args)` 计算`null`或空元素对象的个数，通过`ObjectUtil.isEmpty(Object)` 判断元素
`static boolean`	`equals(Object array1, Object array2)` 判断两个数组是否相等，判断依据包括数组长度和每个元素都相等。
`static <T> T[]`	`filter(T[] array, Filter<T> filter)` 过滤过滤过程通过传入的Filter实现来过滤返回需要的元素内容，这个Filter实现可以实现以下功能： 1、过滤出需要的对象，`Filter.accept(Object)`方法返回true的对象将被加入结果集合中
`static <T> T`	`firstMatch(Matcher<T> matcher, T... array)` 返回数组中第一个匹配规则的值
`static <T> T`	`firstNonNull(T... array)` 返回数组中第一个非空元素
`static <T> T`	`get(Object array, int index)` 获取数组对象中指定index的值，支持负数，例如-1表示倒数第一个值如果数组下标越界，返回null
`static <T> T[]`	`getAny(Object array, int... indexes)` 获取数组中指定多个下标元素值，组成新数组
`static Class<?>`	`getArrayType(Class<?> componentType)` 根据数组元素类型，获取数组的类型方法是通过创建一个空数组从而获取其类型
`static Class<?>`	`getComponentType(Class<?> arrayClass)` 获取数组对象的元素类型
`static Class<?>`	`getComponentType(Object array)` 获取数组对象的元素类型
`static boolean`	`hasEmpty(Object... args)` 是否存在`null`或空对象，通过`ObjectUtil.isEmpty(Object)` 判断元素
`static <T> boolean`	`hasNull(T... array)` 是否包含`null`元素
`static <T> int`	`indexOf(T[] array, Object value)` 返回数组中指定元素所在位置，未找到返回`PrimitiveArrayUtil.INDEX_NOT_FOUND`
`static <T> int`	`indexOf(T[] array, Object value, int beginIndexInclude)` 返回数组中指定元素所在位置，未找到返回`PrimitiveArrayUtil.INDEX_NOT_FOUND`
`static int`	`indexOfIgnoreCase(CharSequence[] array, CharSequence value)` 返回数组中指定元素所在位置，忽略大小写，未找到返回`PrimitiveArrayUtil.INDEX_NOT_FOUND`
`static <T> int`	`indexOfSub(T[] array, int beginInclude, T[] subArray)` 查找子数组的位置
`static <T> int`	`indexOfSub(T[] array, T[] subArray)` 查找子数组的位置
`static <T> Object`	`insert(Object array, int index, T... newElements)` 将新元素插入到到已有数组中的某个位置添加新元素会生成一个新的数组，不影响原数组如果插入位置为为负数，从原数组从后向前计数，若大于原数组长度，则空白处用null填充
`static <T> T[]`	`insert(T[] buffer, int index, T... newElements)` 将新元素插入到到已有数组中的某个位置添加新元素会生成一个新的数组，不影响原数组如果插入位置为为负数，从原数组从后向前计数，若大于原数组长度，则空白处用null填充
`static boolean`	`isAllEmpty(Object... args)` 是否存都为`null`或空对象，通过`ObjectUtil.isEmpty(Object)` 判断元素
`static boolean`	`isAllNotEmpty(Object... args)` 是否存都不为`null`或空对象，通过`ObjectUtil.isEmpty(Object)` 判断元素
`static <T> boolean`	`isAllNotNull(T... array)` 多个字段是否全部不为null
`static <T> boolean`	`isAllNull(T... array)` 多个字段是否全为null
`static boolean`	`isArray(Object obj)` 对象是否为数组对象
`static boolean`	`isEmpty(Object array)` 数组是否为空此方法会匹配单一对象，如果此对象为`null`则返回true 如果此对象为非数组，理解为此对象为数组的第一个元素，则返回false 如果此对象为数组对象，数组长度大于0情况下返回false，否则返回true
`static <T> boolean`	`isEmpty(T[] array)` 数组是否为空
`static boolean`	`isNotEmpty(Object array)` 数组是否为非空此方法会匹配单一对象，如果此对象为`null`则返回false 如果此对象为非数组，理解为此对象为数组的第一个元素，则返回true 如果此对象为数组对象，数组长度大于0情况下返回true，否则返回false
`static <T> boolean`	`isNotEmpty(T[] array)` 数组是否为非空
`static <T extends Comparable<? super T>> boolean`	`isSorted(T[] array)` 检查数组是否升序，即array[i].compareTo(array[i + 1]) <= 0，若传入空数组，则返回false
`static <T> boolean`	`isSorted(T[] array, Comparator<? super T> comparator)` 检查数组是否有序，即comparator.compare(array[i], array[i + 1]) <= 0，若传入空数组或空比较器，则返回false
`static <T extends Comparable<? super T>> boolean`	`isSortedASC(T[] array)` 检查数组是否升序，即array[i].compareTo(array[i + 1]) <= 0，若传入空数组，则返回false
`static <T extends Comparable<? super T>> boolean`	`isSortedDESC(T[] array)` 检查数组是否降序，即array[i].compareTo(array[i + 1]) >= 0，若传入空数组，则返回false
`static <T> boolean`	`isSub(T[] array, T[] subArray)` 查找子数组的位置
`static String`	`join(Object array, CharSequence conjunction)` 以 conjunction 为分隔符将数组转换为字符串
`static <T> String`	`join(T[] array, CharSequence conjunction)` 以 conjunction 为分隔符将数组转换为字符串
`static <T> String`	`join(T[] array, CharSequence conjunction, Editor<T> editor)` 以 conjunction 为分隔符将数组转换为字符串
`static <T> String`	`join(T[] array, CharSequence delimiter, String prefix, String suffix)` 以 conjunction 为分隔符将数组转换为字符串
`static <T> int`	`lastIndexOf(T[] array, Object value)` 返回数组中指定元素所在最后的位置，未找到返回`PrimitiveArrayUtil.INDEX_NOT_FOUND`
`static <T> int`	`lastIndexOf(T[] array, Object value, int endInclude)` 返回数组中指定元素所在最后的位置，未找到返回`PrimitiveArrayUtil.INDEX_NOT_FOUND`
`static <T> int`	`lastIndexOfSub(T[] array, int endInclude, T[] subArray)` 查找最后一个子数组的开始位置
`static <T> int`	`lastIndexOfSub(T[] array, T[] subArray)` 查找最后一个子数组的开始位置
`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 <T,R> R[]`	`map(Object array, Class<R> targetComponentType, Function<? super T,? extends R> func)` 按照指定规则，将一种类型的数组转换为另一种类型
`static <T,R> R[]`	`map(T[] array, Class<R> targetComponentType, Function<? super T,? extends R> func)` 按照指定规则，将一种类型的数组转换为另一种类型
`static <T,R> List<R>`	`map(T[] array, Function<? super T,? extends R> func)` 按照指定规则，将一种类型的数组元素提取后转换为`List`
`static <T,R> Set<R>`	`mapToSet(T[] array, Function<? super T,? extends R> func)` 按照指定规则，将一种类型的数组元素提取后转换为`Set`
`static <T> int`	`matchIndex(Matcher<T> matcher, int beginIndexInclude, T... array)` 返回数组中第一个匹配规则的值的位置
`static <T> int`	`matchIndex(Matcher<T> matcher, T... array)` 返回数组中第一个匹配规则的值的位置
`static <T extends Comparable<? super T>> T`	`max(T[] numberArray)` 取最大值
`static <T extends Comparable<? super T>> T`	`max(T[] numberArray, Comparator<T> comparator)` 取最大值
`static <T extends Comparable<? super T>> T`	`min(T[] numberArray)` 取最小值
`static <T extends Comparable<? super T>> T`	`min(T[] numberArray, Comparator<T> comparator)` 取最小值
`static <T> T[]`	`newArray(Class<?> componentType, int newSize)` 新建一个空数组
`static Object[]`	`newArray(int newSize)` 新建一个空数组
`static String[]`	`nullToEmpty(String[] array)` 数组元素中的null转换为""
`static <T> T[]`	`remove(T[] array, int index)` 移除数组中对应位置的元素 copy from commons-lang
`static <T extends CharSequence> T[]`	`removeBlank(T[] array)` 去除`null`或者""或者空白字符串元素
`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[]`	`replace(T[] buffer, int index, T... values)` 将新元素插入到到已有数组中的某个位置添加新元素会生成一个新数组或原有数组如果插入位置为为负数，那么生成一个由插入元素顺序加已有数组顺序的新数组
`static Object`	`resize(Object array, int newSize)` 生成一个新的重新设置大小的数组调整大小后拷贝原数组到新数组下。
`static <T> T[]`	`resize(T[] buffer, int newSize)` 生成一个新的重新设置大小的数组新数组的类型为原数组的类型，调整大小后拷贝原数组到新数组下。
`static <T> T[]`	`resize(T[] data, int newSize, Class<?> componentType)` 生成一个新的重新设置大小的数组调整大小后拷贝原数组到新数组下。
`static <T> T[]`	`reverse(T[] array)` 反转数组，会变更原数组
`static <T> T[]`	`reverse(T[] array, int startIndexInclusive, int endIndexExclusive)` 反转数组，会变更原数组
`static Object`	`setOrAppend(Object array, int index, Object value)` 将元素值设置为数组的某个位置，当给定的index大于数组长度，则追加替换时返回原数组，追加时返回新数组
`static <T> T[]`	`setOrAppend(T[] buffer, int index, T value)` 将元素值设置为数组的某个位置，当给定的index大于数组长度，则追加
`static <T> T[]`	`shuffle(T[] array)` 打乱数组顺序，会变更原数组
`static <T> T[]`	`shuffle(T[] array, Random random)` 打乱数组顺序，会变更原数组
`static Object[]`	`sub(Object array, int start, int end)` 获取子数组
`static Object[]`	`sub(Object array, int start, int end, int step)` 获取子数组
`static <T> T[]`	`sub(T[] array, int start, int end)` 获取子数组
`static Object`	`swap(Object array, int index1, int index2)` 交换数组中两个位置的值
`static <T> T[]`	`swap(T[] array, int index1, int index2)` 交换数组中两个位置的值
`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 Object[]`	`wrap(Object obj)` 包装数组对象
`static <K,V> Map<K,V>`	`zip(K[] keys, V[] values)` 映射键值（参考Python的zip()函数），返回Map无序例如： keys = [a,b,c,d] values = [1,2,3,4] 则得到的Map是 {a=1, b=2, c=3, d=4} 如果两个数组长度不同，则只对应最短部分
`static <K,V> Map<K,V>`	`zip(K[] keys, V[] values, boolean isOrder)` 映射键值（参考Python的zip()函数）例如： keys = [a,b,c,d] values = [1,2,3,4] 则得到的Map是 {a=1, b=2, c=3, d=4} 如果两个数组长度不同，则只对应最短部分

Methods inherited from class cn.hutool.core.util.PrimitiveArrayUtil
addAll, addAll, addAll, addAll, addAll, addAll, addAll, addAll, contains, contains, contains, contains, contains, contains, contains, contains, indexOf, indexOf, indexOf, indexOf, indexOf, indexOf, indexOf, indexOf, isEmpty, isEmpty, isEmpty, isEmpty, isEmpty, isEmpty, isEmpty, isEmpty, isNotEmpty, isNotEmpty, isNotEmpty, isNotEmpty, isNotEmpty, isNotEmpty, isNotEmpty, isNotEmpty, isSorted, isSorted, isSorted, isSorted, isSorted, isSorted, isSorted, isSortedASC, isSortedASC, isSortedASC, isSortedASC, isSortedASC, isSortedASC, isSortedASC, isSortedDESC, isSortedDESC, isSortedDESC, isSortedDESC, isSortedDESC, isSortedDESC, isSortedDESC, lastIndexOf, lastIndexOf, lastIndexOf, lastIndexOf, lastIndexOf, lastIndexOf, lastIndexOf, lastIndexOf, max, max, max, max, max, max, max, min, min, min, min, min, min, min, range, range, range, remove, remove, remove, remove, remove, remove, remove, remove, remove, removeEle, removeEle, removeEle, removeEle, removeEle, removeEle, removeEle, removeEle, resize, reverse, reverse, reverse, reverse, reverse, reverse, reverse, reverse, reverse, reverse, reverse, reverse, reverse, reverse, reverse, reverse, shuffle, shuffle, shuffle, shuffle, shuffle, shuffle, shuffle, shuffle, shuffle, shuffle, shuffle, shuffle, shuffle, shuffle, shuffle, shuffle, split, sub, sub, sub, sub, sub, sub, sub, sub, swap, swap, swap, swap, swap, swap, swap, swap, unWrap, unWrap, unWrap, unWrap, unWrap, unWrap, unWrap, unWrap, wrap, wrap, wrap, wrap, wrap, wrap, wrap, wrap

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

- Constructor Detail
  - ArrayUtil
```
public ArrayUtil()
```
- Method Detail
  - isEmpty
```
public static <T> boolean isEmpty(T[] array)
```
    数组是否为空
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    是否为空
  - defaultIfEmpty
```
public static <T> T[] defaultIfEmpty(T[] array,
                                     T[] defaultArray)
```
    如果给定数组为空，返回默认数组
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组
    
    defaultArray - 默认数组
    
    Returns:
    
    非空（empty）的原数组或默认数组
    
    Since:
    
    4.6.9
  - isEmpty
```
public static boolean isEmpty(Object array)
```
    数组是否为空
    此方法会匹配单一对象，如果此对象为null则返回true
    如果此对象为非数组，理解为此对象为数组的第一个元素，则返回false
    如果此对象为数组对象，数组长度大于0情况下返回false，否则返回true
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    是否为空
  - isNotEmpty
```
public static <T> boolean isNotEmpty(T[] array)
```
    数组是否为非空
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    是否为非空
  - isNotEmpty
```
public static boolean isNotEmpty(Object array)
```
    数组是否为非空
    此方法会匹配单一对象，如果此对象为null则返回false
    如果此对象为非数组，理解为此对象为数组的第一个元素，则返回true
    如果此对象为数组对象，数组长度大于0情况下返回true，否则返回false
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    是否为非空
  - hasNull
```
public static <T> boolean hasNull(T... array)
```
    是否包含null元素
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 被检查的数组
    
    Returns:
    
    是否包含null元素
    
    Since:
    
    3.0.7
  - isAllNull
```
public static <T> boolean isAllNull(T... array)
```
    多个字段是否全为null
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 被检查的数组
    
    Returns:
    
    多个字段是否全为null
    
    Since:
    
    5.4.0
  - firstNonNull
```
public static <T> T firstNonNull(T... array)
```
    返回数组中第一个非空元素
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    非空元素，如果不存在非空元素或数组为空，返回null
    
    Since:
    
    3.0.7
  - firstMatch
```
public static <T> T firstMatch(Matcher<T> matcher,
                               T... array)
```
    返回数组中第一个匹配规则的值
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    matcher - 匹配接口，实现此接口自定义匹配规则
    
    array - 数组
    
    Returns:
    
    匹配元素，如果不存在匹配元素或数组为空，返回 null
    
    Since:
    
    3.0.7
  - matchIndex
```
public static <T> int matchIndex(Matcher<T> matcher,
                                 T... array)
```
    返回数组中第一个匹配规则的值的位置
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    matcher - 匹配接口，实现此接口自定义匹配规则
    
    array - 数组
    
    Returns:
    
    匹配到元素的位置，-1表示未匹配到
    
    Since:
    
    5.6.6
  - matchIndex
```
public static <T> int matchIndex(Matcher<T> matcher,
                                 int beginIndexInclude,
                                 T... array)
```
    返回数组中第一个匹配规则的值的位置
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    matcher - 匹配接口，实现此接口自定义匹配规则
    
    beginIndexInclude - 检索开始的位置
    
    array - 数组
    
    Returns:
    
    匹配到元素的位置，-1表示未匹配到
    
    Since:
    
    5.7.3
  - newArray
```
public static <T> T[] newArray(Class<?> componentType,
                               int newSize)
```
    新建一个空数组
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    componentType - 元素类型
    
    newSize - 大小
    
    Returns:
    
    空数组
  - newArray
```
public static Object[] newArray(int newSize)
```
    新建一个空数组
    
    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
```
@SafeVarargs
public static <T> T[] append(T[] buffer,
                                           T... newElements)
```
    将新元素添加到已有数组中
    添加新元素会生成一个新的数组，不影响原数组
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    buffer - 已有数组
    
    newElements - 新元素
    
    Returns:
    
    新数组
  - append
```
@SafeVarargs
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
  - replace
```
public static <T> T[] replace(T[] buffer,
                              int index,
                              T... values)
```
    将新元素插入到到已有数组中的某个位置
    添加新元素会生成一个新数组或原有数组
    如果插入位置为为负数，那么生成一个由插入元素顺序加已有数组顺序的新数组
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    buffer - 已有数组
    
    index - 位置，大于长度追加，否则替换，<0表示从头部追加
    
    values - 新值
    
    Returns:
    
    新数组或原有数组
    
    Since:
    
    5.7.23
  - insert
```
public static <T> T[] insert(T[] buffer,
                             int index,
                             T... newElements)
```
    将新元素插入到到已有数组中的某个位置
    添加新元素会生成一个新的数组，不影响原数组
    如果插入位置为为负数，从原数组从后向前计数，若大于原数组长度，则空白处用null填充
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    buffer - 已有数组
    
    index - 插入位置，此位置为对应此位置元素之前的空档
    
    newElements - 新元素
    
    Returns:
    
    新数组
    
    Since:
    
    4.0.8
  - 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
  - resize
```
public static <T> T[] resize(T[] data,
                             int newSize,
                             Class<?> componentType)
```
    生成一个新的重新设置大小的数组
    调整大小后拷贝原数组到新数组下。扩大则占位前N个位置，缩小则截断
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    data - 原数组
    
    newSize - 新的数组大小
    
    componentType - 数组元素类型
    
    Returns:
    
    调整后的新数组
  - resize
```
public static Object resize(Object array,
                            int newSize)
```
    生成一个新的重新设置大小的数组
    调整大小后拷贝原数组到新数组下。扩大则占位前N个位置，其它位置补充0，缩小则截断
    
    Parameters:
    
    array - 原数组
    
    newSize - 新的数组大小
    
    Returns:
    
    调整后的新数组
    
    Since:
    
    4.6.7
  - resize
```
public static <T> T[] resize(T[] buffer,
                             int newSize)
```
    生成一个新的重新设置大小的数组
    新数组的类型为原数组的类型，调整大小后拷贝原数组到新数组下。扩大则占位前N个位置，缩小则截断
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    buffer - 原数组
    
    newSize - 新的数组大小
    
    Returns:
    
    调整后的新数组
  - addAll
```
@SafeVarargs
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
  - 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:
    
    克隆后的数组对象
  - edit
```
public static <T> T[] edit(T[] array,
                           Editor<T> editor)
```
    编辑数组
    编辑过程通过传入的Editor实现来返回需要的元素内容，这个Editor实现可以实现以下功能：
```
 1、过滤出需要的对象，如果返回 null表示这个元素对象抛弃
 2、修改元素对象，返回集合中为修改后的对象
 
```
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组
    
    editor - 编辑器接口，null返回原集合
    
    Returns:
    
    编辑后的数组
    
    Since:
    
    5.3.3
  - filter
```
public static <T> T[] filter(T[] array,
                             Filter<T> filter)
```
    过滤
    过滤过程通过传入的Filter实现来过滤返回需要的元素内容，这个Filter实现可以实现以下功能：
```
 1、过滤出需要的对象，Filter.accept(Object)方法返回true的对象将被加入结果集合中
 
```
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组
    
    filter - 过滤器接口，用于定义过滤规则，null返回原集合
    
    Returns:
    
    过滤后的数组
    
    Since:
    
    3.2.1
  - removeNull
```
public static <T> T[] removeNull(T[] array)
```
    去除null 元素
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    处理后的数组
    
    Since:
    
    3.2.2
  - removeEmpty
```
public static <T extends CharSequence> T[] removeEmpty(T[] array)
```
    去除null或者"" 元素
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    处理后的数组
    
    Since:
    
    3.2.2
  - removeBlank
```
public static <T extends CharSequence> T[] removeBlank(T[] array)
```
    去除null或者""或者空白字符串元素
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    处理后的数组
    
    Since:
    
    3.2.2
  - nullToEmpty
```
public static String[] nullToEmpty(String[] array)
```
    数组元素中的null转换为""
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    新数组
    
    Since:
    
    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}
    如果两个数组长度不同，则只对应最短部分
    
    Type Parameters:
    
    K - Key类型
    
    V - Value类型
    
    Parameters:
    
    keys - 键列表
    
    values - 值列表
    
    isOrder - 是否有序
    
    Returns:
    
    Map
    
    Since:
    
    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}
    如果两个数组长度不同，则只对应最短部分
    
    Type Parameters:
    
    K - Key类型
    
    V - Value类型
    
    Parameters:
    
    keys - 键列表
    
    values - 值列表
    
    Returns:
    
    Map
  - indexOf
```
public static <T> int indexOf(T[] array,
                              Object value,
                              int beginIndexInclude)
```
    返回数组中指定元素所在位置，未找到返回PrimitiveArrayUtil.INDEX_NOT_FOUND
    
    Type Parameters:
    
    T - 数组类型
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    beginIndexInclude - 检索开始的位置
    
    Returns:
    
    数组中指定元素所在位置，未找到返回PrimitiveArrayUtil.INDEX_NOT_FOUND
    
    Since:
    
    3.0.7
  - indexOf
```
public static <T> int indexOf(T[] array,
                              Object value)
```
    返回数组中指定元素所在位置，未找到返回PrimitiveArrayUtil.INDEX_NOT_FOUND
    
    Type Parameters:
    
    T - 数组类型
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    数组中指定元素所在位置，未找到返回PrimitiveArrayUtil.INDEX_NOT_FOUND
    
    Since:
    
    3.0.7
  - indexOfIgnoreCase
```
public static int indexOfIgnoreCase(CharSequence[] array,
                                    CharSequence value)
```
    返回数组中指定元素所在位置，忽略大小写，未找到返回PrimitiveArrayUtil.INDEX_NOT_FOUND
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    数组中指定元素所在位置，未找到返回PrimitiveArrayUtil.INDEX_NOT_FOUND
    
    Since:
    
    3.1.2
  - lastIndexOf
```
public static <T> int lastIndexOf(T[] array,
                                  Object value)
```
    返回数组中指定元素所在最后的位置，未找到返回PrimitiveArrayUtil.INDEX_NOT_FOUND
    
    Type Parameters:
    
    T - 数组类型
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    数组中指定元素所在位置，未找到返回PrimitiveArrayUtil.INDEX_NOT_FOUND
    
    Since:
    
    3.0.7
  - lastIndexOf
```
public static <T> int lastIndexOf(T[] array,
                                  Object value,
                                  int endInclude)
```
    返回数组中指定元素所在最后的位置，未找到返回PrimitiveArrayUtil.INDEX_NOT_FOUND
    
    Type Parameters:
    
    T - 数组类型
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    endInclude - 查找方式为从后向前查找，查找的数组结束位置，一般为array.length-1
    
    Returns:
    
    数组中指定元素所在位置，未找到返回PrimitiveArrayUtil.INDEX_NOT_FOUND
    
    Since:
    
    5.7.3
  - contains
```
public static <T> boolean contains(T[] array,
                                   T value)
```
    数组中是否包含元素
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    是否包含
  - containsAny
```
public static <T> boolean containsAny(T[] array,
                                      T... values)
```
    数组中是否包含指定元素中的任意一个
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组
    
    values - 被检查的多个元素
    
    Returns:
    
    是否包含指定元素中的任意一个
    
    Since:
    
    4.1.20
  - containsAll
```
public static <T> boolean containsAll(T[] array,
                                      T... values)
```
    数组中是否包含指定元素中的全部
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组
    
    values - 被检查的多个元素
    
    Returns:
    
    是否包含指定元素中的全部
    
    Since:
    
    5.4.7
  - containsIgnoreCase
```
public static boolean containsIgnoreCase(CharSequence[] array,
                                         CharSequence value)
```
    数组中是否包含元素，忽略大小写
    
    Parameters:
    
    array - 数组
    
    value - 被检查的元素
    
    Returns:
    
    是否包含
    
    Since:
    
    3.1.2
  - wrap
```
public static Object[] wrap(Object obj)
```
    包装数组对象
    
    Parameters:
    
    obj - 对象，可以是对象数组或者基本类型数组
    
    Returns:
    
    包装类型数组或对象数组
    
    Throws:
    
    UtilException - 对象为非数组
  - isArray
```
public static boolean isArray(Object obj)
```
    对象是否为数组对象
    
    Parameters:
    
    obj - 对象
    
    Returns:
    
    是否为数组对象，如果为null 返回false
  - get
```
public static <T> T get(Object array,
                        int index)
```
    获取数组对象中指定index的值，支持负数，例如-1表示倒数第一个值
    如果数组下标越界，返回null
    
    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 - 数组，如果提供为null则返回null
    
    indexes - 下标列表
    
    Returns:
    
    结果
  - sub
```
public static <T> T[] sub(T[] array,
                          int start,
                          int end)
```
    获取子数组
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组
    
    start - 开始位置（包括）
    
    end - 结束位置（不包括）
    
    Returns:
    
    新的数组
    
    Since:
    
    4.2.2
    
    See Also:
    
    Arrays.copyOfRange(Object[], int, int)
  - 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
  - toString
```
public static String toString(Object obj)
```
    数组或集合转String
    
    Parameters:
    
    obj - 集合或数组对象
    
    Returns:
    
    数组字符串，与集合转字符串格式相同
  - 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
 
```
    Parameters:
    
    array - 数组对象
    
    Returns:
    
    数组长度
    
    Throws:
    
    IllegalArgumentException - 如果参数不为数组，抛出此异常
    
    Since:
    
    3.0.8
    
    See Also:
    
    Array.getLength(Object)
  - join
```
public static <T> String join(T[] array,
                              CharSequence conjunction)
```
    以 conjunction 为分隔符将数组转换为字符串
    
    Type Parameters:
    
    T - 被处理的集合
    
    Parameters:
    
    array - 数组
    
    conjunction - 分隔符
    
    Returns:
    
    连接后的字符串
  - join
```
public static <T> String join(T[] array,
                              CharSequence delimiter,
                              String prefix,
                              String suffix)
```
    以 conjunction 为分隔符将数组转换为字符串
    
    Type Parameters:
    
    T - 被处理的集合
    
    Parameters:
    
    array - 数组
    
    delimiter - 分隔符
    
    prefix - 每个元素添加的前缀，null表示不添加
    
    suffix - 每个元素添加的后缀，null表示不添加
    
    Returns:
    
    连接后的字符串
    
    Since:
    
    4.0.10
  - join
```
public static <T> String join(T[] array,
                              CharSequence conjunction,
                              Editor<T> editor)
```
    以 conjunction 为分隔符将数组转换为字符串
    
    Type Parameters:
    
    T - 被处理的集合
    
    Parameters:
    
    array - 数组
    
    conjunction - 分隔符
    
    editor - 每个元素的编辑器，null表示不编辑
    
    Returns:
    
    连接后的字符串
    
    Since:
    
    5.3.3
  - 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(Iterator<T> iterator,
                              Class<T> componentType)
```
    将集合转为数组
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    iterator - Iterator
    
    componentType - 集合元素类型
    
    Returns:
    
    数组
    
    Since:
    
    3.0.9
  - toArray
```
public static <T> T[] toArray(Iterable<T> iterable,
                              Class<T> componentType)
```
    将集合转为数组
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    iterable - Iterable
    
    componentType - 集合元素类型
    
    Returns:
    
    数组
    
    Since:
    
    3.0.9
  - toArray
```
public static <T> T[] toArray(Collection<T> collection,
                              Class<T> componentType)
```
    将集合转为数组
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    collection - 集合
    
    componentType - 集合元素类型
    
    Returns:
    
    数组
    
    Since:
    
    3.0.9
  - remove
```
public static <T> T[] remove(T[] array,
                             int index)
                      throws IllegalArgumentException
```
    移除数组中对应位置的元素
    copy from commons-lang
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组对象，可以是对象数组，也可以原始类型数组
    
    index - 位置，如果位置小于0或者大于长度，返回原数组
    
    Returns:
    
    去掉指定元素后的新数组或原数组
    
    Throws:
    
    IllegalArgumentException - 参数对象不为数组对象
    
    Since:
    
    3.0.8
  - removeEle
```
public static <T> T[] removeEle(T[] array,
                                T element)
                         throws IllegalArgumentException
```
    移除数组中指定的元素
    只会移除匹配到的第一个元素 copy from commons-lang
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组对象，可以是对象数组，也可以原始类型数组
    
    element - 要移除的元素
    
    Returns:
    
    去掉指定元素后的新数组或原数组
    
    Throws:
    
    IllegalArgumentException - 参数对象不为数组对象
    
    Since:
    
    3.0.8
  - reverse
```
public static <T> T[] reverse(T[] array,
                              int startIndexInclusive,
                              int endIndexExclusive)
```
    反转数组，会变更原数组
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组，会变更
    
    startIndexInclusive - 开始位置（包含）
    
    endIndexExclusive - 结束位置（不包含）
    
    Returns:
    
    变更后的原数组
    
    Since:
    
    3.0.9
  - reverse
```
public static <T> T[] reverse(T[] array)
```
    反转数组，会变更原数组
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组，会变更
    
    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 <T extends Comparable<? super T>> T min(T[] numberArray,
                                                      Comparator<T> comparator)
```
    取最小值
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    numberArray - 数字数组
    
    comparator - 比较器，null按照默认比较
    
    Returns:
    
    最小值
    
    Since:
    
    5.3.4
  - 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 <T extends Comparable<? super T>> T max(T[] numberArray,
                                                      Comparator<T> comparator)
```
    取最大值
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    numberArray - 数字数组
    
    comparator - 比较器，null表示默认比较器
    
    Returns:
    
    最大值
    
    Since:
    
    5.3.4
  - shuffle
```
public static <T> T[] shuffle(T[] array)
```
    打乱数组顺序，会变更原数组
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    array - 数组，会变更
    
    Returns:
    
    打乱后的数组
    
    Since:
    
    5.5.2
  - shuffle
```
public static <T> T[] shuffle(T[] array,
                              Random random)
```
    打乱数组顺序，会变更原数组
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    array - 数组，会变更
    
    random - 随机数生成器
    
    Returns:
    
    打乱后的数组
    
    Since:
    
    5.5.2
  - swap
```
public static <T> T[] swap(T[] array,
                           int index1,
                           int index2)
```
    交换数组中两个位置的值
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    array - 数组
    
    index1 - 位置1
    
    index2 - 位置2
    
    Returns:
    
    交换后的数组，与传入数组为同一对象
    
    Since:
    
    4.0.7
  - swap
```
public static Object swap(Object array,
                          int index1,
                          int index2)
```
    交换数组中两个位置的值
    
    Parameters:
    
    array - 数组对象
    
    index1 - 位置1
    
    index2 - 位置2
    
    Returns:
    
    交换后的数组，与传入数组为同一对象
    
    Since:
    
    4.0.7
  - emptyCount
```
public static int emptyCount(Object... args)
```
    计算null或空元素对象的个数，通过ObjectUtil.isEmpty(Object) 判断元素
    
    Parameters:
    
    args - 被检查的对象,一个或者多个
    
    Returns:
    
    存在null的数量
    
    Since:
    
    4.5.18
  - hasEmpty
```
public static boolean hasEmpty(Object... args)
```
    是否存在null或空对象，通过ObjectUtil.isEmpty(Object) 判断元素
    
    Parameters:
    
    args - 被检查对象
    
    Returns:
    
    是否存在
    
    Since:
    
    4.5.18
  - isAllEmpty
```
public static boolean isAllEmpty(Object... args)
```
    是否存都为null或空对象，通过ObjectUtil.isEmpty(Object) 判断元素
    
    Parameters:
    
    args - 被检查的对象,一个或者多个
    
    Returns:
    
    是否都为空
    
    Since:
    
    4.5.18
  - isAllNotEmpty
```
public static boolean isAllNotEmpty(Object... args)
```
    是否存都不为null或空对象，通过ObjectUtil.isEmpty(Object) 判断元素
    
    Parameters:
    
    args - 被检查的对象,一个或者多个
    
    Returns:
    
    是否都不为空
    
    Since:
    
    4.5.18
  - isAllNotNull
```
public static <T> boolean isAllNotNull(T... array)
```
    多个字段是否全部不为null
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 被检查的数组
    
    Returns:
    
    多个字段是否全部不为null
    
    Since:
    
    5.4.0
  - distinct
```
public static <T> T[] distinct(T[] array)
```
    去重数组中的元素，去重后生成新的数组，原数组不变
    此方法通过LinkedHashSet 去重
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    去重后的数组
  - distinct
```
public static <T,K> T[] distinct(T[] array,
                                 Function<T,K> uniqueGenerator,
                                 boolean override)
```
    去重数组中的元素，去重后生成新的数组，原数组不变
    此方法通过LinkedHashSet 去重
    
    Type Parameters:
    
    T - 数组元素类型
    
    K - 唯一键类型
    
    Parameters:
    
    array - 数组
    
    uniqueGenerator - 唯一键生成器
    
    override - 是否覆盖模式，如果为true，加入的新值会覆盖相同key的旧值，否则会忽略新加值
    
    Returns:
    
    去重后的数组
    
    Since:
    
    5.8.0
  - map
```
public static <T,R> R[] map(T[] array,
                            Class<R> targetComponentType,
                            Function<? super T,? extends R> func)
```
    按照指定规则，将一种类型的数组转换为另一种类型
    
    Type Parameters:
    
    T - 原数组类型
    
    R - 目标数组类型
    
    Parameters:
    
    array - 被转换的数组
    
    targetComponentType - 目标的元素类型
    
    func - 转换规则函数
    
    Returns:
    
    转换后的数组
    
    Since:
    
    5.4.2
  - map
```
public static <T,R> R[] map(Object array,
                            Class<R> targetComponentType,
                            Function<? super T,? extends R> func)
```
    按照指定规则，将一种类型的数组转换为另一种类型
    
    Type Parameters:
    
    T - 原数组类型
    
    R - 目标数组类型
    
    Parameters:
    
    array - 被转换的数组
    
    targetComponentType - 目标的元素类型
    
    func - 转换规则函数
    
    Returns:
    
    转换后的数组
    
    Since:
    
    5.5.8
  - map
```
public static <T,R> List<R> map(T[] array,
                                Function<? super T,? extends R> func)
```
    按照指定规则，将一种类型的数组元素提取后转换为List
    
    Type Parameters:
    
    T - 原数组类型
    
    R - 目标数组类型
    
    Parameters:
    
    array - 被转换的数组
    
    func - 转换规则函数
    
    Returns:
    
    转换后的数组
    
    Since:
    
    5.5.7
  - mapToSet
```
public static <T,R> Set<R> mapToSet(T[] array,
                                    Function<? super T,? extends R> func)
```
    按照指定规则，将一种类型的数组元素提取后转换为Set
    
    Type Parameters:
    
    T - 原数组类型
    
    R - 目标数组类型
    
    Parameters:
    
    array - 被转换的数组
    
    func - 转换规则函数
    
    Returns:
    
    转换后的数组
    
    Since:
    
    5.8.0
  - equals
```
public static boolean equals(Object array1,
                             Object array2)
```
    判断两个数组是否相等，判断依据包括数组长度和每个元素都相等。
    
    Parameters:
    
    array1 - 数组1
    
    array2 - 数组2
    
    Returns:
    
    是否相等
    
    Since:
    
    5.4.2
  - isSub
```
public static <T> boolean isSub(T[] array,
                                T[] subArray)
```
    查找子数组的位置
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组
    
    subArray - 子数组
    
    Returns:
    
    子数组的开始位置，即子数字第一个元素在数组中的位置
    
    Since:
    
    5.4.8
  - indexOfSub
```
public static <T> int indexOfSub(T[] array,
                                 T[] subArray)
```
    查找子数组的位置
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组
    
    subArray - 子数组
    
    Returns:
    
    子数组的开始位置，即子数字第一个元素在数组中的位置
    
    Since:
    
    5.4.8
  - indexOfSub
```
public static <T> int indexOfSub(T[] array,
                                 int beginInclude,
                                 T[] subArray)
```
    查找子数组的位置
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组
    
    beginInclude - 查找开始的位置（包含）
    
    subArray - 子数组
    
    Returns:
    
    子数组的开始位置，即子数字第一个元素在数组中的位置
    
    Since:
    
    5.4.8
  - lastIndexOfSub
```
public static <T> int lastIndexOfSub(T[] array,
                                     T[] subArray)
```
    查找最后一个子数组的开始位置
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组
    
    subArray - 子数组
    
    Returns:
    
    最后一个子数组的开始位置，即子数字第一个元素在数组中的位置
    
    Since:
    
    5.4.8
  - lastIndexOfSub
```
public static <T> int lastIndexOfSub(T[] array,
                                     int endInclude,
                                     T[] subArray)
```
    查找最后一个子数组的开始位置
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组
    
    endInclude - 查找结束的位置（包含），-1表示最后一位
    
    subArray - 子数组
    
    Returns:
    
    最后一个子数组的开始位置，即子数字第一个元素在数组中的位置
    
    Since:
    
    5.4.8
  - isSorted
```
public static <T> boolean isSorted(T[] array,
                                   Comparator<? super T> comparator)
```
    检查数组是否有序，即comparator.compare(array[i], array[i + 1]) <= 0，若传入空数组或空比较器，则返回false
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组
    
    comparator - 比较器
    
    Returns:
    
    数组是否有序
    
    Since:
    
    5.5.2
  - isSorted
```
public static <T extends Comparable<? super T>> boolean isSorted(T[] array)
```
    检查数组是否升序，即array[i].compareTo(array[i + 1]) <= 0，若传入空数组，则返回false
    
    Type Parameters:
    
    T - 数组元素类型，该类型需要实现Comparable接口
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    数组是否升序
    
    Since:
    
    5.5.2
  - isSortedASC
```
public static <T extends Comparable<? super T>> boolean isSortedASC(T[] array)
```
    检查数组是否升序，即array[i].compareTo(array[i + 1]) <= 0，若传入空数组，则返回false
    
    Type Parameters:
    
    T - 数组元素类型，该类型需要实现Comparable接口
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    数组是否升序
    
    Since:
    
    5.5.2
  - isSortedDESC
```
public static <T extends Comparable<? super T>> boolean isSortedDESC(T[] array)
```
    检查数组是否降序，即array[i].compareTo(array[i + 1]) >= 0，若传入空数组，则返回false
    
    Type Parameters:
    
    T - 数组元素类型，该类型需要实现Comparable接口
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    数组是否降序
    
    Since:
    
    5.5.2

Class ArrayUtil

Field Summary

Fields inherited from class cn.hutool.core.util.PrimitiveArrayUtil

Constructor Summary

Method Summary

Methods inherited from class cn.hutool.core.util.PrimitiveArrayUtil

Methods inherited from class java.lang.Object

Constructor Detail

ArrayUtil

Method Detail

isEmpty

defaultIfEmpty

isEmpty

isNotEmpty

isNotEmpty

hasNull

isAllNull

firstNonNull

firstMatch

matchIndex

matchIndex

newArray

newArray

getComponentType

getComponentType

getArrayType

cast

append

append

setOrAppend

setOrAppend

replace

insert

insert

resize

resize

resize

addAll

copy

copy

clone

clone

edit

filter

removeNull

removeEmpty

removeBlank

nullToEmpty

zip

zip

indexOf

indexOf

indexOfIgnoreCase

lastIndexOf

lastIndexOf

contains

containsAny

containsAll

containsIgnoreCase

wrap

isArray

get

getAny

sub

sub

sub

toString

length

join

join

join

join

toArray

toArray

toArray

toArray

remove

removeEle

reverse

reverse