Package org.miaixz.bus.core.xyz

Class ArrayKit

java.lang.Object
org.miaixz.bus.core.center.array.PrimitiveArray
org.miaixz.bus.core.xyz.ArrayKit
public class ArrayKit extends PrimitiveArray
数组工具类
Since:
Java 17+
Author:
Kimi Liu

  • Constructor Summary

    Constructors
    Constructor
    Description
    ArrayKit()
     

  • Method Summary

    Modifier and Type
    Method
    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 boolean
    arrayEquals(Object o1, Object o2)
    比较给定的数组和Arrays.equals，根据数组元素而不是数组引用执行相等性检查
    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 <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或空元素对象的个数，通过ObjectKit.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)
    根据数组元素类型，获取数组的类型 方法是通过创建一个空数组从而获取其类型
    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... args)
    指定字符串数组中，是否包含空字符串。
    static <T> boolean
    hasEmpty(T[] args)
    是否存在null或空对象，通过ObjectKit.isEmpty(Object) 判断元素
    static <T> boolean
    hasEmptyVarargs(T... args)
    是否存在null或空对象，通过ObjectKit.isEmpty(Object) 判断元素
    static <T> boolean
    hasNonNull(T... array)
    是否包含非null元素
    static <T> boolean
    hasNull(T... array)
    是否包含null元素
    static <T> Boolean
    hasSameElement(T[] array)
    判断数组中是否有相同元素
    static <T> int
    indexOf(T[] array, Object value)
    返回数组中指定元素所在位置，未找到返回Normal.__1
    static <T> int
    indexOf(T[] array, Object value, int beginIndexInclude)
    返回数组中指定元素所在位置，未找到返回Normal.__1
    static int
    indexOfIgnoreCase(CharSequence[] array, CharSequence value)
    返回数组中指定元素所在位置，忽略大小写，未找到返回Normal.__1
    static <T> int
    indexOfSub(T[] array, int beginInclude, T[] subArray)
    查找子数组的位置
    static <T> int
    indexOfSub(T[] array, T[] subArray)
    查找子数组的位置
    static <A, T> A
    insert(A array, int index, T... newElements)
    将新元素插入到已有数组中的某个位置 添加新元素会生成一个新的数组，不影响原数组 如果插入位置为负数，从原数组从后向前计数，若大于原数组长度，则空白处用默认值填充
    static <T> T[]
    insert(T[] buffer, int index, T... newElements)
    将新元素插入到已有数组中的某个位置 添加新元素会生成一个新的数组，不影响原数组 如果插入位置为负数，从原数组从后向前计数，若大于原数组长度，则空白处用null填充
    static boolean
    isAllBlank(CharSequence... args)
    指定字符串数组中的元素，是否全部为空字符串。
    static <T> boolean
    isAllEmpty(T[] args)
    是否所有元素都为null或空对象，通过ObjectKit.isEmpty(Object) 判断元素
    static <T> boolean
    isAllEmptyVarargs(T... args)
    是否所有元素都为null或空对象，通过ObjectKit.isEmpty(Object) 判断元素
    static boolean
    isAllNotBlank(CharSequence... args)
    是否存都不为null或空对象或空白符的对象，通过hasBlank(CharSequence...) 判断元素
    static boolean
    isAllNotEmpty(Object... args)
    是否所有元素都不为null或空对象，通过ObjectKit.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)
    检查数组是否有序，升序或者降序
    static <T> boolean
    isSorted(T[] array, Comparator<? super T> comparator)
    检查数组是否有序，升序或者降序，使用指定比较器比较
    static <T extends Comparable<? super T>>
    boolean
    isSortedASC(T[] array)
    检查数组是否升序，即 array[i].compareTo(array[i + 1]) <= 0
    static <T> boolean
    isSortedASC(T[] array, Comparator<? super T> comparator)
    检查数组是否升序，使用指定的比较器比较，即 compare.compare(array[i], array[i + 1]) <= 0
    static <T extends Comparable<? super T>>
    boolean
    isSortedDESC(T[] array)
    检查数组是否降序，即 array[i].compareTo(array[i + 1]) >= 0
    static <T> boolean
    isSortedDESC(T[] array, Comparator<? super T> comparator)
    检查数组是否降序，使用指定的比较器比较，即 compare.compare(array[i], array[i + 1]) >= 0
    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)
    返回数组中指定元素最后的所在位置，未找到返回Normal.__1
    static <T> int
    lastIndexOf(T[] array, Object value, int endInclude)
    返回数组中指定元素最后的所在位置，未找到返回Normal.__1
    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
    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> R[]
    mapToArray(T[] array, Function<? super T,? extends R> func, IntFunction<R[]> generator)
    按照指定规则，将一种类型的数组元素转换为另一种类型，并保存为 Set
    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 Object[]
    newArray(int newSize)
    新建一个Object类型空数组
    static <T> T[]
    newArray(Class<?> componentType, int newSize)
    新建一个空数组
    static String[]
    nullToEmpty(String[] array)
    数组元素中的null转换为""
    static <T> T[]
    ofArray(Iterable<T> iterable, Class<T> componentType)
    将集合转为数组
    static <A> A
    ofArray(Object values)
    转为数组，如果values为数组，返回，否则返回一个只有values一个元素的数组
    static <A> A
    ofArray(Object values, Class<?> elementType)
    转为数组，如果values为数组，返回，否则返回一个只有values一个元素的数组
    static <T> T[]
    ofArray(Iterator<T> iterator, Class<T> componentType)
    将集合转为数组
    static <T> T[]
    remove(T[] array, int index)
    移除数组中对应位置的元素 copier from commons-lang
    static <T extends CharSequence>
    T[]
    removeBlank(T[] array)
    去除null或者""或者空白字符串 元素
    static <T> T[]
    removeEle(T[] array, T element)
    移除数组中指定的元素 只会移除匹配到的第一个元素 copier 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[] 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 <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开头，每个元素的匹配使用ObjectKit.equals(Object, Object)匹配。 array和prefix为同一个数组（即array == prefix），返回true array或prefix为空数组（null或length为0的数组），返回true prefix长度大于array，返回false
    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 <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.miaixz.bus.core.center.array.PrimitiveArray

    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, 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 Details

    • ArrayKit

      public ArrayKit()

  • Method Details

    • ofArray

      public static <A> A ofArray(Object values)
      转为数组，如果values为数组，返回，否则返回一个只有values一个元素的数组
      Type Parameters:
      A - 数组类型
      Parameters:
      values - 元素值
      Returns:
      数组

    • ofArray

      public static <A> A ofArray(Object values, Class<?> elementType)
      转为数组，如果values为数组，返回，否则返回一个只有values一个元素的数组
      Type Parameters:
      A - 数组类型
      Parameters:
      values - 元素值
      elementType - 数组元素类型，null表示使用values的类型
      Returns:
      数组

    • ofArray

      public static <T> T[] ofArray(Iterator<T> iterator, Class<T> componentType)
      将集合转为数组
      Type Parameters:
      T - 数组元素类型
      Parameters:
      iterator - Iterator
      componentType - 集合元素类型
      Returns:
      数组

    • ofArray

      public static <T> T[] ofArray(Iterable<T> iterable, Class<T> componentType)
      将集合转为数组
      Type Parameters:
      T - 数组元素类型
      Parameters:
      iterable - Iterable
      componentType - 集合元素类型
      Returns:
      数组

    • hasBlank

      public static boolean hasBlank(CharSequence... args)

      指定字符串数组中，是否包含空字符串。

      如果指定的字符串数组的长度为 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:
      args - 字符串列表
      Returns:
      是否包含空字符串

    • isAllNotBlank

      public static boolean isAllNotBlank(CharSequence... args)
      是否存都不为null或空对象或空白符的对象，通过hasBlank(CharSequence...) 判断元素
      Parameters:
      args - 被检查的对象,一个或者多个
      Returns:
      是否都不为空

    • isAllBlank

      public static boolean isAllBlank(CharSequence... args)

      指定字符串数组中的元素，是否全部为空字符串。

      如果指定的字符串数组的长度为 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:
      args - 字符串列表
      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）的原数组或默认数组

    • 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或空元素对象的个数，通过ObjectKit.isEmpty(Object) 判断元素
      Parameters:
      args - 被检查的对象,一个或者多个
      Returns:
      null或空元素对象的个数

    • hasEmpty

      public static <T> boolean hasEmpty(T[] args)
      是否存在null或空对象，通过ObjectKit.isEmpty(Object) 判断元素

      如果提供的数组本身为空，则返回false

      Type Parameters:
      T - 元素类型
      Parameters:
      args - 被检查对象
      Returns:
      是否存在 null 或空对象

    • hasEmptyVarargs

      @SafeVarargs public static <T> boolean hasEmptyVarargs(T... args)
      是否存在null或空对象，通过ObjectKit.isEmpty(Object) 判断元素

      如果提供的数组本身为空，则返回false

      限制条件：args的每个item不能是数组、不能是集合

      Type Parameters:
      T - 元素类型
      Parameters:
      args - 被检查对象
      Returns:
      是否存在 null 或空对象
      Throws:
      IllegalArgumentException - 如果提供的args的item存在数组或集合，抛出异常

    • isAllEmpty

      public static <T> boolean isAllEmpty(T[] args)
      是否所有元素都为null或空对象，通过ObjectKit.isEmpty(Object) 判断元素

      如果提供的数组本身为空，则返回true

      Type Parameters:
      T - 元素类型
      Parameters:
      args - 被检查的对象,一个或者多个
      Returns:
      是否都为空

    • isAllEmptyVarargs

      @SafeVarargs public static <T> boolean isAllEmptyVarargs(T... args)
      是否所有元素都为null或空对象，通过ObjectKit.isEmpty(Object) 判断元素

      如果提供的数组本身为空，则返回true

      限制条件：args的每个item不能是数组、不能是集合

      Type Parameters:
      T - 元素类型
      Parameters:
      args - 被检查的对象,一个或者多个
      Returns:
      是否都为空
      Throws:
      IllegalArgumentException - 如果提供的args的item存在数组或集合，抛出异常

    • isAllNotEmpty

      public static boolean isAllNotEmpty(Object... args)
      是否所有元素都不为null或空对象，通过ObjectKit.isEmpty(Object) 判断元素

      如果提供的数组本身为空，则返回true

      Parameters:
      args - 被检查的对象,一个或者多个
      Returns:
      是否都不为空

    • hasNull

      public static <T> boolean hasNull(T... array)
      是否包含null元素

      如果数组为null，则返回true，如果数组为空，则返回false

      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 被检查的数组
      Returns:
      是否包含 null 元素

    • isAllNull

      public static <T> boolean isAllNull(T... array)
      所有字段是否全为null

      如果数组为null或者空，则返回 true

      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 被检查的数组
      Returns:
      所有字段是否全为null

    • isAllNotNull

      public static <T> boolean isAllNotNull(T... array)
      是否所有元素都不为 null

      如果提供的数组为null，则返回false，如果提供的数组为空，则返回true

      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 被检查的数组
      Returns:
      是否所有元素都不为 null

    • hasNonNull

      public static <T> boolean hasNonNull(T... array)
      是否包含非null元素

      如果数组是null或者空，返回false，否则当数组中有非null元素时返回true

      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 被检查的数组
      Returns:
      是否包含非 null 元素

    • firstNonNull

      public static <T> T firstNonNull(T... array)
      返回数组中第一个非空元素
      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 数组
      Returns:
      第一个非空元素，如果 不存在非空元素 或 数组为空，返回null

    • firstMatch

      public static <T> T firstMatch(Predicate<T> matcher, T... array)
      返回数组中第一个匹配规则的值
      Type Parameters:
      T - 数组元素类型
      Parameters:
      matcher - 匹配接口，实现此接口自定义匹配规则
      array - 数组
      Returns:
      第一个匹配元素，如果 不存在匹配元素 或 数组为空，返回 null

    • matchIndex

      public static <T> int matchIndex(Predicate<T> matcher, T... array)
      返回数组中第一个匹配规则的值的位置
      Type Parameters:
      T - 数组元素类型
      Parameters:
      matcher - 匹配接口，实现此接口自定义匹配规则
      array - 数组
      Returns:
      第一个匹配元素的位置，Normal.__1表示未匹配到

    • matchIndex

      public static <E> int matchIndex(int beginIndexInclude, Predicate<E> matcher, E... array)
      返回数组中第一个匹配规则的值的位置
      Type Parameters:
      E - 数组元素类型
      Parameters:
      beginIndexInclude - 检索开始的位置，不能为负数
      matcher - 匹配接口，实现此接口自定义匹配规则
      array - 数组
      Returns:
      第一个匹配元素的位置，Normal.__1表示未匹配到

    • 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类型的空数组

    • 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:
      元素类型

    • 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:
      元素类型

    • getArrayType

      public static Class<?> getArrayType(Class<?> componentType)
      根据数组元素类型，获取数组的类型 方法是通过创建一个空数组从而获取其类型

      本方法是 getComponentType(Class)的逆方法

      Parameters:
      componentType - 数组元素类型
      Returns:
      数组类型

    • cast

      public static Object[] cast(Class<?> type, Object arrayObj) throws NullPointerException, IllegalArgumentException
      强转数组类型 强制转换的前提是数组元素类型可被强制转换 强制转换后会生成一个新数组
      Parameters:
      type - 数组类型或数组元素类型
      arrayObj - 原数组
      Returns:
      转换后的数组类型
      Throws:
      NullPointerException - 提供参数为空
      IllegalArgumentException - 参数arrayObj不是数组

    • 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:
      新数组或原有数组

    • setOrAppend

      public static <A> A setOrAppend(A array, int index, Object value)
      将元素值设置为数组的某个位置，当给定的index大于等于数组长度，则追加
      Type Parameters:
      A - 数组类型
      Parameters:
      array - 已有数组
      index - 位置，大于等于长度则追加，否则替换
      value - 新值
      Returns:
      新数组或原有数组

    • setOrPadding

      public static <A> A setOrPadding(A array, int index, Object value)
      将元素值设置为数组的某个位置，当index小于数组的长度时，替换指定位置的值，否则追加null或0直到到达index后，设置值
      Type Parameters:
      A - 数组类型
      Parameters:
      array - 已有数组
      index - 位置，大于等于长度则追加，否则替换
      value - 新值
      Returns:
      新数组或原有数组

    • 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:
      新数组或原有数组

    • addAll

      @SafeVarargs public static <T> T[] addAll(T[]... arrays)
      合并所有数组，返回合并后的新数组 忽略null的数组
      Type Parameters:
      T - 数组元素类型
      Parameters:
      arrays - 数组集合
      Returns:
      合并后的数组

    • replace

      public static <T> T[] replace(T[] buffer, int index, T... values)
      从数组中的指定位置开始，按顺序使用新元素替换旧元素
      • 如果 指定位置 为负数，那么生成一个新数组，其中新元素按顺序放在数组头部
      • 如果 指定位置 大于等于 旧数组长度，那么生成一个新数组，其中新元素按顺序放在数组尾部
      • 如果 指定位置 加上 新元素数量 大于 旧数组长度，那么生成一个新数组，指定位置之前是旧数组元素，指定位置及之后为新元素
      • 否则，从已有数组中的指定位置开始，按顺序使用新元素替换旧元素，返回旧数组
      Type Parameters:
      T - 数组元素类型
      Parameters:
      buffer - 已有数组
      index - 位置
      values - 新值
      Returns:
      新数组或原有数组

    • replace

      public static <A> A replace(A array, int index, A values)
      从数组中的指定位置开始，按顺序使用新元素替换旧元素
      • 如果 指定位置 为负数，那么生成一个新数组，其中新元素按顺序放在数组头部
      • 如果 指定位置 大于等于 旧数组长度，那么生成一个新数组，其中新元素按顺序放在数组尾部
      • 如果 指定位置 加上 新元素数量 大于 旧数组长度，那么生成一个新数组，指定位置之前是旧数组元素，指定位置及之后为新元素
      • 否则，从已有数组中的指定位置开始，按顺序使用新元素替换旧元素，返回旧数组
      Type Parameters:
      A - 数组类型
      Parameters:
      array - 已有数组
      index - 位置
      values - 新值
      Returns:
      新数组或原有数组

    • insert

      public static <T> T[] insert(T[] buffer, int index, T... newElements)
      将新元素插入到已有数组中的某个位置 添加新元素会生成一个新的数组，不影响原数组 如果插入位置为负数，从原数组从后向前计数，若大于原数组长度，则空白处用null填充
      Type Parameters:
      T - 数组元素类型
      Parameters:
      buffer - 已有数组
      index - 插入位置，此位置为对应此位置元素之前的空档
      newElements - 新元素
      Returns:
      新数组

    • insert

      @SafeVarargs public static <A, T> A insert(A array, int index, T... newElements)
      将新元素插入到已有数组中的某个位置 添加新元素会生成一个新的数组，不影响原数组 如果插入位置为负数，从原数组从后向前计数，若大于原数组长度，则空白处用默认值填充
      Type Parameters:
      A - 数组类型
      T - 数组元素类型
      Parameters:
      array - 已有数组，可以为原始类型数组
      index - 插入位置，此位置为对应此位置元素之前的空档
      newElements - 新元素
      Returns:
      新数组

    • 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:
      调整后的新数组
      See Also:

    • 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:
      目标数组

    • 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:
      目标数组

    • 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:
      编辑后的数组

    • filter

      public static <T> T[] filter(T[] array, Predicate<T> predicate)
      过滤数组元素 保留 Predicate.test(Object)为true的元素
      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 数组
      predicate - 过滤器接口，用于定义过滤规则，为null则返回原数组
      Returns:
      过滤后的数组

    • removeNull

      public static <T> T[] removeNull(T[] array)
      去除 null 元素
      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 数组
      Returns:
      处理后的数组

    • removeEmpty

      public static <T extends CharSequence> T[] removeEmpty(T[] array)
      去除null或者"" 元素
      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 数组
      Returns:
      处理后的数组

    • removeBlank

      public static <T extends CharSequence> T[] removeBlank(T[] array)
      去除null或者""或者空白字符串 元素
      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 数组
      Returns:
      处理后的数组

    • nullToEmpty

      public static String[] nullToEmpty(String[] array)
      数组元素中的null转换为""
      Parameters:
      array - 数组
      Returns:
      处理后的数组

    • 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

    • 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)
      返回数组中指定元素所在位置，未找到返回Normal.__1
      Type Parameters:
      T - 数组类型
      Parameters:
      array - 数组
      value - 被检查的元素
      beginIndexInclude - 检索开始的位置
      Returns:
      数组中指定元素所在位置，未找到返回Normal.__1

    • indexOf

      public static <T> int indexOf(T[] array, Object value)
      返回数组中指定元素所在位置，未找到返回Normal.__1
      Type Parameters:
      T - 数组类型
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      数组中指定元素所在位置，未找到返回Normal.__1

    • indexOfIgnoreCase

      public static int indexOfIgnoreCase(CharSequence[] array, CharSequence value)
      返回数组中指定元素所在位置，忽略大小写，未找到返回Normal.__1
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      数组中指定元素所在位置，未找到返回Normal.__1

    • lastIndexOf

      public static <T> int lastIndexOf(T[] array, Object value)
      返回数组中指定元素最后的所在位置，未找到返回Normal.__1
      Type Parameters:
      T - 数组类型
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      数组中指定元素最后的所在位置，未找到返回Normal.__1

    • lastIndexOf

      public static <T> int lastIndexOf(T[] array, Object value, int endInclude)
      返回数组中指定元素最后的所在位置，未找到返回Normal.__1
      Type Parameters:
      T - 数组类型
      Parameters:
      array - 数组
      value - 被检查的元素
      endInclude - 从后向前查找时的起始位置，一般为array.length - 1
      Returns:
      数组中指定元素最后的所在位置，未找到返回Normal.__1

    • 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:
      是否包含指定元素中的任意一个

    • containsAll

      public static <T> boolean containsAll(T[] array, T... values)
      数组中是否包含所有指定元素
      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 数组
      values - 被检查的多个元素
      Returns:
      是否包含所有指定元素

    • containsIgnoreCase

      public static boolean containsIgnoreCase(CharSequence[] array, CharSequence value)
      数组中是否包含元素，忽略大小写
      Parameters:
      array - 数组
      value - 被检查的元素
      Returns:
      是否包含

    • wrap

      public static Object[] wrap(Object obj)
      包装数组对象
      Parameters:
      obj - 对象，可以是对象数组或者基本类型数组
      Returns:
      包装类型数组或对象数组
      Throws:
      InternalException - 对象为非数组

    • 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:
      值

    • 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 
       ArrayKit.length(null)            = 0
 ArrayKit.length([])              = 0
 ArrayKit.length([null])          = 1
 ArrayKit.length([true, false])   = 2
 ArrayKit.length([1, 2, 3])       = 3
 ArrayKit.length(["a", "b", "c"]) = 3
      Parameters:
      array - 数组对象
      Returns:
      数组长度
      Throws:
      IllegalArgumentException - 如果参数不为数组，抛出此异常
      See Also:

    • 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:
      连接后的字符串

    • join

      public static <T> String join(T[] array, CharSequence conjunction, UnaryOperator<T> editor)
      先处理数组元素，再以 conjunction 为分隔符将数组转换为字符串
      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 数组
      conjunction - 分隔符
      editor - 每个元素的编辑器，null表示不编辑
      Returns:
      连接后的字符串

    • 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
      移除数组中对应位置的元素 copier from commons-lang
      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 数组对象，可以是对象数组，也可以原始类型数组
      index - 位置，如果位置小于0或者大于长度，返回原数组
      Returns:
      去掉指定元素后的新数组或原数组
      Throws:
      IllegalArgumentException - 参数对象不为数组对象

    • removeEle

      public static <T> T[] removeEle(T[] array, T element) throws IllegalArgumentException
      移除数组中指定的元素 只会移除匹配到的第一个元素 copier from commons-lang
      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 数组对象，可以是对象数组，也可以原始类型数组
      element - 要移除的元素
      Returns:
      去掉指定元素后的新数组或原数组
      Throws:
      IllegalArgumentException - 参数对象不为数组对象

    • reverse

      public static <T> T[] reverse(T[] array, int startIndexInclusive, int endIndexExclusive)
      反转数组，会变更原数组
      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 数组，会变更
      startIndexInclusive - 开始位置（包含）
      endIndexExclusive - 结束位置（不包含）
      Returns:
      变更后的原数组

    • reverse

      public static <T> T[] reverse(T[] array)
      反转数组，会变更原数组
      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 数组，会变更
      Returns:
      变更后的原数组

    • min

      public static <T extends Comparable<? super T>> T min(T[] numberArray)
      取最小值
      Type Parameters:
      T - 元素类型
      Parameters:
      numberArray - 数字数组
      Returns:
      最小值

    • min

      public static <T extends Comparable<? super T>> T min(T[] numberArray, Comparator<T> comparator)
      取最小值
      Type Parameters:
      T - 元素类型
      Parameters:
      numberArray - 数字数组
      comparator - 比较器，null按照默认比较
      Returns:
      最小值

    • max

      public static <T extends Comparable<? super T>> T max(T[] numberArray)
      取最大值
      Type Parameters:
      T - 元素类型
      Parameters:
      numberArray - 数字数组
      Returns:
      最大值

    • max

      public static <T extends Comparable<? super T>> T max(T[] numberArray, Comparator<T> comparator)
      取最大值
      Type Parameters:
      T - 元素类型
      Parameters:
      numberArray - 数字数组
      comparator - 比较器，null表示默认比较器
      Returns:
      最大值

    • shuffle

      public static <T> T[] shuffle(T[] array)
      打乱数组顺序，会变更原数组 使用Fisher–Yates洗牌算法，以线性时间复杂度打乱数组顺序
      Type Parameters:
      T - 元素类型
      Parameters:
      array - 数组，会变更
      Returns:
      打乱后的数组

    • shuffle

      public static <T> T[] shuffle(T[] array, Random random)
      打乱数组顺序，会变更原数组 使用Fisher–Yates洗牌算法，以线性时间复杂度打乱数组顺序
      Type Parameters:
      T - 元素类型
      Parameters:
      array - 数组，会变更
      random - 随机数生成器
      Returns:
      打乱后的数组

    • swap

      public static <T> T[] swap(T[] array, int index1, int index2)
      交换数组中两个位置的值
      Type Parameters:
      T - 元素类型
      Parameters:
      array - 数组
      index1 - 位置1
      index2 - 位置2
      Returns:
      交换后的数组，与传入数组为同一对象

    • swap

      public static Object swap(Object array, int index1, int index2)
      交换数组中两个位置的值
      Parameters:
      array - 数组对象
      index1 - 位置1
      index2 - 位置2
      Returns:
      交换后的数组，与传入数组为同一对象

    • 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:
      去重后的数组

    • 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:
      转换后的数组

    • 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:
      转换后的数组

    • 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:
      列表

    • 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:
      集合

    • mapToArray

      public static <T, R> R[] mapToArray(T[] array, Function<? super T,? extends R> func, IntFunction<R[]> generator)
      按照指定规则，将一种类型的数组元素转换为另一种类型，并保存为 Set
      Type Parameters:
      T - 原数组类型
      R - 目标数组类型
      Parameters:
      array - 被转换的数组
      func - 转换规则函数
      generator - 数组生成器，如返回String[]，则传入String[]::new
      Returns:
      集合

    • equals

      public static boolean equals(Object array1, Object array2)
      判断两个数组是否相等，判断依据包括数组长度和每个元素都相等。
      Parameters:
      array1 - 数组1
      array2 - 数组2
      Returns:
      是否相等

    • sub

      public static <T> T[] sub(T[] array, int start, int end)
      获取子数组
      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 数组，不允许为空
      start - 开始位置（包括）
      end - 结束位置（不包括）
      Returns:
      新的数组
      See Also:

    • sub

      public static <A> A sub(A array, int beginInclude, int endExclude)
      获取子数组
      Type Parameters:
      A - 数组类型
      Parameters:
      array - 数组
      beginInclude - 开始位置（包括）
      endExclude - 结束位置（不包括）
      Returns:
      新的数组

    • sub

      public static <A> A sub(A array, int beginInclude, int endExclude, int step)
      获取子数组
      Type Parameters:
      A - 数组类型
      Parameters:
      array - 数组
      beginInclude - 开始位置（包括）
      endExclude - 结束位置（不包括）
      step - 步进
      Returns:
      新的数组

    • isSub

      public static <T> boolean isSub(T[] array, T[] subArray)
      是否是数组的子数组
      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 数组
      subArray - 子数组
      Returns:
      是否是数组的子数组

    • indexOfSub

      public static <T> int indexOfSub(T[] array, T[] subArray)
      查找子数组的位置
      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 数组
      subArray - 子数组
      Returns:
      子数组的开始位置，即子数字第一个元素在数组中的位置

    • indexOfSub

      public static <T> int indexOfSub(T[] array, int beginInclude, T[] subArray)
      查找子数组的位置
      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 数组
      beginInclude - 查找开始的位置（包含）
      subArray - 子数组
      Returns:
      子数组的开始位置，即子数字第一个元素在数组中的位置

    • lastIndexOfSub

      public static <T> int lastIndexOfSub(T[] array, T[] subArray)
      查找最后一个子数组的开始位置
      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 数组
      subArray - 子数组
      Returns:
      最后一个子数组的开始位置，即子数字第一个元素在数组中的位置

    • lastIndexOfSub

      public static <T> int lastIndexOfSub(T[] array, int endInclude, T[] subArray)
      查找最后一个子数组的开始位置
      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 数组
      endInclude - 从后往前查找时的开始位置（包含）
      subArray - 子数组
      Returns:
      最后一个子数组的开始位置，即从后往前，子数字第一个元素在数组中的位置

    • isSorted

      public static <T> boolean isSorted(T[] array, Comparator<? super T> comparator)
      检查数组是否有序，升序或者降序，使用指定比较器比较

      若传入空数组或空比较器，则返回false；元素全部相等，返回 true

      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 数组
      comparator - 比较器，需要自己处理null值比较
      Returns:
      数组是否有序

    • isSorted

      public static <T extends Comparable<? super T>> boolean isSorted(T[] array)
      检查数组是否有序，升序或者降序

      若传入空数组，则返回false；元素全部相等，返回 true

      Type Parameters:
      T - 数组元素类型，该类型需要实现Comparable接口
      Parameters:
      array - 数组
      Returns:
      数组是否有序
      Throws:
      NullPointerException - 如果数组元素含有null值

    • 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值

    • 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值

    • isSortedASC

      public static <T> boolean isSortedASC(T[] array, Comparator<? super T> comparator)
      检查数组是否升序，使用指定的比较器比较，即 compare.compare(array[i], array[i + 1]) <= 0

      若传入空数组或空比较器，则返回false

      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 数组
      comparator - 比较器，需要自己处理null值比较
      Returns:
      数组是否升序

    • isSortedDESC

      public static <T> boolean isSortedDESC(T[] array, Comparator<? super T> comparator)
      检查数组是否降序，使用指定的比较器比较，即 compare.compare(array[i], array[i + 1]) >= 0

      若传入空数组或空比较器，则返回false

      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 数组
      comparator - 比较器，需要自己处理null值比较
      Returns:
      数组是否降序

    • hasSameElement

      public static <T> Boolean hasSameElement(T[] array)
      判断数组中是否有相同元素

      若传入空数组，则返回false

      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 数组
      Returns:
      数组是否有相同元素

    • startWith

      public static <T> boolean startWith(T[] array, T[] prefix)
      array数组是否以prefix开头，每个元素的匹配使用ObjectKit.equals(Object, Object)匹配。
      • array和prefix为同一个数组（即array == prefix），返回true
      • array或prefix为空数组（null或length为0的数组），返回true
      • prefix长度大于array，返回false
      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 数组
      prefix - 前缀
      Returns:
      是否开头

    • arrayEquals

      public static boolean arrayEquals(Object o1, Object o2)
      比较给定的数组和Arrays.equals，根据数组元素而不是数组引用执行相等性检查
      Parameters:
      o1 - 第一个比较对象
      o2 - 第二个比较对象
      Returns:
      给定对象是否相等
      See Also: