ArrayUtil (hutool 6.0.0-M20 API)

java.lang.Object
- org.dromara.hutool.core.array.PrimitiveArrayUtil
- - org.dromara.hutool.core.array.ArrayUtil

public class ArrayUtil
extends PrimitiveArrayUtil

数组工具类

Author:: Looly

Field Summary
- Fields inherited from class org.dromara.hutool.core.array.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 <A,T> A`	`append(A array, T... newElements)` 将新元素添加到已有数组中添加新元素会生成一个新的数组，不影响原数组
`static <T> T[]`	`append(T[] buffer, T... newElements)` 将新元素添加到已有数组中添加新元素会生成一个新的数组，不影响原数组
`static Object[]`	`cast(Class<?> type, Object arrayObj)` 强转数组类型强制转换的前提是数组元素类型可被强制转换强制转换后会生成一个新数组
`static <A> A`	`castOrWrapSingle(Object values, Class<?> elementType)` 转为数组，如果values为数组，返回，否则返回一个只有values一个元素的数组注意：values的元素类型或其本身类型必须和提供的elementType完全一致
`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 <T> T`	`copy(Object src, int srcPos, T dest, int destPos, int length)` 包装 `System.arraycopy(Object, int, Object, int, int)` 数组复制
`static <T> T`	`copy(Object src, T dest)` 包装 `System.arraycopy(Object, int, Object, int, int)` 数组复制，源数组和目标数组都是从位置0开始复制，复制长度为源数组的长度
`static <T> T`	`copy(Object src, T 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, UnaryOperator<T> editor)` 对每个数组元素执行指定操作，返回操作后的元素这个Editor实现可以实现以下功能：过滤出需要的对象，如果返回`null`则抛弃这个元素对象修改元素对象，返回修改后的对象
`static int`	`emptyCount(Object... args)` 计算`null`或空元素对象的个数，通过`ObjUtil.isEmpty(Object)` 判断元素
`static boolean`	`equals(Object array1, Object array2)` 判断两个数组是否相等，判断依据包括数组长度和每个元素都相等。
`static <T> T[]`	`filter(T[] array, Predicate<T> predicate)` 过滤数组元素保留 `Predicate.test(Object)`为`true`的元素
`static <T> T`	`firstMatch(Predicate<T> matcher, T... array)` 返回数组中第一个匹配规则的值
`static <T> T`	`firstNonNull(T... array)` 返回数组中第一个非空元素
`static <E> E`	`get(E[] array, Predicate<E> predicate)` 获取满足条件的第一个元素
`static <E> E`	`get(Object array, int index)` 获取数组对象中指定index的值，支持负数，例如-1表示倒数第一个值如果数组下标越界，返回null
`static <T> T[]`	`getAny(Object array, int... indexes)` 获取数组中所有指定位置的元素值，组成新数组
`static Class<?>`	`getArrayType(Class<?> componentType)` 根据数组元素类型，获取数组的类型方法是通过创建一个空数组从而获取其类型本方法是 `getComponentType(Class)`的逆方法
`static Class<?>`	`getComponentType(Class<?> arrayClass)` 获取数组对象的元素类型，方法调用参数与返回结果举例： Object[].class =》 Object.class String[].class =》 String.class int[].class =》 int.class Integer[].class =》 Integer.class null =》 null String.class =》 null
`static Class<?>`	`getComponentType(Object array)` 获取数组对象的元素类型，方法调用参数与返回结果举例： Object[] =》 Object.class String[] =》 String.class int[] =》 int.class Integer[] =》 Integer.class null =》 null String =》 null
`static boolean`	`hasBlank(CharSequence... strs)` 指定字符串数组中，是否包含空字符串。
`static <T> boolean`	`hasEmpty(T[] args)` 是否存在`null`或空对象，通过`ObjUtil.isEmpty(Object)` 判断元素如果提供的数组本身为空，则返回`false`
`static <T> boolean`	`hasEmptyVarargs(T... args)` 是否存在`null`或空对象，通过`ObjUtil.isEmpty(Object)` 判断元素如果提供的数组本身为空，则返回`false` 限制条件：args的每个item不能是数组、不能是集合
`static <T> boolean`	`hasNonNull(T... array)` 是否包含非`null`元素如果数组是`null`或者空，返回`false`，否则当数组中有非`null`元素时返回`true`
`static <T> boolean`	`hasNull(T... array)` 是否包含`null`元素如果数组为null，则返回`true`，如果数组为空，则返回`false`
`static <T> Boolean`	`hasSameElement(T[] array)` 判断数组中是否有相同元素若传入空数组，则返回`false`
`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 <A,E> A`	`insert(A array, int index, E... newElements)` 将新元素插入到已有数组中的某个位置添加新元素会生成一个新的数组，不影响原数组如果插入位置为负数，从原数组从后向前计数，若大于原数组长度，则空白处用默认值填充
`static <T> T[]`	`insert(T[] buffer, int index, T... newElements)` 将新元素插入到已有数组中的某个位置添加新元素会生成一个新的数组，不影响原数组如果插入位置为负数，从原数组从后向前计数，若大于原数组长度，则空白处用null填充
`static boolean`	`isAllBlank(CharSequence... strs)` 指定字符串数组中的元素，是否全部为空字符串。
`static <T> boolean`	`isAllEmpty(T[] args)` 是否所有元素都为`null`或空对象，通过`ObjUtil.isEmpty(Object)` 判断元素如果提供的数组本身为空，则返回`true`
`static <T> boolean`	`isAllEmptyVarargs(T... args)` 是否所有元素都为`null`或空对象，通过`ObjUtil.isEmpty(Object)` 判断元素如果提供的数组本身为空，则返回`true` 限制条件：args的每个item不能是数组、不能是集合
`static boolean`	`isAllNotBlank(CharSequence... args)` 是否存都不为`null`或空对象或空白符的对象，通过`hasBlank(CharSequence...)`
`static boolean`	`isAllNotEmpty(Object... args)` 是否所有元素都不为`null`或空对象，通过`ObjUtil.isEmpty(Object)` 判断元素如果提供的数组本身为空，则返回`true`
`static <T> boolean`	`isAllNotNull(T... array)` 是否所有元素都不为 `null` 如果提供的数组为null，则返回`false`，如果提供的数组为空，则返回`true`
`static <T> boolean`	`isAllNull(T... array)` 所有字段是否全为null 如果数组为`null`或者空，则返回 `true`
`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)` 检查数组是否有序，升序或者降序若传入空数组，则返回`false`；元素全部相等，返回 `true`
`static <T> boolean`	`isSorted(T[] array, Comparator<? super T> comparator)` 检查数组是否有序，升序或者降序，使用指定比较器比较若传入空数组或空比较器，则返回`false`；元素全部相等，返回 `true`
`static <T extends Comparable<? super T>> boolean`	`isSortedASC(T[] array)` 检查数组是否升序，即 `array[i].compareTo(array[i + 1]) <= 0` 若传入空数组，则返回`false`
`static <T> boolean`	`isSortedASC(T[] array, Comparator<? super T> comparator)` 检查数组是否升序，使用指定的比较器比较，即 `comparator.compare(array[i], 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`	`isSortedDESC(T[] array, Comparator<? super T> comparator)` 检查数组是否降序，使用指定的比较器比较，即 `comparator.compare(array[i], 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 delimiter, String prefix, String suffix)` 以 conjunction 为分隔符将数组转换为字符串
`static <T> String`	`join(T[] array, CharSequence conjunction, UnaryOperator<T> editor)` 先处理数组元素，再以 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 <R> R[]`	`map(Object array, Class<R> targetComponentType, Function<?,? extends R> func)` 按照指定规则，将一种类型的数组转换为另一种类型
`static <T,R> R[]`	`mapToArray(T[] array, Function<? super T,? extends R> func, IntFunction<R[]> generator)` 按照指定规则，将一种类型的数组元素转换为另一种类型，并保存为数组
`static <T,R> List<R>`	`mapToList(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 <E> int`	`matchIndex(int beginIndexInclude, Predicate<E> matcher, E... array)` 返回数组中第一个匹配规则的值的位置
`static <T> int`	`matchIndex(Predicate<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)` 新建一个`Object`类型空数组
`static String[]`	`nullToEmpty(String[] array)` 数组元素中的null转换为""
`static <T> T[]`	`ofArray(Iterable<T> iterable, Class<T> componentType)` 将集合转为数组，如果集合为`null`，则返回空的数组（元素个数为0）
`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 <A> A`	`replace(A array, int index, A values)` 从数组中的指定位置开始，按顺序使用新元素替换旧元素如果指定位置为负数，那么生成一个新数组，其中新元素按顺序放在数组头部如果指定位置大于等于旧数组长度，那么生成一个新数组，其中新元素按顺序放在数组尾部如果指定位置加上新元素数量大于旧数组长度，那么生成一个新数组，指定位置之前是旧数组元素，指定位置及之后为新元素否则，从已有数组中的指定位置开始，按顺序使用新元素替换旧元素，返回旧数组
`static <T> T[]`	`replace(T[] array, 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 <A> A`	`setOrAppend(A array, int index, Object value)` 将元素值设置为数组的某个位置，当给定的index大于等于数组长度，则追加
`static <T> T[]`	`setOrAppend(T[] array, int index, T value)` 将元素值设置为数组的某个位置，当给定的index大于等于数组长度，则追加
`static <A,E> A`	`setOrPadding(A array, int index, E value, E paddingValue)` 将元素值设置为数组的某个位置，当index小于数组的长度时，替换指定位置的值，否则追加paddingValue直到到达index后，设置值
`static <A> A`	`setOrPadding(A array, int index, Object value)` 将元素值设置为数组的某个位置，当index小于数组的长度时，替换指定位置的值，否则追加`null`或`0`直到到达index后，设置值
`static <T> T[]`	`shuffle(T[] array)` 打乱数组顺序，会变更原数组使用Fisher–Yates洗牌算法，以线性时间复杂度打乱数组顺序
`static <T> T[]`	`shuffle(T[] array, Random random)` 打乱数组顺序，会变更原数组使用Fisher–Yates洗牌算法，以线性时间复杂度打乱数组顺序
`static <T> boolean`	`startWith(T[] array, T[] prefix)` array数组是否以prefix开头，每个元素的匹配使用`ObjUtil.equals(Object, Object)`匹配。
`static <A> A`	`sub(A array, int beginInclude, int endExclude)` 获取子数组
`static <A> A`	`sub(A array, int beginInclude, int endExclude, 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 String`	`toString(Object obj)` 数组或集合转String
`static Object[]`	`wrap(Object obj)` 包装数组对象
`static <A> A`	`wrapSingle(Object value, Class<?> elementType)` 包装单一元素为数组
`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 org.dromara.hutool.core.array.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, isSortedASC, isSortedASC, isSortedASC, isSortedASC, isSortedASC, isSortedASC, isSortedASC, isSortedDESC, isSortedDESC, isSortedDESC, isSortedDESC, isSortedDESC, isSortedDESC, isSortedDESC, isSubEquals, lastIndexOf, lastIndexOf, lastIndexOf, lastIndexOf, lastIndexOf, lastIndexOf, lastIndexOf, lastIndexOf, max, max, max, max, max, max, max, min, min, min, min, min, min, min, regionMatches, 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, startWith, startWith, startWith, startWith, startWith, startWith, startWith, startWith, 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
  - castOrWrapSingle
```
public static <A> A castOrWrapSingle(Object values,
                                     Class<?> elementType)
```
    转为数组，如果values为数组，返回，否则返回一个只有values一个元素的数组
    注意：values的元素类型或其本身类型必须和提供的elementType完全一致
    
    Type Parameters:
    
    A - 数组类型
    
    Parameters:
    
    values - 元素值
    
    elementType - 数组元素类型，null表示使用values的类型
    
    Returns:
    
    数组
  - wrapSingle
```
public static <A> A wrapSingle(Object value,
                               Class<?> elementType)
```
    包装单一元素为数组
    
    Type Parameters:
    
    A - 数组类型
    
    Parameters:
    
    value - 元素值
    
    elementType - 数组元素类型，null表示使用value的类型
    
    Returns:
    
    数组
  - ofArray
```
public static <T> T[] ofArray(Iterable<T> iterable,
                              Class<T> componentType)
```
    将集合转为数组，如果集合为null，则返回空的数组（元素个数为0）
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    iterable - Iterable
    
    componentType - 集合元素类型
    
    Returns:
    
    数组
    
    Since:
    
    3.0.9
  - hasBlank
```
public static boolean hasBlank(CharSequence... strs)
```
    指定字符串数组中，是否包含空字符串。
    
    如果指定的字符串数组的长度为 0，或者其中的任意一个元素是空字符串，则返回 true。
    
    例：
    - hasBlank() // true
    - hasBlank("", null, " ") // true
    - hasBlank("123", " ") // true
    - hasBlank("123", "abc") // false
    注意：该方法与 isAllBlank(CharSequence...) 的区别在于：
    - hasBlank(CharSequence...) 等价于 isBlank(...) || isBlank(...) || ...
    - isAllBlank(CharSequence...) 等价于 isBlank(...) && isBlank(...) && ...
    Parameters:
    
    strs - 字符串列表
    
    Returns:
    
    是否包含空字符串
  - isAllNotBlank
```
public static boolean isAllNotBlank(CharSequence... args)
```
    是否存都不为null或空对象或空白符的对象，通过hasBlank(CharSequence...) 判断元素
    
    Parameters:
    
    args - 被检查的对象,一个或者多个
    
    Returns:
    
    是否都不为空
  - isAllBlank
```
public static boolean isAllBlank(CharSequence... strs)
```
    指定字符串数组中的元素，是否全部为空字符串。
    
    如果指定的字符串数组的长度为 0，或者所有元素都是空字符串，则返回 true。
    
    例：
    - isAllBlank() // true
    - isAllBlank("", null, " ") // true
    - isAllBlank("123", " ") // false
    - isAllBlank("123", "abc") // false
    注意：该方法与 hasBlank(CharSequence...) 的区别在于：
    - hasBlank(CharSequence...) 等价于 isBlank(...) || isBlank(...) || ...
    - isAllBlank(CharSequence...) 等价于 isBlank(...) && isBlank(...) && ...
    Parameters:
    
    strs - 字符串列表
    
    Returns:
    
    所有字符串是否为空白
  - 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:
    
    是否为非空
  - emptyCount
```
public static int emptyCount(Object... args)
```
    计算null或空元素对象的个数，通过ObjUtil.isEmpty(Object) 判断元素
    
    Parameters:
    
    args - 被检查的对象,一个或者多个
    
    Returns:
    
    null或空元素对象的个数
    
    Since:
    
    4.5.18
  - hasEmpty
```
public static <T> boolean hasEmpty(T[] args)
```
    是否存在null或空对象，通过ObjUtil.isEmpty(Object) 判断元素
    
    如果提供的数组本身为空，则返回false
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    args - 被检查对象
    
    Returns:
    
    是否存在 null 或空对象
    
    Since:
    
    4.5.18
  - hasEmptyVarargs
```
@SafeVarargs
public static <T> boolean hasEmptyVarargs(T... args)
```
    是否存在null或空对象，通过ObjUtil.isEmpty(Object) 判断元素
    
    如果提供的数组本身为空，则返回false
    
    限制条件：args的每个item不能是数组、不能是集合
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    args - 被检查对象
    
    Returns:
    
    是否存在 null 或空对象
    
    Throws:
    
    IllegalArgumentException - 如果提供的args的item存在数组或集合，抛出异常
    
    Since:
    
    6.0.0
  - isAllEmpty
```
public static <T> boolean isAllEmpty(T[] args)
```
    是否所有元素都为null或空对象，通过ObjUtil.isEmpty(Object) 判断元素
    如果提供的数组本身为空，则返回true
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    args - 被检查的对象,一个或者多个
    
    Returns:
    
    是否都为空
    
    Since:
    
    4.5.18
  - isAllEmptyVarargs
```
@SafeVarargs
public static <T> boolean isAllEmptyVarargs(T... args)
```
    是否所有元素都为null或空对象，通过ObjUtil.isEmpty(Object) 判断元素
    如果提供的数组本身为空，则返回true
    
    限制条件：args的每个item不能是数组、不能是集合
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    args - 被检查的对象,一个或者多个
    
    Returns:
    
    是否都为空
    
    Throws:
    
    IllegalArgumentException - 如果提供的args的item存在数组或集合，抛出异常
    
    Since:
    
    6.0.0
  - isAllNotEmpty
```
public static boolean isAllNotEmpty(Object... args)
```
    是否所有元素都不为null或空对象，通过ObjUtil.isEmpty(Object) 判断元素
    如果提供的数组本身为空，则返回true
    
    Parameters:
    
    args - 被检查的对象,一个或者多个
    
    Returns:
    
    是否都不为空
    
    Since:
    
    4.5.18
  - hasNull
```
public static <T> boolean hasNull(T... array)
```
    是否包含null元素
    如果数组为null，则返回true，如果数组为空，则返回false
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 被检查的数组
    
    Returns:
    
    是否包含 null 元素
    
    Since:
    
    3.0.7
  - isAllNull
```
public static <T> boolean isAllNull(T... array)
```
    所有字段是否全为null
    如果数组为null或者空，则返回 true
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 被检查的数组
    
    Returns:
    
    所有字段是否全为null
    
    Since:
    
    5.4.0
  - isAllNotNull
```
public static <T> boolean isAllNotNull(T... array)
```
    是否所有元素都不为 null
    如果提供的数组为null，则返回false，如果提供的数组为空，则返回true
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 被检查的数组
    
    Returns:
    
    是否所有元素都不为 null
    
    Since:
    
    5.4.0
  - hasNonNull
```
public static <T> boolean hasNonNull(T... array)
```
    是否包含非null元素
    
    如果数组是null或者空，返回false，否则当数组中有非null元素时返回true
    
    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(Predicate<T> matcher,
                               T... array)
```
    返回数组中第一个匹配规则的值
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    matcher - 匹配接口，实现此接口自定义匹配规则
    
    array - 数组
    
    Returns:
    
    第一个匹配元素，如果不存在匹配元素或数组为空，返回 null
    
    Since:
    
    3.0.7
  - matchIndex
```
public static <T> int matchIndex(Predicate<T> matcher,
                                 T... array)
```
    返回数组中第一个匹配规则的值的位置
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    matcher - 匹配接口，实现此接口自定义匹配规则
    
    array - 数组
    
    Returns:
    
    第一个匹配元素的位置，PrimitiveArrayUtil.INDEX_NOT_FOUND表示未匹配到
    
    Since:
    
    5.6.6
  - matchIndex
```
public static <E> int matchIndex(int beginIndexInclude,
                                 Predicate<E> matcher,
                                 E... array)
```
    返回数组中第一个匹配规则的值的位置
    
    Type Parameters:
    
    E - 数组元素类型
    
    Parameters:
    
    matcher - 匹配接口，实现此接口自定义匹配规则
    
    beginIndexInclude - 检索开始的位置，不能为负数
    
    array - 数组
    
    Returns:
    
    第一个匹配元素的位置，PrimitiveArrayUtil.INDEX_NOT_FOUND表示未匹配到
    
    Since:
    
    5.7.3
  - newArray
```
public static <T> T[] newArray(Class<?> componentType,
                               int newSize)
```
    新建一个空数组
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    componentType - 元素类型，例如：Integer.class，但是不能使用原始类型，例如：int.class
    
    newSize - 大小
    
    Returns:
    
    空数组
  - newArray
```
public static Object[] newArray(int newSize)
```
    新建一个Object类型空数组
    
    Parameters:
    
    newSize - 大小
    
    Returns:
    
    Object类型的空数组
    
    Since:
    
    3.3.0
  - getComponentType
```
public static Class<?> getComponentType(Object array)
```
    获取数组对象的元素类型，方法调用参数与返回结果举例：
    - Object[] =》 Object.class
    - String[] =》 String.class
    - int[] =》 int.class
    - Integer[] =》 Integer.class
    - null =》 null
    - String =》 null
    Parameters:
    
    array - 数组对象
    
    Returns:
    
    元素类型
    
    Since:
    
    3.2.2
  - getComponentType
```
public static Class<?> getComponentType(Class<?> arrayClass)
```
    获取数组对象的元素类型，方法调用参数与返回结果举例：
    - Object[].class =》 Object.class
    - String[].class =》 String.class
    - int[].class =》 int.class
    - Integer[].class =》 Integer.class
    - null =》 null
    - String.class =》 null
    Parameters:
    
    arrayClass - 数组对象的class
    
    Returns:
    
    元素类型
    
    Since:
    
    3.2.2
  - getArrayType
```
public static Class<?> getArrayType(Class<?> componentType)
```
    根据数组元素类型，获取数组的类型
    方法是通过创建一个空数组从而获取其类型
    本方法是 getComponentType(Class)的逆方法
    
    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 <A,T> A append(A array,
                                           T... newElements)
```
    将新元素添加到已有数组中
    添加新元素会生成一个新的数组，不影响原数组
    
    Type Parameters:
    
    A - 数组类型
    
    T - 数组元素类型
    
    Parameters:
    
    array - 已有数组
    
    newElements - 新元素
    
    Returns:
    
    新数组
  - setOrAppend
```
public static <T> T[] setOrAppend(T[] array,
                                  int index,
                                  T value)
```
    将元素值设置为数组的某个位置，当给定的index大于等于数组长度，则追加
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 已有数组
    
    index - 位置，大于等于长度则追加，否则替换
    
    value - 新值
    
    Returns:
    
    新数组或原有数组
    
    Since:
    
    4.1.2
  - setOrAppend
```
public static <A> A setOrAppend(A array,
                                int index,
                                Object value)
```
    将元素值设置为数组的某个位置，当给定的index大于等于数组长度，则追加
    
    Type Parameters:
    
    A - 数组类型
    
    Parameters:
    
    array - 已有数组
    
    index - 位置，大于等于长度则追加，否则替换
    
    value - 新值
    
    Returns:
    
    新数组或原有数组
    
    Since:
    
    4.1.2
  - setOrPadding
```
public static <A> A setOrPadding(A array,
                                 int index,
                                 Object value)
```
    将元素值设置为数组的某个位置，当index小于数组的长度时，替换指定位置的值，否则追加null或0直到到达index后，设置值
    
    Type Parameters:
    
    A - 数组类型
    
    Parameters:
    
    array - 已有数组
    
    index - 位置，大于等于长度则追加，否则替换
    
    value - 新值
    
    Returns:
    
    新数组或原有数组
    
    Since:
    
    6.0.0
  - setOrPadding
```
public static <A,E> A setOrPadding(A array,
                                   int index,
                                   E value,
                                   E paddingValue)
```
    将元素值设置为数组的某个位置，当index小于数组的长度时，替换指定位置的值，否则追加paddingValue直到到达index后，设置值
    
    Type Parameters:
    
    A - 数组类型
    
    E - 元素类型
    
    Parameters:
    
    array - 已有数组
    
    index - 位置，大于等于长度则追加，否则替换
    
    value - 新值
    
    paddingValue - 填充值
    
    Returns:
    
    新数组或原有数组
    
    Since:
    
    6.0.0
  - addAll
```
@SafeVarargs
public static <T> T[] addAll(T[]... arrays)
```
    合并所有数组，返回合并后的新数组
    忽略null的数组
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    arrays - 数组集合
    
    Returns:
    
    合并后的数组
  - replace
```
public static <T> T[] replace(T[] array,
                              int index,
                              T... values)
```
    从数组中的指定位置开始，按顺序使用新元素替换旧元素
    - 如果指定位置为负数，那么生成一个新数组，其中新元素按顺序放在数组头部
    - 如果指定位置大于等于旧数组长度，那么生成一个新数组，其中新元素按顺序放在数组尾部
    - 如果指定位置加上新元素数量大于旧数组长度，那么生成一个新数组，指定位置之前是旧数组元素，指定位置及之后为新元素
    - 否则，从已有数组中的指定位置开始，按顺序使用新元素替换旧元素，返回旧数组
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 已有数组
    
    index - 位置
    
    values - 新值
    
    Returns:
    
    新数组或原有数组
    
    Since:
    
    5.7.23
  - replace
```
public static <A> A replace(A array,
                            int index,
                            A values)
```
    从数组中的指定位置开始，按顺序使用新元素替换旧元素
    - 如果指定位置为负数，那么生成一个新数组，其中新元素按顺序放在数组头部
    - 如果指定位置大于等于旧数组长度，那么生成一个新数组，其中新元素按顺序放在数组尾部
    - 如果指定位置加上新元素数量大于旧数组长度，那么生成一个新数组，指定位置之前是旧数组元素，指定位置及之后为新元素
    - 否则，从已有数组中的指定位置开始，按顺序使用新元素替换旧元素，返回旧数组
    Type Parameters:
    
    A - 数组类型
    
    Parameters:
    
    array - 已有数组
    
    index - 位置
    
    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
```
@SafeVarargs
public static <A,E> A insert(A array,
                                           int index,
                                           E... newElements)
```
    将新元素插入到已有数组中的某个位置
    添加新元素会生成一个新的数组，不影响原数组
    如果插入位置为负数，从原数组从后向前计数，若大于原数组长度，则空白处用默认值填充
    
    Type Parameters:
    
    A - 数组类型
    
    E - 数组元素类型
    
    Parameters:
    
    array - 已有数组，可以为原始类型数组
    
    index - 插入位置，此位置为对应此位置元素之前的空档
    
    newElements - 新元素
    
    Returns:
    
    新数组
    
    Since:
    
    4.0.8
  - resize
```
public static <T> T[] resize(T[] data,
                             int newSize,
                             Class<?> componentType)
```
    生成一个新的重新设置大小的数组
    调整大小后，按顺序拷贝原数组到新数组中，新长度更小则截断
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    data - 原数组
    
    newSize - 新的数组大小
    
    componentType - 数组元素类型
    
    Returns:
    
    调整后的新数组
  - resize
```
public static Object resize(Object array,
                            int newSize)
```
    生成一个新的重新设置大小的数组
    调整大小后，按顺序拷贝原数组到新数组中，新长度更小则截断
    
    Parameters:
    
    array - 原数组
    
    newSize - 新的数组大小
    
    Returns:
    
    调整后的新数组
    
    Since:
    
    4.6.7
    
    See Also:
    
    System.arraycopy(Object, int, Object, int, int)
  - resize
```
public static <T> T[] resize(T[] buffer,
                             int newSize)
```
    生成一个新的重新设置大小的数组
    调整大小后，按顺序拷贝原数组到新数组中，新长度更小则截断原数组
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    buffer - 原数组
    
    newSize - 新的数组大小
    
    Returns:
    
    调整后的新数组
  - copy
```
public static <T> T copy(Object src,
                         T dest)
```
    包装 System.arraycopy(Object, int, Object, int, int)
    数组复制，源数组和目标数组都是从位置0开始复制，复制长度为源数组的长度
    
    Type Parameters:
    
    T - 目标数组类型
    
    Parameters:
    
    src - 源数组
    
    dest - 目标数组
    
    Returns:
    
    目标数组
  - copy
```
public static <T> T copy(Object src,
                         T dest,
                         int length)
```
    包装 System.arraycopy(Object, int, Object, int, int)
    数组复制，源数组和目标数组都是从位置0开始复制
    
    Type Parameters:
    
    T - 目标数组类型
    
    Parameters:
    
    src - 源数组
    
    dest - 目标数组
    
    length - 拷贝数组长度
    
    Returns:
    
    目标数组
    
    Since:
    
    3.0.6
  - copy
```
public static <T> T copy(Object src,
                         int srcPos,
                         T dest,
                         int destPos,
                         int length)
```
    包装 System.arraycopy(Object, int, Object, int, int)
    数组复制
    
    Type Parameters:
    
    T - 目标数组类型
    
    Parameters:
    
    src - 源数组
    
    srcPos - 源数组开始位置
    
    dest - 目标数组
    
    destPos - 目标数组开始位置
    
    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,
                           UnaryOperator<T> 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,
                             Predicate<T> predicate)
```
    过滤数组元素
    保留 Predicate.test(Object)为true的元素
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组
    
    predicate - 过滤器接口，用于定义过滤规则，为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 - Map中的元素是否保留键值数组本身的顺序
    
    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:
    
    HutoolException - 对象为非数组
  - isArray
```
public static boolean isArray(Object obj)
```
    对象是否为数组对象
    
    Parameters:
    
    obj - 对象
    
    Returns:
    
    是否为数组对象，如果为null 返回false
  - get
```
public static <E> E get(Object array,
                        int index)
```
    获取数组对象中指定index的值，支持负数，例如-1表示倒数第一个值
    如果数组下标越界，返回null
    
    Type Parameters:
    
    E - 数组元素类型
    
    Parameters:
    
    array - 数组对象
    
    index - 下标，支持负数
    
    Returns:
    
    值
    
    Since:
    
    4.0.6
  - get
```
public static <E> E get(E[] array,
                        Predicate<E> predicate)
```
    获取满足条件的第一个元素
    
    Type Parameters:
    
    E - 元素类型
    
    Parameters:
    
    array - 数组
    
    predicate - 条件
    
    Returns:
    
    满足条件的第一个元素，未找到返回null
  - getAny
```
public static <T> T[] getAny(Object array,
                             int... indexes)
```
    获取数组中所有指定位置的元素值，组成新数组
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组，如果提供为null则返回null
    
    indexes - 下标列表
    
    Returns:
    
    指定位置的元素值数组
  - 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,
                              UnaryOperator<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:
    
    连接后的字符串
  - 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)
```
    打乱数组顺序，会变更原数组
    使用Fisher–Yates洗牌算法，以线性时间复杂度打乱数组顺序
    
    Type Parameters:
    
    T - 元素类型
    
    Parameters:
    
    array - 数组，会变更
    
    Returns:
    
    打乱后的数组
    
    Since:
    
    5.5.2
  - shuffle
```
public static <T> T[] shuffle(T[] array,
                              Random random)
```
    打乱数组顺序，会变更原数组
    使用Fisher–Yates洗牌算法，以线性时间复杂度打乱数组顺序
    
    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
  - 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 <R> R[] map(Object array,
                          Class<R> targetComponentType,
                          Function<?,? extends R> func)
```
    按照指定规则，将一种类型的数组转换为另一种类型
    
    Type Parameters:
    
    R - 目标数组类型
    
    Parameters:
    
    array - 被转换的数组
    
    targetComponentType - 目标的元素类型，只能为包装类型
    
    func - 转换规则函数
    
    Returns:
    
    转换后的数组
    
    Since:
    
    5.5.8
  - mapToArray
```
public static <T,R> R[] mapToArray(T[] array,
                                   Function<? super T,? extends R> func,
                                   IntFunction<R[]> generator)
```
    按照指定规则，将一种类型的数组元素转换为另一种类型，并保存为数组
    
    Type Parameters:
    
    T - 原数组类型
    
    R - 目标数组类型
    
    Parameters:
    
    array - 被转换的数组
    
    func - 转换规则函数
    
    generator - 数组生成器，如返回String[]，则传入String[]::new
    
    Returns:
    
    集合
  - mapToList
```
public static <T,R> List<R> mapToList(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
  - 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 <A> A sub(A array,
                        int beginInclude,
                        int endExclude)
```
    获取子数组
    
    Type Parameters:
    
    A - 数组类型
    
    Parameters:
    
    array - 数组
    
    beginInclude - 开始位置（包括）
    
    endExclude - 结束位置（不包括）
    
    Returns:
    
    新的数组
    
    Since:
    
    4.0.6
  - sub
```
public static <A> A sub(A array,
                        int beginInclude,
                        int endExclude,
                        int step)
```
    获取子数组
    
    Type Parameters:
    
    A - 数组类型
    
    Parameters:
    
    array - 数组
    
    beginInclude - 开始位置（包括）
    
    endExclude - 结束位置（不包括）
    
    step - 步进
    
    Returns:
    
    新的数组
    
    Since:
    
    4.0.6
  - 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)
```
    检查数组是否有序，升序或者降序，使用指定比较器比较
    若传入空数组或空比较器，则返回false；元素全部相等，返回 true
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组
    
    comparator - 比较器，需要自己处理null值比较
    
    Returns:
    
    数组是否有序
    
    Since:
    
    6.0.0
  - isSorted
```
public static <T extends Comparable<? super T>> boolean isSorted(T[] array)
```
    检查数组是否有序，升序或者降序
    若传入空数组，则返回false；元素全部相等，返回 true
    
    Type Parameters:
    
    T - 数组元素类型，该类型需要实现Comparable接口
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    数组是否有序
    
    Throws:
    
    NullPointerException - 如果数组元素含有null值
    
    Since:
    
    6.0.0
  - 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:
    
    数组是否升序
    
    Throws:
    
    NullPointerException - 如果数组元素含有null值
    
    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:
    
    数组是否降序
    
    Throws:
    
    NullPointerException - 如果数组元素含有null值
    
    Since:
    
    5.5.2
  - isSortedASC
```
public static <T> boolean isSortedASC(T[] array,
                                      Comparator<? super T> comparator)
```
    检查数组是否升序，使用指定的比较器比较，即 comparator.compare(array[i], array[i + 1]) <= 0
    若传入空数组或空比较器，则返回false
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组
    
    comparator - 比较器，需要自己处理null值比较
    
    Returns:
    
    数组是否升序
    
    Since:
    
    6.0.0
  - isSortedDESC
```
public static <T> boolean isSortedDESC(T[] array,
                                       Comparator<? super T> comparator)
```
    检查数组是否降序，使用指定的比较器比较，即 comparator.compare(array[i], array[i + 1]) >= 0
    若传入空数组或空比较器，则返回false
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组
    
    comparator - 比较器，需要自己处理null值比较
    
    Returns:
    
    数组是否降序
    
    Since:
    
    6.0.0
  - hasSameElement
```
public static <T> Boolean hasSameElement(T[] array)
```
    判断数组中是否有相同元素
    若传入空数组，则返回false
    
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组
    
    Returns:
    
    数组是否有相同元素
    
    Since:
    
    6.0.0
  - startWith
```
public static <T> boolean startWith(T[] array,
                                    T[] prefix)
```
    array数组是否以prefix开头，每个元素的匹配使用ObjUtil.equals(Object, Object)匹配。
    - array和prefix为同一个数组（即array == prefix），返回true
    - array或prefix为空数组（null或length为0的数组），返回true
    - prefix长度大于array，返回false
    Type Parameters:
    
    T - 数组元素类型
    
    Parameters:
    
    array - 数组
    
    prefix - 前缀
    
    Returns:
    
    是否开头

Class ArrayUtil

Field Summary

Fields inherited from class org.dromara.hutool.core.array.PrimitiveArrayUtil

Constructor Summary

Method Summary

Methods inherited from class org.dromara.hutool.core.array.PrimitiveArrayUtil

Methods inherited from class java.lang.Object

Constructor Detail

ArrayUtil

Method Detail

castOrWrapSingle

wrapSingle

ofArray

hasBlank

isAllNotBlank

isAllBlank

isEmpty

defaultIfEmpty

isEmpty

isNotEmpty

isNotEmpty

emptyCount

hasEmpty

hasEmptyVarargs

isAllEmpty

isAllEmptyVarargs

isAllNotEmpty

hasNull

isAllNull

isAllNotNull

hasNonNull

firstNonNull

firstMatch

matchIndex

matchIndex

newArray

newArray

getComponentType

getComponentType

getArrayType

cast

append

append

setOrAppend

setOrAppend

setOrPadding

setOrPadding

addAll

replace

replace

insert

insert

resize

resize

resize

copy

copy

copy

clone

clone

edit

filter

removeNull

removeEmpty

removeBlank

nullToEmpty

zip

zip

indexOf

indexOf

indexOfIgnoreCase

lastIndexOf

lastIndexOf

contains

containsAny

containsAll

containsIgnoreCase

wrap

isArray

get