程序包 me.codeplayer.util

类 X

  • public abstract class X
extends Object
    通用公共工具类
    此类全为静态方法，请使用静态方法的形式调用
    由于均为静态方法，所以类名尽可能地短，以免干扰逻辑可读性
    并且工具类会经常被调用，类名短，也方便开发人员编写。
    作者:
    Ready

    • 构造器概要

      构造器 
      构造器 说明
      X()  

    • 方法概要

      所有方法 静态方法 具体方法 
      修饰符和类型 方法 说明
      static <T> T castType​(Object obj)
      将指定泛型对象进行泛型擦除，并转换为对应的泛型声明
      static <T> T decode​(Object input, Object... expressions)
      将指定的值根据指定的表达式解析，并返回解析后的结果
      static <T extends Collection<?>>
      T      		 emptyToNull​(T c)
      尝试将空集合转为 null
      static <T> T[] emptyToNull​(T[] array)
      尝试将空数组转为 null
      static <T> int eqLax​(T inputVal, T currentVal)
      宽松地比较两个实体的指定属性值是否相等，并返回比较结果
      static <T,​R>
      int      		 eqLax​(T input, T current, Function<T,​R> getter)
      宽松地比较两个实体的指定属性值是否相等
      static <T,​R>
      R      		 expectEquals​(T input, T current, Function<T,​R> getter, BiConsumer<T,​R> setIfNull)
      期望两个实体的指定属性值是相等的，并返回该值。
      static <T,​R>
      R      		 expectEquals​(T input, T current, Function<T,​R> getter, BiConsumer<T,​R> setIfNull, Object error)
      期望两个实体的指定属性值是相等的，并返回该值。
      static <T,​R>
      R      		 expectEqualsBasedOld​(T input, T old, Function<T,​R> getter, Consumer<R> setOldIfInputNul)
      期望两个实体的指定属性值是相等的，并返回该值。
      static <T,​R>
      R      		 expectEqualsBasedOld​(T input, T old, Function<T,​R> getter, Consumer<R> setOldIfInputNull, Object error)
      期望两个实体的指定属性值是相等的，并返回该值。
      static String expectNotEmpty​(String v1, String v2)
      从指定的多个字符串依次检测并选取第一个不为空字符串的值，否则返回空字符串""
      static String expectNotEmpty​(String v1, String v2, String v3)
      从指定的多个字符串依次检测并选取第一个不为空字符串的值，否则返回空字符串""
      static String expectNotEmpty​(String v1, String v2, String v3, String v4)
      从指定的多个字符串依次检测并选取第一个不为空字符串的值，否则返回空字符串""
      static <T> T expectNotNull​(T v1, T v2)
      从指定的多个值依次检测并选取第一个不为null的值
      static <T> T expectNotNull​(T v1, T v2, T v3)
      从指定的多个值依次检测并选取第一个不为null的值
      static <T> T expectNotNull​(T v1, T v2, T v3, T v4)
      从指定的多个值依次检测并选取第一个不为null的值
      static int getCapacity​(int capacity)
      根据需要存储的元素个数确定HashMap等Map接口实现类的初始容量(使用默认的负载因子：0.75)
      static int getCapacity​(int capacity, float loadFactor)
      根据需要存储的元素个数确定HashMap等Map接口实现类的初始容量
      static <T> T getElse​(T val, Supplier<T> other)
      当指定 val 为 null 时，则返回替补 other 中的返回值，否则返回 val 本身
      static org.slf4j.Logger getLogger()
      获取调用此方法的当前类的日志处理器(Logger)
      该 Logger 使用 slf4j API
      static <T> T getRecursively​(T root, Function<T,​T> recursion, Predicate<T> untilMatch)
      递归地调用对象的指定方法，直到返回的对象满足指定条件（如果 root 对象本身符合条件就返回其本身）
      static boolean isBlank​(Object obj)
      判断指定的对象是否为空
      如果对象(或其 toString() 返回值)为null、空字符串、空格字符串，则返回true
      注意：本方法会先去除字符串两边的空格，再判断
      static boolean isBlank​(String str)
      判断指定的字符串是否为null或去空格后为空字符串，如果是则返回true
      static boolean isEmpty​(Object obj)
      判断指定的对象是否为空
      如果对象(或其 toString() 返回值)为 null、空字符串，则返回 true
      注意：本方法不会去除字符串两边的空格，如果想去除字符串两边的空格后再进行判断，可以使用 isBlank() 方法
      static boolean isEmpty​(String str)
      判断指定的字符串是否为空
      如果字符串为null、空字符串,则返回true
      注意：本方法不会去除字符串两边的空格，如果想去除字符串两边的空格后再进行判断，可以使用isBlank()方法
      static <T,​R>
      boolean      		 isMatch​(T bean, Function<? super T,​R> mapper, Predicate<? super R> matcher)
      检测指定的对象在经过指定的转换后，是否符合指定的条件
      static boolean isMutex​(boolean a, boolean b)
      指示两个等价于 boolean 值的条件是否互斥（若一个为 true，则另一个必定为 false）
      static boolean isValid​(byte[] array)
      判断指定byte数组是否有效。
      static boolean isValid​(char[] array)
      判断指定char数组是否有效。
      static boolean isValid​(double[] array)
      判断指定double数组是否有效。
      static boolean isValid​(float[] array)
      判断指定float数组是否有效。
      static boolean isValid​(int[] array)
      判断指定int数组是否有效。
      static boolean isValid​(long[] array)
      判断指定long数组是否有效。
      static boolean isValid​(Boolean b)
      判断指定Boolean值是否有效。
      static boolean isValid​(CharSequence sequence)
      判断指定的字符串序列是否有效。
      static boolean isValid​(Number number)
      判断指定的数值对象是否有效。
      static boolean isValid​(Object arg)
      判断指定对象是否无效。
      static boolean isValid​(Object[] array)
      判断指定的对象数组是否有效。
      static boolean isValid​(Collection<?> collection)
      判断指定的Collection对象是否有效。
      static boolean isValid​(Map<?,​?> map)
      判断指定的Map对象是否有效。
      static <T,​R>
      R      		 map​(T obj, Function<? super T,​R> mapper)
      对指定的对象执行指定的 mapper 转换，安全地获得期望的转换结果
      static <T,​R,​E>
      E      		 map​(T obj, Function<? super T,​R> mapper, Function<R,​E> nestedMapper)
      对指定的对象执行 mapper 、nestedMapper 双重转换，安全地获得期望的转换结果
      static <T,​R>
      R      		 mapAny​(Function<? super T,​? extends R> mapper, Predicate<R> matcher, T... args)
      尝试将数组 args 中的元素依次应用到 mapper 中，并返回第一个符合 matcher 条件的返回值
      static <T,​R>
      R      		 mapElse​(T obj, Function<? super T,​R> mapper, R other)
      对指定的对象执行执行的 mapper 转换，安全地获得期望的转换结果
      static <T,​R>
      R      		 mapElseGet​(T obj, Function<? super T,​R> mapper, Supplier<R> other)
      对指定的对象执行执行的 mapper 转换，安全地获得期望的转换结果
      static <T> boolean matchAll​(Predicate<T> matcher, T... values)
      指示指定的参数是否都符合指定的 matcher 条件
      static boolean matchAllOrNone​(boolean a, boolean b)
      指示两个条件是否都成立，或者都不成立
      static boolean matchAllOrNone​(boolean a, boolean b, boolean c)
      指示3个等价于 boolean 值的条件要么都成立，要么都不成立
      static <T> boolean matchAny​(Predicate<T> matcher, T... values)
      指示指定的参数是否至少有一个符合指定的 matcher 条件
      static int size​(CharSequence cs)
      返回字符序列的长度，如果参数为null，则返回 0
      static int size​(Object[] array)
      返回数组的长度，如果参数为null，则返回 0
      static int size​(Collection<?> c)
      返回集合的长度，如果参数为null，则返回 0
      static int size​(Map<?,​?> map)
      返回 Map 的长度，如果参数为null，则返回 0
      static int sizeOfArray​(Object array)
      返回数组的长度，如果参数为 null，则返回 0
      static String trim4Html​(String str)
      去除字符串两端的空格
      如果字符串为null、空字符串""、空白字符串，这返回HTML的空格符"&nbsp;"
      static <E> E tryUnwrap​(Object supplier)
      尝试拆箱可能由 Supplier 接口包装的实体对象
      static <T> void use​(T obj, Consumer<? super T> consumer)
      使用 obj 执行指定的调用
      static <T> void use​(T obj, Predicate<T> filter, Consumer<? super T> consumer)
      使用 obj 执行指定的调用
      static RuntimeException wrapException​(String msg, boolean forceUseMsg, Throwable ex)
      将指定的异常信息封装为运行时异常
      static RuntimeException wrapException​(String msg, boolean forceUseMsg, Throwable ex, Throwable cause)
      将指定的异常信息封装为运行时异常
      static RuntimeException wrapException​(String msg, Throwable ex)
      将指定的异常信息封装为运行时异常
      static RuntimeException wrapException​(String msg, Throwable ex, Throwable cause)
      将指定的异常信息封装为运行时异常

    • 构造器详细资料

      • X

        public X()

    • 方法详细资料

      • getLogger

        public static org.slf4j.Logger getLogger()
        获取调用此方法的当前类的日志处理器(Logger)
        该 Logger 使用 slf4j API

      • isEmpty

        public static boolean isEmpty​(String str)
        判断指定的字符串是否为空
        如果字符串为null、空字符串,则返回true
        注意：本方法不会去除字符串两边的空格，如果想去除字符串两边的空格后再进行判断，可以使用isBlank()方法

      • isEmpty

        public static boolean isEmpty​(Object obj)
        判断指定的对象是否为空
        如果对象(或其 toString() 返回值)为 null、空字符串，则返回 true
        注意：本方法不会去除字符串两边的空格，如果想去除字符串两边的空格后再进行判断，可以使用 isBlank() 方法
        参数:
        obj - 指定的对象

      • isBlank

        public static boolean isBlank​(String str)
        判断指定的字符串是否为null或去空格后为空字符串，如果是则返回true
        参数:
        str - 指定的字符串对象

      • isBlank

        public static boolean isBlank​(Object obj)
        判断指定的对象是否为空
        如果对象(或其 toString() 返回值)为null、空字符串、空格字符串，则返回true
        注意：本方法会先去除字符串两边的空格，再判断
        参数:
        obj - 指定的对象
        另请参阅:
        StringUtil.isBlank(Object)

      • expectNotNull

        public static <T> T expectNotNull​(T v1,
                                  T v2,
                                  T v3,
                                  T v4)
        从指定的多个值依次检测并选取第一个不为null的值

      • expectNotEmpty

        public static String expectNotEmpty​(String v1,
                                    String v2,
                                    String v3,
                                    String v4)
        从指定的多个字符串依次检测并选取第一个不为空字符串的值，否则返回空字符串""

      • expectNotEmpty

        public static String expectNotEmpty​(String v1,
                                    String v2,
                                    String v3)
        从指定的多个字符串依次检测并选取第一个不为空字符串的值，否则返回空字符串""

      • expectNotEmpty

        public static String expectNotEmpty​(String v1,
                                    String v2)
        从指定的多个字符串依次检测并选取第一个不为空字符串的值，否则返回空字符串""

      • isValid

        public static boolean isValid​(Boolean b)
        判断指定Boolean值是否有效。true 即为有效。
        参数:
        b - 指定的Boolean对象

      • isValid

        public static boolean isValid​(Number number)
        判断指定的数值对象是否有效。如果参数为 null 或 数值等于0，则为无效；其他均为有效。
        参数:
        number - 指定的

      • isValid

        public static boolean isValid​(CharSequence sequence)
        判断指定的字符串序列是否有效。如果参数为 null 或空字符串 "" ，则为无效；其他均为有效。
        参数:
        sequence - 指定的字符串序列对象

      • isValid

        public static boolean isValid​(Map<?,​?> map)
        判断指定的Map对象是否有效。如果参数为 null 或 map.size() == 0，则为无效，其他均为有效。
        参数:
        map - 指定的映射集合对象

      • isValid

        public static boolean isValid​(Collection<?> collection)
        判断指定的Collection对象是否有效。如果参数为 null 或 collection.size() == 0，则为无效，其他均为有效。
        参数:
        collection - 指定的集合对象

      • isValid

        public static boolean isValid​(byte[] array)
        判断指定byte数组是否有效。如果参数为 null 或 array.length == 0，则为无效，其他均为有效。
        参数:
        array - 指定的byte数组

      • isValid

        public static boolean isValid​(int[] array)
        判断指定int数组是否有效。如果参数为 null 或 array.length == 0，则为无效，其他均为有效。
        参数:
        array - 指定的int数组

      • isValid

        public static boolean isValid​(long[] array)
        判断指定long数组是否有效。如果参数为 null 或 array.length == 0，则为无效，其他均为有效。
        参数:
        array - 指定的long数组

      • isValid

        public static boolean isValid​(char[] array)
        判断指定char数组是否有效。如果参数为 null 或 array.length == 0，则为无效，其他均为有效。
        参数:
        array - 指定的char数组

      • isValid

        public static boolean isValid​(float[] array)
        判断指定float数组是否有效。如果参数为 null 或 array.length == 0，则为无效，其他均为有效。
        参数:
        array - 指定的float数组

      • isValid

        public static boolean isValid​(double[] array)
        判断指定double数组是否有效。如果参数为 null 或 array.length == 0，则为无效，其他均为有效。
        参数:
        array - 指定的double数组

      • isValid

        public static boolean isValid​(Object[] array)
        判断指定的对象数组是否有效。如果参数为 null 或 array.length == 0，则为无效，其他均为有效。
        参数:
        array - 指定的对象数组

      • isValid

        public static boolean isValid​(Object arg)
        判断指定对象是否无效。只有以下情况视为无效，其他均为有效。
        无效的参数对象arg的定义如下(按照判断顺序排序)：
        1.arg == null
        2.如果arg是字符序列对象，去空格后，arg.length() == 0
        3.如果arg是数值对象，去空格后，值 == 0
        4.如果arg是映射集合(Map)对象，arg.size() == 0
        5.如果arg是集合(Collection)对象，arg.size() == 0
        6.如果arg是数组(Array)对象，arg.length == 0
        7.如果arg是布尔(Boolean)对象，arg 等价于 false
        返回:
        上述无效的情况返回 false，其他情况均返回 true

      • decode

        public static <T> T decode​(Object input,
                           Object... expressions)
        将指定的值根据指定的表达式解析，并返回解析后的结果
        参数:
        input - 指定的值
        expressions - 指定的表达式，例如：("1", "男", "0", "女")方法将会将指定属性的值(value)，与表达式进行匹配，形如： 
         
 if(value 等于 "1"){
        return "男";
 }else if(value 等于 "0"){
        return "女";
 }else{
        return value;
 }

        本方法接收的表达式参数个数可以为奇数，例如：(6, "星期六", 7, "星期天", "工作日")，相当于： 

         if(value 等于 6){
        return "星期六";
 }else if(value 等于 7){
        return "星期天";
 }else{
        return "工作日";
 }

      • trim4Html

        public static String trim4Html​(String str)
        去除字符串两端的空格
        如果字符串为null、空字符串""、空白字符串，这返回HTML的空格符"&nbsp;"

      • getCapacity

        public static int getCapacity​(int capacity)
        根据需要存储的元素个数确定HashMap等Map接口实现类的初始容量(使用默认的负载因子：0.75)
        参数:
        capacity - 需要存储的元素个数

      • getCapacity

        public static int getCapacity​(int capacity,
                              float loadFactor)
        根据需要存储的元素个数确定HashMap等Map接口实现类的初始容量
        参数:
        capacity - 需要存储的元素个数
        loadFactor - 负载因子，必须介于0-1之间，如果不在此范围，内部也不检测，后果自负

      • castType

        public static <T> T castType​(Object obj)
        将指定泛型对象进行泛型擦除，并转换为对应的泛型声明

      • use

        public static <T> void use​(@Nullable
                           T obj,
                           Consumer<? super T> consumer)
        使用 obj 执行指定的调用
        参数:
        obj - 指定的对象，可以为 null
        consumer - 指定的调用，如果 obj 为 null，则不执行该调用

      • use

        public static <T> void use​(@Nullable
                           T obj,
                           Predicate<T> filter,
                           Consumer<? super T> consumer)
        使用 obj 执行指定的调用
        参数:
        obj - 指定的对象，可以为 null
        filter - 过滤器，只有 {code obj} 满足该条件，才会执行 consumer
        consumer - 指定的调用，如果 obj 为 null，则不执行该调用

      • map

        public static <T,​R> R map​(@Nullable
                                T obj,
                                Function<? super T,​R> mapper)
        对指定的对象执行指定的 mapper 转换，安全地获得期望的转换结果
        参数:
        obj - 指定的对象，可以为 null
        mapper - 转换器
        返回:
        如果 obj == null 则返回null，否则返回转换后的结果
        从以下版本开始:
        2.3.0

      • map

        public static <T,​R,​E> E map​(@Nullable
                                        T obj,
                                        Function<? super T,​R> mapper,
                                        Function<R,​E> nestedMapper)
        对指定的对象执行 mapper 、nestedMapper 双重转换，安全地获得期望的转换结果
        参数:
        obj - 指定的对象，可以为 null
        mapper - 转换器
        nestedMapper - 嵌套的二次转换器
        返回:
        如果 obj == null 则返回 null，否则返回转换后的结果
        从以下版本开始:
        2.6

      • mapElse

        public static <T,​R> R mapElse​(@Nullable
                                    T obj,
                                    Function<? super T,​R> mapper,
                                    R other)
        对指定的对象执行执行的 mapper 转换，安全地获得期望的转换结果
        参数:
        obj - 指定的对象，可以为 null
        mapper - 转换器
        other - 如果转换后的值为null，则返回该参数值
        返回:
        如果 obj == null 则返回null，否则返回转换后的结果
        从以下版本开始:
        2.6

      • mapElseGet

        public static <T,​R> R mapElseGet​(@Nullable
                                       T obj,
                                       Function<? super T,​R> mapper,
                                       Supplier<R> other)
        对指定的对象执行执行的 mapper 转换，安全地获得期望的转换结果
        参数:
        obj - 指定的对象，可以为 null
        mapper - 转换器
        other - 如果转换后的值为null，则返回该备用对象的返回值
        返回:
        如果 obj == null 则返回null，否则返回转换后的结果
        从以下版本开始:
        2.6

      • tryUnwrap

        public static <E> E tryUnwrap​(@Nullable
                              Object supplier)
        尝试拆箱可能由 Supplier 接口包装的实体对象
        返回:
        如果指定参数实现了 Supplier 接口，则调用 get() 方法 并返回其值；否则直接返回 该对象本身
        从以下版本开始:
        2.3.0

      • getElse

        public static <T> T getElse​(@Nullable
                            T val,
                            Supplier<T> other)
        当指定 val 为 null 时，则返回替补 other 中的返回值，否则返回 val 本身
        从以下版本开始:
        2.6

      • isMatch

        public static <T,​R> boolean isMatch​(@Nullable
                                          T bean,
                                          Function<? super T,​R> mapper,
                                          Predicate<? super R> matcher)
        检测指定的对象在经过指定的转换后，是否符合指定的条件
        参数:
        bean - 指定的对象
        mapper - 转换器
        matcher - 条件判断器
        从以下版本开始:
        2.3.0

      • wrapException

        public static RuntimeException wrapException​(@Nullable
                                             String msg,
                                             boolean forceUseMsg,
                                             @Nullable
                                             Throwable ex,
                                             @Nullable
                                             Throwable cause)
        将指定的异常信息封装为运行时异常
        参数:
        forceUseMsg - 如果指定的异常是运行时异常，且 msg 不为null；此时是否还需要包装一个 IllegalArgumentException 来确保强制使用传入的 msg 作为异常信息
        返回:
        如果异常 ex 为 null，或者不是运行时异常，则自动将其封装为 IllegalArgumentException；否则返回对应的运行时异常
        从以下版本开始:
        2.3.0

      • wrapException

        public static RuntimeException wrapException​(@Nullable
                                             String msg,
                                             @Nullable
                                             Throwable ex,
                                             @Nullable
                                             Throwable cause)
        将指定的异常信息封装为运行时异常

        注意：如果指定的异常是运行时异常；此时不会使用传入的 msg

        返回:
        如果异常 ex 为 null，或者不是运行时异常，则自动将其封装为 IllegalArgumentException；否则返回对应的运行时异常
        从以下版本开始:
        2.3.0

      • wrapException

        public static RuntimeException wrapException​(@Nullable
                                             String msg,
                                             boolean forceUseMsg,
                                             @Nullable
                                             Throwable ex)
        将指定的异常信息封装为运行时异常
        参数:
        forceUseMsg - 如果指定的异常是运行时异常，且 msg 不为null；此时是否还需要包装一个 IllegalArgumentException 来确保强制使用传入的 msg 作为异常信息
        返回:
        如果异常 ex 为 null，或者不是运行时异常，则自动将其封装为 IllegalArgumentException；否则返回对应的运行时异常
        从以下版本开始:
        2.3.0

      • getRecursively

        public static <T> T getRecursively​(T root,
                                   Function<T,​T> recursion,
                                   Predicate<T> untilMatch)
        递归地调用对象的指定方法，直到返回的对象满足指定条件（如果 root 对象本身符合条件就返回其本身）
        从以下版本开始:
        2.8

      • eqLax

        public static <T> int eqLax​(@Nullable
                            T inputVal,
                            @Nullable
                            T currentVal)
        宽松地比较两个实体的指定属性值是否相等，并返回比较结果
        返回:
        相等 -> 1；如果有一方为 null -> 0；否则返回 -1
        从以下版本开始:
        2.8

      • eqLax

        public static <T,​R> int eqLax​(@Nullable
                                    T input,
                                    @Nullable
                                    T current,
                                    Function<T,​R> getter)
        宽松地比较两个实体的指定属性值是否相等
        返回:
        相等 -> 1；如果有一方为 null -> 0；否则返回 -1
        从以下版本开始:
        2.8

      • expectEquals

        public static <T,​R> R expectEquals​(@Nullable
                                         T input,
                                         @Nullable
                                         T current,
                                         Function<T,​R> getter,
                                         BiConsumer<T,​R> setIfNull,
                                         @Nullable
                                         Object error)
                                  throws IllegalArgumentException
        期望两个实体的指定属性值是相等的，并返回该值。 本方法允许其中一个属性值为 null，并会自动使用另一方的值进行填补。如果两者都不为 null 且不相等，则直接抛出非法参数异常
        返回:
        返回非空的属性值。如果两个属性值相等，优先返回 current 的属性值
        抛出:
        IllegalArgumentException
        从以下版本开始:
        2.8

      • expectEquals

        public static <T,​R> R expectEquals​(@Nullable
                                         T input,
                                         @Nullable
                                         T current,
                                         Function<T,​R> getter,
                                         BiConsumer<T,​R> setIfNull)
                                  throws IllegalArgumentException
        期望两个实体的指定属性值是相等的，并返回该值。 本方法允许其中一个属性值为 null，并会自动使用另一方的值进行填补。如果两者都不为 null 且不相等，则直接抛出非法参数异常
        返回:
        返回非空的属性值。如果两个属性值相等，优先返回 current 的属性值
        抛出:
        IllegalArgumentException
        从以下版本开始:
        2.8

      • expectEqualsBasedOld

        public static <T,​R> R expectEqualsBasedOld​(@Nullable
                                                 T input,
                                                 @Nullable
                                                 T old,
                                                 Function<T,​R> getter,
                                                 Consumer<R> setOldIfInputNull,
                                                 @Nullable
                                                 Object error)
                                          throws IllegalArgumentException
        期望两个实体的指定属性值是相等的，并返回该值。 如果两者不相等且 input 为 null，则会自动使用 old 进行赋值操作。如果两者都不为 null 且不相等，则直接抛出非法参数异常
        返回:
        返回 old 的属性值
        抛出:
        IllegalArgumentException
        从以下版本开始:
        2.8

      • expectEqualsBasedOld

        public static <T,​R> R expectEqualsBasedOld​(@Nullable
                                                 T input,
                                                 @Nullable
                                                 T old,
                                                 Function<T,​R> getter,
                                                 Consumer<R> setOldIfInputNul)
                                          throws IllegalArgumentException
        期望两个实体的指定属性值是相等的，并返回该值。 如果两者不相等且 input 为 null，则会自动使用 old 进行赋值操作。如果两者都不为 null 且不相等，则直接抛出非法参数异常
        返回:
        返回 old 的属性值
        抛出:
        IllegalArgumentException
        从以下版本开始:
        2.8

      • size

        public static int size​(Collection<?> c)
        返回集合的长度，如果参数为null，则返回 0
        从以下版本开始:
        2.8

      • size

        public static int size​(Map<?,​?> map)
        返回 Map 的长度，如果参数为null，则返回 0
        从以下版本开始:
        2.8

      • size

        public static int size​(Object[] array)
        返回数组的长度，如果参数为null，则返回 0
        从以下版本开始:
        2.8

      • size

        public static int size​(CharSequence cs)
        返回字符序列的长度，如果参数为null，则返回 0
        从以下版本开始:
        2.8

      • matchAllOrNone

        public static boolean matchAllOrNone​(boolean a,
                                     boolean b)
        指示两个条件是否都成立，或者都不成立
        返回:
        a && b || !a && !b

      • matchAllOrNone

        public static boolean matchAllOrNone​(boolean a,
                                     boolean b,
                                     boolean c)
        指示3个等价于 boolean 值的条件要么都成立，要么都不成立

      • isMutex

        public static boolean isMutex​(boolean a,
                              boolean b)
        指示两个等价于 boolean 值的条件是否互斥（若一个为 true，则另一个必定为 false）

      • matchAny

        public static <T> boolean matchAny​(Predicate<T> matcher,
                                   T... values)
        指示指定的参数是否至少有一个符合指定的 matcher 条件

      • matchAll

        public static <T> boolean matchAll​(Predicate<T> matcher,
                                   T... values)
        指示指定的参数是否都符合指定的 matcher 条件

      • emptyToNull

        public static <T> T[] emptyToNull​(T[] array)
        尝试将空数组转为 null

      • emptyToNull

        public static <T extends Collection<?>> T emptyToNull​(T c)
        尝试将空集合转为 null

      • emptyToNull

        public static <T extends Map<?,​?>> T emptyToNull​(T map)
        尝试将空 Map 集合转为 null

      • mapAny

        public static <T,​R> R mapAny​(Function<? super T,​? extends R> mapper,
                                   Predicate<R> matcher,
                                   T... args)
        尝试将数组 args 中的元素依次应用到 mapper 中，并返回第一个符合 matcher 条件的返回值