X (ready-x 3.5.1 API)

java.lang.Object
- me.codeplayer.util.X

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

作者:

Ready

构造器概要

构造器
构造器和说明

X()

构造器
构造器和说明
`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 extends Map<?,?>> T`	`emptyToNull(T map)` 尝试将空 Map 集合转为 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(Boolean b)` 判断指定Boolean值是否有效。
`static boolean`	`isValid(byte[] array)` 判断指定byte数组是否有效。
`static boolean`	`isValid(char[] array)` 判断指定char数组是否有效。
`static boolean`	`isValid(CharSequence sequence)` 判断指定的字符串序列是否有效。
`static boolean`	`isValid(Collection<?> collection)` 判断指定的Collection对象是否有效。
`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(Map<?,?> map)` 判断指定的Map对象是否有效。
`static boolean`	`isValid(Number number)` 判断指定的数值对象是否有效。
`static boolean`	`isValid(Object arg)` 判断指定对象是否无效。
`static boolean`	`isValid(Object[] array)` 判断指定的对象数组是否有效。
`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(Collection<?> c)` 返回集合的长度，如果参数为null，则返回 0
`static int`	`size(Map<?,?> map)` 返回 Map 的长度，如果参数为null，则返回 0
`static int`	`size(Object[] array)` 返回数组的长度，如果参数为null，则返回 0
`static int`	`sizeOfArray(Object array)` 返回数组的长度，如果参数为 `null`，则返回 0
`static String`	`trim4Html(String str)` 去除字符串两端的空格如果字符串为null、空字符串""、空白字符串，这返回HTML的空格符" "
`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)` 将指定的异常信息封装为运行时异常注意：如果指定的异常是运行时异常；此时不会使用传入的 `msg`

从类继承的方法 java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- 构造器详细资料
  - 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的值
  - expectNotNull
```
public static <T> T expectNotNull(T v1,
                                  T v2,
                                  T v3)
```
    从指定的多个值依次检测并选取第一个不为null的值
    
    另请参阅:
    
    expectNotNull(Object, Object, Object, Object)
  - expectNotNull
```
public static <T> T expectNotNull(T v1,
                                  T v2)
```
    从指定的多个值依次检测并选取第一个不为null的值
    
    另请参阅:
    
    expectNotNull(Object, Object, Object, Object)
  - 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的空格符" "
  - 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
  - wrapException
```
public static RuntimeException wrapException(@Nullable
                                             String msg,
                                             @Nullable
                                             Throwable ex)
```
    将指定的异常信息封装为运行时异常
    
    返回:
    
    如果异常 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
  - sizeOfArray
```
public static int sizeOfArray(Object array)
                       throws IllegalArgumentException
```
    返回数组的长度，如果参数为 null，则返回 0
    
    抛出:
    
    IllegalArgumentException - 如果 array 不是数组（可以为 null）
    
    从以下版本开始:
    
    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 条件的返回值

类 X

构造器概要

方法概要

从类继承的方法 java.lang.Object

构造器详细资料

X

方法详细资料

getLogger

isEmpty

isEmpty

isBlank

isBlank

expectNotNull

expectNotNull

expectNotNull

expectNotEmpty

expectNotEmpty

expectNotEmpty

isValid

isValid

isValid

isValid

isValid

isValid

isValid

isValid

isValid

isValid

isValid

isValid

isValid

decode

trim4Html

getCapacity

getCapacity

castType

use

use

map

map

mapElse

mapElseGet

tryUnwrap

getElse

isMatch

wrapException

wrapException

wrapException

wrapException

getRecursively

eqLax

eqLax

expectEquals

expectEquals

expectEqualsBasedOld

expectEqualsBasedOld

size

size

size

sizeOfArray

size

matchAllOrNone

matchAllOrNone

isMutex

matchAny

matchAll

emptyToNull

emptyToNull

emptyToNull

mapAny