Package org.miaixz.bus.core.center.array

Class ArrayValidator

java.lang.Object
org.miaixz.bus.core.center.array.ArrayValidator
Direct Known Subclasses:
PrimitiveArray
public class ArrayValidator extends Object
Array检查工具类，提供字对象的blank和empty等检查
  • empty定义：null or 空字对象：""
  • blank定义：null or 空字对象："" or 空格、全角空格、制表符、换行符，等不可见字符
Since:
Java 17+
Author:
Kimi Liu

  • Constructor Summary

    Constructors
    Constructor
    Description
    ArrayValidator()
     

  • Method Summary

    Modifier and Type
    Method
    Description
    static <T> T[]
    defaultIfEmpty(T[] array, T[] defaultArray)
    如果给定数组为空，返回默认数组
    static int
    emptyCount(Object... args)
    计算null或空元素对象的个数，通过ObjectValidator.isEmpty(Object) 判断元素
    static <T> T
    firstMatch(Predicate<T> matcher, T... array)
    返回数组中第一个匹配规则的值
    static <T> T
    firstNonNull(T... array)
    返回数组中第一个非空元素
    static boolean
    hasBlank(CharSequence... args)
    指定字符串数组中，是否包含空字符串。
    static <T> boolean
    hasEmpty(T[] args)
    是否存在null或空对象，通过ObjectValidator.isEmpty(Object) 判断元素
    static <T> boolean
    hasEmptyVarargs(T... args)
    是否存在null或空对象，通过ObjectValidator.isEmpty(Object) 判断元素
    static <T> boolean
    hasNonNull(T... array)
    是否包含非null元素
    static <T> boolean
    hasNull(T... array)
    是否包含null元素
    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 boolean
    isAllBlank(CharSequence... args)
    指定字符串数组中的元素，是否全部为空字符串。
    static <T> boolean
    isAllEmpty(T[] args)
    是否所有元素都为null或空对象，通过ObjectValidator.isEmpty(Object) 判断元素 如果提供的数组本身为空，则返回true
    static <T> boolean
    isAllEmptyVarargs(T... args)
    是否所有元素都为null或空对象，通过ObjectValidator.isEmpty(Object) 判断元素
    static boolean
    isAllNotBlank(CharSequence... args)
    是否存都不为null或空对象或空白符的对象，通过hasBlank(CharSequence...) 判断元素
    static boolean
    isAllNotEmpty(Object... args)
    是否所有元素都不为null或空对象，通过ObjectValidator.isEmpty(Object) 判断元素
    static <T> boolean
    isAllNotNull(T... array)
    是否所有元素都不为 null
    static <T> boolean
    isAllNull(T... array)
    所有字段是否全为null
    static boolean
    isArray(Object obj)
    对象是否为数组对象
    static boolean
    isEmpty(boolean[] array)
    数组是否为空
    static boolean
    isEmpty(byte[] array)
    数组是否为空
    static boolean
    isEmpty(char[] array)
    数组是否为空
    static boolean
    isEmpty(double[] array)
    数组是否为空
    static boolean
    isEmpty(float[] array)
    数组是否为空
    static boolean
    isEmpty(int[] array)
    数组是否为空
    static boolean
    isEmpty(long[] array)
    数组是否为空
    static boolean
    isEmpty(short[] array)
    数组是否为空
    static boolean
    isEmpty(Object array)
    数组是否为空 此方法会匹配单一对象，如果此对象为null则返回true 如果此对象为非数组，理解为此对象为数组的第一个元素，则返回false 如果此对象为数组对象，数组长度大于0的情况下返回false，否则返回true
    static <T> boolean
    isEmpty(T[] array)
    数组是否为空
    static boolean
    isNotEmpty(boolean[] array)
    数组是否为非空
    static boolean
    isNotEmpty(byte[] array)
    数组是否为非空
    static boolean
    isNotEmpty(char[] array)
    数组是否为非空
    static boolean
    isNotEmpty(double[] array)
    数组是否为非空
    static boolean
    isNotEmpty(float[] array)
    数组是否为非空
    static boolean
    isNotEmpty(int[] array)
    数组是否为非空
    static boolean
    isNotEmpty(long[] array)
    数组是否为非空
    static boolean
    isNotEmpty(short[] 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 boolean
    isSortedASC(byte[] array)
    检查数组是否升序，即array[i] <= array[i+1] 若传入空数组，则返回false
    static boolean
    isSortedASC(char[] array)
    检查数组是否升序，即array[i] <= array[i+1] 若传入空数组，则返回false
    static boolean
    isSortedASC(double[] array)
    检查数组是否升序，即array[i] <= array[i+1] 若传入空数组，则返回false
    static boolean
    isSortedASC(float[] array)
    检查数组是否升序，即array[i] <= array[i+1] 若传入空数组，则返回false
    static boolean
    isSortedASC(int[] array)
    检查数组是否升序，即array[i] <= array[i+1] 若传入空数组，则返回false
    static boolean
    isSortedASC(long[] array)
    检查数组是否升序，即array[i] <= array[i+1] 若传入空数组，则返回false
    static boolean
    isSortedASC(short[] array)
    检查数组是否升序，即array[i] <= array[i+1] 若传入空数组，则返回false
    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 boolean
    isSortedDESC(byte[] array)
    检查数组是否降序，即array[i] >= array[i+1] 若传入空数组，则返回false
    static boolean
    isSortedDESC(char[] array)
    检查数组是否降序，即array[i] >= array[i+1] 若传入空数组，则返回false
    static boolean
    isSortedDESC(double[] array)
    检查数组是否降序，即array[i] >= array[i+1] 若传入空数组，则返回false
    static boolean
    isSortedDESC(float[] array)
    检查数组是否降序，即array[i] >= array[i+1] 若传入空数组，则返回false
    static boolean
    isSortedDESC(int[] array)
    检查数组是否降序，即array[i] >= array[i+1] 若传入空数组，则返回false
    static boolean
    isSortedDESC(long[] array)
    检查数组是否降序，即array[i] >= array[i+1] 若传入空数组，则返回false
    static boolean
    isSortedDESC(short[] array)
    检查数组是否降序，即array[i] >= array[i+1] 若传入空数组，则返回false
    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 boolean
    isSubEquals(byte[] array, int offset, byte... subArray)
    是否局部匹配，相当于对比以下子串是否相等
    static <T> int
    lastIndexOf(T[] array, Object value)
    返回数组中指定元素最后的所在位置，未找到返回Normal.__1
    static <T> int
    lastIndexOf(T[] array, Object value, int endInclude)
    返回数组中指定元素最后的所在位置，未找到返回Normal.__1
    static int
    length(Object array)
    获取数组长度 如果参数为null，返回0
    static <E> int
    matchIndex(int beginIndexInclude, Predicate<E> matcher, E... array)
    返回数组中第一个匹配规则的值的位置
    static <T> int
    matchIndex(Predicate<T> matcher, T... array)
    返回数组中第一个匹配规则的值的位置
    static boolean
    regionMatches(byte[] array1, int offset1, byte[] array2, int offset2, int length)
    是否局部匹配，相当于对比以下子串是否相等
    static String
    toString(Object obj)
    数组或集合转String

    Methods inherited from class java.lang.Object

    clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

  • Constructor Details

    • ArrayValidator

      public ArrayValidator()

  • Method Details

    • isEmpty

      public static boolean isEmpty(long[] array)
      数组是否为空
      Parameters:
      array - 数组
      Returns:
      是否为空

    • isEmpty

      public static boolean isEmpty(int[] array)
      数组是否为空
      Parameters:
      array - 数组
      Returns:
      是否为空

    • isEmpty

      public static boolean isEmpty(short[] array)
      数组是否为空
      Parameters:
      array - 数组
      Returns:
      是否为空

    • isEmpty

      public static boolean isEmpty(char[] array)
      数组是否为空
      Parameters:
      array - 数组
      Returns:
      是否为空

    • isEmpty

      public static boolean isEmpty(byte[] array)
      数组是否为空
      Parameters:
      array - 数组
      Returns:
      是否为空

    • isEmpty

      public static boolean isEmpty(double[] array)
      数组是否为空
      Parameters:
      array - 数组
      Returns:
      是否为空

    • isEmpty

      public static boolean isEmpty(float[] array)
      数组是否为空
      Parameters:
      array - 数组
      Returns:
      是否为空

    • isEmpty

      public static boolean isEmpty(boolean[] array)
      数组是否为空
      Parameters:
      array - 数组
      Returns:
      是否为空

    • isNotEmpty

      public static boolean isNotEmpty(long[] array)
      数组是否为非空
      Parameters:
      array - 数组
      Returns:
      是否为非空

    • isNotEmpty

      public static boolean isNotEmpty(int[] array)
      数组是否为非空
      Parameters:
      array - 数组
      Returns:
      是否为非空

    • isNotEmpty

      public static boolean isNotEmpty(short[] array)
      数组是否为非空
      Parameters:
      array - 数组
      Returns:
      是否为非空

    • isNotEmpty

      public static boolean isNotEmpty(char[] array)
      数组是否为非空
      Parameters:
      array - 数组
      Returns:
      是否为非空

    • isNotEmpty

      public static boolean isNotEmpty(byte[] array)
      数组是否为非空
      Parameters:
      array - 数组
      Returns:
      是否为非空

    • isNotEmpty

      public static boolean isNotEmpty(double[] array)
      数组是否为非空
      Parameters:
      array - 数组
      Returns:
      是否为非空

    • isNotEmpty

      public static boolean isNotEmpty(float[] array)
      数组是否为非空
      Parameters:
      array - 数组
      Returns:
      是否为非空

    • isNotEmpty

      public static boolean isNotEmpty(boolean[] array)
      数组是否为非空
      Parameters:
      array - 数组
      Returns:
      是否为非空

    • isArray

      public static boolean isArray(Object obj)
      对象是否为数组对象
      Parameters:
      obj - 对象
      Returns:
      是否为数组对象，如果为null 返回false

    • 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:
      是否为非空

    • 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 boolean isSortedASC(byte[] array)
      检查数组是否升序，即array[i] <= array[i+1] 若传入空数组，则返回false
      Parameters:
      array - 数组
      Returns:
      数组是否升序

    • isSortedDESC

      public static boolean isSortedDESC(byte[] array)
      检查数组是否降序，即array[i] >= array[i+1] 若传入空数组，则返回false
      Parameters:
      array - 数组
      Returns:
      数组是否降序

    • isSortedASC

      public static boolean isSortedASC(short[] array)
      检查数组是否升序，即array[i] <= array[i+1] 若传入空数组，则返回false
      Parameters:
      array - 数组
      Returns:
      数组是否升序

    • isSortedDESC

      public static boolean isSortedDESC(short[] array)
      检查数组是否降序，即array[i] >= array[i+1] 若传入空数组，则返回false
      Parameters:
      array - 数组
      Returns:
      数组是否降序

    • isSortedASC

      public static boolean isSortedASC(char[] array)
      检查数组是否升序，即array[i] <= array[i+1] 若传入空数组，则返回false
      Parameters:
      array - 数组
      Returns:
      数组是否升序

    • isSortedDESC

      public static boolean isSortedDESC(char[] array)
      检查数组是否降序，即array[i] >= array[i+1] 若传入空数组，则返回false
      Parameters:
      array - 数组
      Returns:
      数组是否降序

    • isSortedASC

      public static boolean isSortedASC(int[] array)
      检查数组是否升序，即array[i] <= array[i+1] 若传入空数组，则返回false
      Parameters:
      array - 数组
      Returns:
      数组是否升序

    • isSortedDESC

      public static boolean isSortedDESC(int[] array)
      检查数组是否降序，即array[i] >= array[i+1] 若传入空数组，则返回false
      Parameters:
      array - 数组
      Returns:
      数组是否降序

    • isSortedASC

      public static boolean isSortedASC(long[] array)
      检查数组是否升序，即array[i] <= array[i+1] 若传入空数组，则返回false
      Parameters:
      array - 数组
      Returns:
      数组是否升序

    • isSortedDESC

      public static boolean isSortedDESC(long[] array)
      检查数组是否降序，即array[i] >= array[i+1] 若传入空数组，则返回false
      Parameters:
      array - 数组
      Returns:
      数组是否降序

    • isSortedASC

      public static boolean isSortedASC(double[] array)
      检查数组是否升序，即array[i] <= array[i+1] 若传入空数组，则返回false
      Parameters:
      array - 数组
      Returns:
      数组是否升序

    • isSortedDESC

      public static boolean isSortedDESC(double[] array)
      检查数组是否降序，即array[i] >= array[i+1] 若传入空数组，则返回false
      Parameters:
      array - 数组
      Returns:
      数组是否降序

    • isSortedASC

      public static boolean isSortedASC(float[] array)
      检查数组是否升序，即array[i] <= array[i+1] 若传入空数组，则返回false
      Parameters:
      array - 数组
      Returns:
      数组是否升序

    • isSortedDESC

      public static boolean isSortedDESC(float[] array)
      检查数组是否降序，即array[i] >= array[i+1] 若传入空数组，则返回false
      Parameters:
      array - 数组
      Returns:
      数组是否降序

    • 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:
      数组是否降序

    • isAllEmpty

      public static <T> boolean isAllEmpty(T[] args)
      是否所有元素都为null或空对象，通过ObjectValidator.isEmpty(Object) 判断元素 如果提供的数组本身为空，则返回true
      Type Parameters:
      T - 元素类型
      Parameters:
      args - 被检查的对象,一个或者多个
      Returns:
      是否都为空

    • isSubEquals

      public static boolean isSubEquals(byte[] array, int offset, byte... subArray)
      是否局部匹配，相当于对比以下子串是否相等 
           array1[offset1, subArray.length]
                  ||
               subArray
      Parameters:
      array - 数组
      offset - 开始位置
      subArray - 子数组
      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, int beginInclude, T[] subArray)
      查找子数组的位置
      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 数组
      beginInclude - 查找开始的位置（包含）
      subArray - 子数组
      Returns:
      子数组的开始位置，即子数字第一个元素在数组中的位置

    • isAllEmptyVarargs

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

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

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

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

    • isAllNotEmpty

      public static boolean isAllNotEmpty(Object... args)
      是否所有元素都不为null或空对象，通过ObjectValidator.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 元素

    • hasEmpty

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

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

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

    • hasEmptyVarargs

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

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

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

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

    • 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 元素

    • emptyCount

      public static int emptyCount(Object... args)
      计算null或空元素对象的个数，通过ObjectValidator.isEmpty(Object) 判断元素
      Parameters:
      args - 被检查的对象,一个或者多个
      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表示未匹配到

    • 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

    • indexOfSub

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

    • regionMatches

      public static boolean regionMatches(byte[] array1, int offset1, byte[] array2, int offset2, int length)
      是否局部匹配，相当于对比以下子串是否相等 
           array1[offset1 : offset1 + length]
                  ||
     array2[offset2 : offset2 + length]
      Parameters:
      array1 - 第一个数组
      offset1 - 第一个数组开始位置
      array2 - 第二个数组
      offset2 - 第二个数组开始位置
      length - 检查长度
      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: