Package org.aoju.bus.core.toolkit

Class ObjectKit

java.lang.Object
org.aoju.bus.core.toolkit.ObjectKit
public class ObjectKit extends Object
一些通用的函数
Since:
Java 17+
Author:
Kimi Liu

  • Constructor Summary

    Constructors
    Constructor
    Description
    ObjectKit()
     

  • Method Summary

    Modifier and Type
    Method
    Description
    static <T> void
    cleanInitValue(T bean)
    清空对象中所有属性的初始值
    static <T> T
    clone(T object)
    克隆对象 如果对象实现Cloneable接口,调用其clone方法 如果实现Serializable接口,执行深度克隆 否则返回null
    static <T> T
    cloneByStream(T object)
    序列化后拷贝流的方式克隆 对象必须实现Serializable接口
    static <T> T
    CloneObject(Class<T> clazz, Object bean)
    克隆有序列化的对象
    static <T> T
    CloneObject(T bean)
    克隆有序列化的对象
    static int
    compare(byte x, byte y)
    比较两个值的大小
    static int
    compare(char x, char y)
    比较两个值的大小
    static int
    compare(double x, double y)
    比较两个值的大小
    static int
    compare(int x, int y)
    比较两个值的大小
    static int
    compare(long x, long y)
    比较两个值的大小
    static int
    compare(short x, short y)
    比较两个值的大小
    static <T extends Comparable<? super T>>
    int
    compare(T c1, T c2)
    null安全的对象比较，null对象小于任何对象
    static <T extends Comparable<? super T>>
    int
    compare(T c1, T c2, boolean isNullGreater)
    null安全的对象比较
    static <T> int
    compare(T c1, T c2, Comparator<T> comparator)
    对象比较，比较结果取决于comparator，如果被比较对象为null，传入的comparator对象应处理此情况 如果传入comparator为null，则使用默认规则比较（此时被比较对象必须实现Comparable接口）
    static <T, U> Comparator<T>
    comparingIndexed(Function<? super T,? extends U> keyExtractor, boolean atEndIfMiss, U... objs)
    索引比较器 通过keyExtractor函数，提取对象的某个属性或规则，根据提供的排序数组，完成比较
    static <T, U> Comparator<T>
    comparingIndexed(Function<? super T,? extends U> keyExtractor, Iterable<U> objs)
    索引比较器 通过keyExtractor函数，提取对象的某个属性或规则，根据提供的排序数组，完成比较 objs中缺失的，默认排序在前面(atEndIfMiss=false)
    static <T, U> Comparator<T>
    comparingIndexed(Function<? super T,? extends U> keyExtractor, U[] objs)
    索引比较器 通过keyExtractor函数，提取对象的某个属性或规则，根据提供的排序数组，完成比较 objs中缺失的，默认排序在前面(atEndIfMiss=false)
    static <T> Comparator<T>
    comparingPinyin(Function<T,String> keyExtractor)
    中文比较器
    static <T> Comparator<T>
    comparingPinyin(Function<T,String> keyExtractor, boolean reverse)
    中文（拼音）比较器
    static boolean
    contains(Object object, Object element)
    对象中是否包含元素
    static <T extends CharSequence>
    T
    defaultIfBlank(T text, Supplier<? extends T> handle)
    如果被检查对象为 null 或 "" 或 空白字符串时，返回默认值（由 defaultValueSupplier 提供）；否则直接返回
    static <T extends CharSequence>
    T
    defaultIfBlank(T text, T defaultValue)
    如果给定对象为null或者""或者空白符返回默认值
    static <T> T
    defaultIfEmpty(String text, Supplier<? extends T> handle, T defaultValue)
    如果给定对象为null或者""返回默认值, 否则返回自定义handle处理后的返回值
    static <T> T[]
    defaultIfEmpty(T[] array, T[] defaultArray)
    如果给定数组为空，返回默认数组
    static <T extends CharSequence>
    T
    defaultIfEmpty(T text, Supplier<? extends T> handle)
    如果被检查对象为 null 或 "" 时，返回默认值（由 defaultValueSupplier 提供）；否则直接返回
    static <T extends CharSequence>
    T
    defaultIfEmpty(T text, T defaultValue)
    如果给定对象为null或者 "" 返回默认值
    static <T> T
    defaultIfNull(Object source, Supplier<? extends T> handle, T defaultValue)
    如果给定对象为null 返回默认值, 如果不为null 返回自定义handle处理后的返回值
    static <T> T
    defaultIfNull(T source, Supplier<? extends T> defaultValueSupplier)
    如果被检查对象为 null， 返回默认值（由 defaultValueSupplier 提供）；否则直接返回
    static <T> T
    defaultIfNull(T object, T defaultValue)
    如果给定对象为null返回默认值
    static <T> T
    deserialize(byte[] bytes)
    byte反序列化 对象必须实现Serializable接口
    static boolean
    equals(Object obj1, Object obj2)
    比较两个对象是否相等
    static <T extends Comparable<? super T>>
    boolean
    equals(T c1, T c2)
    null安全的检查两个对象是否相同，通过调用compare(c1, c2) == 0完成
    static <T extends Comparable<? super T>>
    boolean
    ge(T c1, T c2)
    c1是否大于或等于c2，通过调用compare(c1, c2) >= 0完成
    static Field[]
    getAllFields(Object object)
    获取包括父类所有的属性
    static Object
    getAttributeValue(Object object, String attrName)
    从对象中取值
    static Class
    getClassByName(String classAllName)
    依据class的名称获取对应class
    static Map<String,Class>
    getFieldNames(Class clazz)
    获取类的所有属性与属性的类型
    static Map<String,Object>
    getFields(Object bean)
    获取对象中的所有属性
    static <T> Class<T>
    getGeneric(Class clazz)
    依据类,获取该类的泛型class
    static Map<String,Object>
    getNotNullFields(Object bean)
    获取对象中的非空属性(属性如果是对象,则只会在同一个map中新增,不会出现map嵌套情况) (不会清空初始值)
    static Map<String,Object>
    getNotNullFields(Object bean, boolean hasInitValue)
    获取对象中的非空属性(属性如果是对象,则只会在同一个map中新增,不会出现map嵌套情况)
    static Map<String,Object>
    getNotNullFieldsForStructure(Object bean)
    获取对象中的非空属性(属性如果是对象,则会嵌套map)
    static Map<String,List<String>>
    getNotNullFieldsParam(Object bean)
    获取对象中的非空属性(属性如果是对象,则只会在同一个map中新增,不会出现map嵌套情况) (不会清空初始值)
    static Map<String,List<String>>
    getNotNullFieldsParam(Object bean, boolean hasInitValue)
    获取对象中的非空属性(属性如果是对象,则只会在同一个map中新增,不会出现map嵌套情况)
    static <T extends Comparable<? super T>>
    boolean
    gt(T c1, T c2)
    c1是否大于c2，通过调用compare(c1, c2) > 0完成
    static void
    identityToString(Appendable appendable, Object object)
    如果类没有覆盖toString本身，则附加由Object生成的toString.
    static String
    identityToString(Object object)
    获取如果类没有覆盖toString本身，则Object将生成的toString.
    static void
    identityToString(StringBuffer buffer, Object object)
    如果类没有覆盖toString本身，则附加由Object生成的toString.
    static void
    identityToString(StringBuilder builder, Object object)
    如果类没有覆盖toString本身，则附加由Object生成的toString.
    static void
    identityToString(TextBuilder builder, Object object)
    如果类没有覆盖toString本身，则附加由Object生成的toString.
    static <T> T
    initObject(Class<T> clazz, Map<String,Object> attrMap)
    初始化对象
    static void
    insertObject(Object baseData, Object newData)
    将新数据的非空属性值插入到基本数据中
    static boolean
    isAllEmpty(Object... objs)
    是否全都为null或空对象，通过isEmpty(Object) 判断元素
    static boolean
    isAllNotEmpty(Object... objs)
    是否全都不为null或空对象，通过isEmpty(Object) 判断元素
    static boolean
    isArray(Object object)
    确定给定的对象是一个数组:对象数组还是基元数组
    static boolean
    isBaseClass(Object value)
    校验是否是九种基础类型(即：非用户定义的类型)
    static boolean
    isEmpty(Object object)
    判断指定对象是否为空，支持：
    static boolean
    isFalse(Boolean object)
    判断对象为false
    static <T extends Comparable<? super T>>
    boolean
    isIn(T value, T c1, T c2)
    给定的value是否在c1和c2的范围内 即 min(c1,c2) <= value <= max(c1,c2)
    static <T extends Comparable<? super T>>
    boolean
    isInExclusive(T value, T c1, T c2)
    给定的value是否在c1和c2的范围内，但是不包括边界 即 min(c1,c2) < value < max(c1,c2)
    static final boolean
    isNotEmpty(Object object)
    判断对象是否为NotEmpty(!null或元素大于0) 实用于对如下对象做判断:String Collection及其子类 Map及其子类
    static boolean
    isNotNull(Object object)
    检查对象是否不为null
    static boolean
    isNull(Object object)
    检查对象是否为null
    static boolean
    isTrue(Boolean object)
    判断对象为true
    static <T extends Comparable<? super T>>
    boolean
    le(T c1, T c2)
    c1是否小于或等于c2，通过调用compare(c1, c2) <= 0完成
    static int
    length(Object object)
    计算对象长度,如果是字符串调用其length函数, 集合类调用其size函数, 数组调用其length属性, 其他可遍历对象遍历计算长度
    static <T extends Comparable<? super T>>
    boolean
    lt(T c1, T c2)
    c1是否大小于c2，通过调用compare(c1, c2) < 0完成
    static <T extends Comparable<? super T>>
    T
    max(T t1, T t2)
    取两个值中的最大值，大小相同返回第一个值
    static <T extends Comparable<? super T>>
    T
    min(T t1, T t2)
    取两个值中的最小值，大小相同返回第一个值
    static <E extends Comparable<? super E>>
    Comparator<E>
    natural()
    获取自然排序器，即默认排序器 如需对null友好操作如下 Comparator.nullsLast(CompareKit.natural()) Comparator.nullsFirst(CompareKit.natural())
    static <E extends Comparable<? super E>>
    Comparator<E>
    naturalReverse()
    获取反序排序器，即默认自然排序的反序排序器 如需对null友好操作如下 Comparator.nullsLast(CompareKit.naturalReverse()) Comparator.nullsFirst(CompareKit.naturalReverse())
    static boolean
    notEquals(Object obj1, Object obj2)
    比较两个对象是否不相等
    static boolean
    nullSafeEquals(Object o1, Object o2)
    确定给定的对象是否相等，如果两个对象都是null， 则返回true;如果只有一个对象是null， 则返回false
    static <T> T
    parseByteForObject(byte[] bts)
    将byte字节转换成对象
    static byte[]
    parseObjForByte(Object object)
    将对象转换为byte数据
    static <T> T
    parseToObject(Object value, Class<T> type)
    转换类型
    static <E extends Comparable<? super E>>
    Comparator<E>
    reverse(Comparator<E> comparator)
    获取反序排序器，即默认排序器 如需对null友好操作如下 Comparator.nullsLast(CompareKit.reverse()) Comparator.nullsFirst(CompareKit.reverse())
    static <T> byte[]
    serialize(T object)
    对象序列化 对象必须实现Serializable接口
    static void
    setAttribute(Object object, String attrName, Object value)
    给对象的属性赋值
    static byte[]
    toByte(Object object)
    将对象进行序列化
    static <T> T
    toObject(byte[] bts)
    将序列化数据转换为对象
    static <T> T
    toObject(String base64)
    将base64的序列化数据转换为对象
    static Object[]
    toObjectArray(Object source)
    将给定的数组(可能是原始数组)转换为对象数组(如果需要原始包装器对象) 一个null源值将被转换为一个空的对象数组.
    static String
    toString(Object object)
    将Object转为String 策略为：

    Methods inherited from class java.lang.Object

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

  • Constructor Details

    • ObjectKit

      public ObjectKit()

  • Method Details

    • isNull

      public static boolean isNull(Object object)
      检查对象是否为null
      Parameters:
      object - 对象
      Returns:
      是否为null

    • isNotNull

      public static boolean isNotNull(Object object)
      检查对象是否不为null 
       1. != null
 2. not equals(null)
      Parameters:
      object - 对象
      Returns:
      是否为非null

    • defaultIfNull

      public static <T> T defaultIfNull(T object, T defaultValue)
      如果给定对象为null返回默认值
      Type Parameters:
      T - 对象类型
      Parameters:
      object - 被检查对象,可能为null
      defaultValue - 被检查对象为null返回的默认值,可以为null
      Returns:
      被检查对象为{ null}返回默认值,否则返回原值

    • defaultIfNull

      public static <T> T defaultIfNull(T source, Supplier<? extends T> defaultValueSupplier)
      如果被检查对象为 null， 返回默认值（由 defaultValueSupplier 提供）；否则直接返回
      Type Parameters:
      T - 对象类型
      Parameters:
      source - 被检查对象
      defaultValueSupplier - 默认值提供者
      Returns:
      被检查对象为null返回默认值，否则返回自定义handle处理后的返回值

    • defaultIfNull

      public static <T> T defaultIfNull(Object source, Supplier<? extends T> handle, T defaultValue)
      如果给定对象为null 返回默认值, 如果不为null 返回自定义handle处理后的返回值
      Type Parameters:
      T - 被检查对象为null返回默认值，否则返回自定义handle处理后的返回值
      Parameters:
      source - Object 类型对象
      handle - 非空时自定义的处理方法
      defaultValue - 默认为空的返回值
      Returns:
      被检查对象为{ null}返回默认值,否则返回原值

    • defaultIfEmpty

      public static <T extends CharSequence> T defaultIfEmpty(T text, Supplier<? extends T> handle)
      如果被检查对象为 null 或 "" 时，返回默认值（由 defaultValueSupplier 提供）；否则直接返回
      Type Parameters:
      T - 对象类型（必须实现CharSequence接口）
      Parameters:
      text - 被检查对象
      handle - 默认值提供者
      Returns:
      被检查对象为null返回默认值，否则返回自定义handle处理后的返回值

    • defaultIfEmpty

      public static <T> T defaultIfEmpty(String text, Supplier<? extends T> handle, T defaultValue)
      如果给定对象为null或者""返回默认值, 否则返回自定义handle处理后的返回值
      Type Parameters:
      T - 被检查对象为null或者 ""返回默认值，否则返回自定义handle处理后的返回值
      Parameters:
      text - String 类型
      handle - 自定义的处理方法
      defaultValue - 默认为空的返回值
      Returns:
      被检查对象为{ null}返回默认值,否则返回原值

    • defaultIfEmpty

      public static <T extends CharSequence> T defaultIfEmpty(T text, T defaultValue)
      如果给定对象为null或者 "" 返回默认值 
       ObjectKit.defaultIfEmpty(null, null)      = null
 ObjectKit.defaultIfEmpty(null, "")        = ""
 ObjectKit.defaultIfEmpty("", "zz")        = "zz"
 ObjectKit.defaultIfEmpty(" ", "zz")       = " "
 ObjectKit.defaultIfEmpty("abc", *)        = "abc"
      Type Parameters:
      T - 对象类型(必须实现CharSequence接口)
      Parameters:
      text - 被检查对象，可能为null
      defaultValue - 被检查对象为null或者 ""返回的默认值，可以为null或者 ""
      Returns:
      被检查对象为null或者 ""返回默认值，否则返回原值

    • defaultIfEmpty

      public static <T> T[] defaultIfEmpty(T[] array, T[] defaultArray)
      如果给定数组为空，返回默认数组
      Type Parameters:
      T - 数组元素类型
      Parameters:
      array - 数组
      defaultArray - 默认数组
      Returns:
      非空（empty）的原数组或默认数组

    • defaultIfBlank

      public static <T extends CharSequence> T defaultIfBlank(T text, T defaultValue)
      如果给定对象为null或者""或者空白符返回默认值 
       ObjectKit.defaultIfBlank(null, null)      = null
 ObjectKit.defaultIfBlank(null, "")        = ""
 ObjectKit.defaultIfBlank("", "zz")        = "zz"
 ObjectKit.defaultIfBlank(" ", "zz")       = "zz"
 ObjectKit.defaultIfBlank("abc", *)        = "abc"
      Type Parameters:
      T - 对象类型(必须实现CharSequence接口)
      Parameters:
      text - 被检查对象，可能为null
      defaultValue - 被检查对象为null或者 ""或者空白符返回的默认值，可以为null或者 ""或者空白符
      Returns:
      被检查对象为null或者 ""或者空白符返回默认值，否则返回原值

    • defaultIfBlank

      public static <T extends CharSequence> T defaultIfBlank(T text, Supplier<? extends T> handle)
      如果被检查对象为 null 或 "" 或 空白字符串时，返回默认值（由 defaultValueSupplier 提供）；否则直接返回
      Type Parameters:
      T - 对象类型（必须实现CharSequence接口）
      Parameters:
      text - 被检查对象
      handle - 默认值提供者
      Returns:
      被检查对象为null返回默认值，否则返回自定义handle处理后的返回值

    • isTrue

      public static boolean isTrue(Boolean object)
      判断对象为true
      Parameters:
      object - 对象
      Returns:
      对象是否为true

    • isFalse

      public static boolean isFalse(Boolean object)
      判断对象为false
      Parameters:
      object - 对象
      Returns:
      对象是否为false

    • isArray

      public static boolean isArray(Object object)
      确定给定的对象是一个数组:对象数组还是基元数组
      Parameters:
      object - 要检查的对象
      Returns:
      the true/false

    • isEmpty

      public static boolean isEmpty(Object object)
      判断指定对象是否为空，支持： 
       1. CharSequence
 2. Map
 3. Iterable
 4. Iterator
 5. Array
      Parameters:
      object - 被判断的对象
      Returns:
      是否为空，如果类型不支持，返回false

    • isNotEmpty

      public static final boolean isNotEmpty(Object object)
      判断对象是否为NotEmpty(!null或元素大于0) 实用于对如下对象做判断:String Collection及其子类 Map及其子类
      Parameters:
      object - 待检查对象
      Returns:
      boolean 返回的布尔值

    • isAllEmpty

      public static boolean isAllEmpty(Object... objs)
      是否全都为null或空对象，通过isEmpty(Object) 判断元素
      Parameters:
      objs - 被检查的对象,一个或者多个
      Returns:
      是否都为空

    • isAllNotEmpty

      public static boolean isAllNotEmpty(Object... objs)
      是否全都不为null或空对象，通过isEmpty(Object) 判断元素
      Parameters:
      objs - 被检查的对象,一个或者多个
      Returns:
      是否都不为空

    • equals

      public static boolean equals(Object obj1, Object obj2)
      比较两个对象是否相等
      Parameters:
      obj1 - 对象1
      obj2 - 对象2
      Returns:
      是否相等
      See Also:

    • notEquals

      public static boolean notEquals(Object obj1, Object obj2)
      比较两个对象是否不相等
      Parameters:
      obj1 - 对象1
      obj2 - 对象2
      Returns:
      是否不等

    • length

      public static int length(Object object)
      计算对象长度,如果是字符串调用其length函数, 集合类调用其size函数, 数组调用其length属性, 其他可遍历对象遍历计算长度
      Parameters:
      object - 被计算长度的对象
      Returns:
      长度

    • contains

      public static boolean contains(Object object, Object element)
      对象中是否包含元素
      Parameters:
      object - 对象
      element - 元素
      Returns:
      是否包含

    • clone

      public static <T> T clone(T object)
      克隆对象 如果对象实现Cloneable接口,调用其clone方法 如果实现Serializable接口,执行深度克隆 否则返回null
      Type Parameters:
      T - 对象类型
      Parameters:
      object - 被克隆对象
      Returns:
      克隆后的对象

    • toString

      public static String toString(Object object)
      将Object转为String 策略为： 
        1、null转为"null"
  2、调用Convert.toString(Object)转换
      Parameters:
      object - Bean对象
      Returns:
      Bean所有字段转为Map后的字符串

    • cloneByStream

      public static <T> T cloneByStream(T object)
      序列化后拷贝流的方式克隆 对象必须实现Serializable接口
      Type Parameters:
      T - 对象类型
      Parameters:
      object - 被克隆对象
      Returns:
      克隆后的对象
      Throws:
      InternalException - IO异常和ClassNotFoundException封装

    • getAllFields

      public static Field[] getAllFields(Object object)
      获取包括父类所有的属性
      Parameters:
      object - 对象
      Returns:
      the field

    • toByte

      public static byte[] toByte(Object object)
      将对象进行序列化
      Parameters:
      object - 对象
      Returns:
      对象序列化后的数据

    • toObject

      public static <T> T toObject(String base64)
      将base64的序列化数据转换为对象
      Type Parameters:
      T - 对象
      Parameters:
      base64 - 经过base64的序列化对象数据
      Returns:
      原对象

    • toObject

      public static <T> T toObject(byte[] bts)
      将序列化数据转换为对象
      Type Parameters:
      T - 对象
      Parameters:
      bts - 序列化后的对象数据
      Returns:
      原对象

    • getClassByName

      public static Class getClassByName(String classAllName)
      依据class的名称获取对应class
      Parameters:
      classAllName - 类的全称(如: java.lang.String)
      Returns:
      返回依据类名映射的class对象

    • initObject

      public static <T> T initObject(Class<T> clazz, Map<String,Object> attrMap)
      初始化对象
      Type Parameters:
      T - 对象
      Parameters:
      clazz - 创建的对象的类型
      attrMap - 初始对象的属性值
      Returns:
      创建的对象

    • setAttribute

      public static void setAttribute(Object object, String attrName, Object value)
      给对象的属性赋值
      Parameters:
      object - 对象
      attrName - 对象的属性名
      value - 对象的属性值

    • getAttributeValue

      public static Object getAttributeValue(Object object, String attrName)
      从对象中取值
      Parameters:
      object - 对象
      attrName - 要取值的属性名
      Returns:
      值

    • getFields

      public static Map<String,Object> getFields(Object bean)
      获取对象中的所有属性
      Parameters:
      bean - 对象
      Returns:
      属性和值(Map[属性名, 属性值])

    • getFieldNames

      public static Map<String,Class> getFieldNames(Class clazz)
      获取类的所有属性与属性的类型
      Parameters:
      clazz - 类
      Returns:
      该类的所有属性名与属性类型(包含父类属性)

    • getNotNullFields

      public static Map<String,Object> getNotNullFields(Object bean, boolean hasInitValue)
      获取对象中的非空属性(属性如果是对象,则只会在同一个map中新增,不会出现map嵌套情况)
      Parameters:
      bean - 对象
      hasInitValue - 是否过滤掉初始值(true:过滤掉)
      Returns:
      非空属性和值(Map[属性名, 属性值])

    • getNotNullFields

      public static Map<String,Object> getNotNullFields(Object bean)
      获取对象中的非空属性(属性如果是对象,则只会在同一个map中新增,不会出现map嵌套情况) (不会清空初始值)
      Parameters:
      bean - 对象
      Returns:
      非空属性和值(Map[属性名, 属性值])

    • getNotNullFieldsParam

      public static Map<String,List<String>> getNotNullFieldsParam(Object bean)
      获取对象中的非空属性(属性如果是对象,则只会在同一个map中新增,不会出现map嵌套情况) (不会清空初始值)

      request param

      Parameters:
      bean - 对象
      Returns:
      非空属性和值(Map[属性名, 属性值])

    • getNotNullFieldsParam

      public static Map<String,List<String>> getNotNullFieldsParam(Object bean, boolean hasInitValue)
      获取对象中的非空属性(属性如果是对象,则只会在同一个map中新增,不会出现map嵌套情况)
      Parameters:
      bean - 对象
      hasInitValue - 是否过滤掉初始值(true:过滤掉)
      Returns:
      非空属性和值(Map[属性名, 属性值])

    • getNotNullFieldsForStructure

      public static Map<String,Object> getNotNullFieldsForStructure(Object bean)
      获取对象中的非空属性(属性如果是对象,则会嵌套map)
      Parameters:
      bean - 对象
      Returns:
      非空属性和值(Map[属性名, 属性值])

    • getGeneric

      public static <T> Class<T> getGeneric(Class clazz)
      依据类,获取该类的泛型class
      Type Parameters:
      T - 对象
      Parameters:
      clazz - 类对象
      Returns:
      泛型类型

    • parseByteForObject

      public static <T> T parseByteForObject(byte[] bts)
      将byte字节转换成对象
      Type Parameters:
      T - 对象
      Parameters:
      bts - 字节数据
      Returns:
      对象

    • parseObjForByte

      public static byte[] parseObjForByte(Object object)
      将对象转换为byte数据
      Parameters:
      object - 对象
      Returns:
      byte数据

    • parseToObject

      public static <T> T parseToObject(Object value, Class<T> type)
      转换类型
      Type Parameters:
      T - 对象
      Parameters:
      value - 字符串的值
      type - 要转换的类型
      Returns:
      转换后的值

    • isBaseClass

      public static boolean isBaseClass(Object value)
      校验是否是九种基础类型(即：非用户定义的类型)
      Parameters:
      value - 字符串的值 要校验的值
      Returns:
      是否是基础类型(true : 已经是基础类型了)

    • CloneObject

      public static <T> T CloneObject(Class<T> clazz, Object bean)
      克隆有序列化的对象
      Type Parameters:
      T - 要返回的数据类型
      Parameters:
      clazz - 反射类
      bean - 所有继承过BaseBean的对象
      Returns:
      克隆后的对象

    • CloneObject

      public static <T> T CloneObject(T bean)
      克隆有序列化的对象
      Type Parameters:
      T - 要返回的数据类型
      Parameters:
      bean - 要克隆的对象
      Returns:
      克隆后的对象

    • insertObject

      public static void insertObject(Object baseData, Object newData)
      将新数据的非空属性值插入到基本数据中
      Parameters:
      baseData - 基本数据
      newData - 新数据

    • cleanInitValue

      public static <T> void cleanInitValue(T bean)
      清空对象中所有属性的初始值
      Type Parameters:
      T - 对象
      Parameters:
      bean - 对象

    • identityToString

      public static String identityToString(Object object)
      获取如果类没有覆盖toString本身，则Object将生成的toString. null将返回null 
       ObjectKit.identityToString(null)         = null
 ObjectKit.identityToString("")           = "java.lang.String@1e23"
 ObjectKit.identityToString(Boolean.TRUE) = "java.lang.Boolean@7fa"
      Parameters:
      object - 创建toString的对象可以是null
      Returns:
      如果传入null，则默认的toString文本或null

    • identityToString

      public static void identityToString(Appendable appendable, Object object) throws IOException
      如果类没有覆盖toString本身，则附加由Object生成的toString. null将为这两个参数中的任何一个抛出NullPointerException 
       ObjectKit.identityToString(appendable, "")            = appendable.append("java.lang.String@1e23"
 ObjectKit.identityToString(appendable, Boolean.TRUE)  = appendable.append("java.lang.Boolean@7fa"
 ObjectKit.identityToString(appendable, Boolean.TRUE)  = appendable.append("java.lang.Boolean@7fa")
      Parameters:
      appendable - 可以附加的信息
      object - 要为其创建toString的对象
      Throws:
      IOException - 如果发生I/O错误

    • identityToString

      public static void identityToString(TextBuilder builder, Object object)
      如果类没有覆盖toString本身，则附加由Object生成的toString. null将为这两个参数中的任何一个抛出NullPointerException 
       ObjectKit.identityToString(builder, "")            = builder.append("java.lang.String@1e23"
 ObjectKit.identityToString(builder, Boolean.TRUE)  = builder.append("java.lang.Boolean@7fa"
 ObjectKit.identityToString(builder, Boolean.TRUE)  = builder.append("java.lang.Boolean@7fa")
      Parameters:
      builder - 要附加到的生成器
      object - 要为其创建toString的对象

    • identityToString

      public static void identityToString(StringBuffer buffer, Object object)
      如果类没有覆盖toString本身，则附加由Object生成的toString. null将为这两个参数中的任何一个抛出NullPointerException 
       ObjectKit.identityToString(buf, "")            = buf.append("java.lang.String@1e23"
 ObjectKit.identityToString(buf, Boolean.TRUE)  = buf.append("java.lang.Boolean@7fa"
 ObjectKit.identityToString(buf, Boolean.TRUE)  = buf.append("java.lang.Boolean@7fa")
      Parameters:
      buffer - 要追加的缓冲区
      object - 要为其创建toString的对象

    • identityToString

      public static void identityToString(StringBuilder builder, Object object)
      如果类没有覆盖toString本身，则附加由Object生成的toString. null将为这两个参数中的任何一个抛出NullPointerException 
       ObjectKit.identityToString(builder, "")            = builder.append("java.lang.String@1e23"
 ObjectKit.identityToString(builder, Boolean.TRUE)  = builder.append("java.lang.Boolean@7fa"
 ObjectKit.identityToString(builder, Boolean.TRUE)  = builder.append("java.lang.Boolean@7fa")
      Parameters:
      builder - 要附加到的生成器
      object - 要为其创建toString的对象

    • nullSafeEquals

      public static boolean nullSafeEquals(Object o1, Object o2)
      确定给定的对象是否相等，如果两个对象都是null， 则返回true;如果只有一个对象是null， 则返回false
      Parameters:
      o1 - 第一个比较对象
      o2 - 第二个比较对象
      Returns:
      给定对象是否相等
      See Also:

    • toObjectArray

      public static Object[] toObjectArray(Object source)
      将给定的数组(可能是原始数组)转换为对象数组(如果需要原始包装器对象) 一个null源值将被转换为一个空的对象数组.
      Parameters:
      source - 数组
      Returns:
      对应的对象数组

    • serialize

      public static <T> byte[] serialize(T object)
      对象序列化 对象必须实现Serializable接口
      Type Parameters:
      T - 对象类型
      Parameters:
      object - 要被序列化的对象
      Returns:
      序列化后的字节码

    • deserialize

      public static <T> T deserialize(byte[] bytes)
      byte反序列化 对象必须实现Serializable接口
      Type Parameters:
      T - 对象类型
      Parameters:
      bytes - 反序列化的字节码
      Returns:
      反序列化后的对象

    • compare

      public static int compare(char x, char y)
      比较两个值的大小
      Parameters:
      x - 第一个值
      y - 第二个值
      Returns:
      x==y返回0，x<y返回小于0的数，x>y返回大于0的数
      See Also:

    • compare

      public static int compare(double x, double y)
      比较两个值的大小
      Parameters:
      x - 第一个值
      y - 第二个值
      Returns:
      x==y返回0，x<y返回小于0的数，x>y返回大于0的数
      See Also:

    • compare

      public static int compare(int x, int y)
      比较两个值的大小
      Parameters:
      x - 第一个值
      y - 第二个值
      Returns:
      x==y返回0，x<y返回小于0的数，x>y返回大于0的数
      See Also:

    • compare

      public static int compare(long x, long y)
      比较两个值的大小
      Parameters:
      x - 第一个值
      y - 第二个值
      Returns:
      x==y返回0，x<y返回小于0的数，x>y返回大于0的数
      See Also:

    • compare

      public static int compare(short x, short y)
      比较两个值的大小
      Parameters:
      x - 第一个值
      y - 第二个值
      Returns:
      x==y返回0，x<y返回小于0的数，x>y返回大于0的数
      See Also:

    • compare

      public static int compare(byte x, byte y)
      比较两个值的大小
      Parameters:
      x - 第一个值
      y - 第二个值
      Returns:
      x==y返回0，x<y返回-1，x>y返回1
      See Also:

    • natural

      public static <E extends Comparable<? super E>> Comparator<E> natural()
      获取自然排序器，即默认排序器
      • 如需对null友好操作如下
      • Comparator.nullsLast(CompareKit.natural())
      • Comparator.nullsFirst(CompareKit.natural())
      Type Parameters:
      E - 排序节点类型
      Returns:
      默认排序器

    • naturalReverse

      public static <E extends Comparable<? super E>> Comparator<E> naturalReverse()
      获取反序排序器，即默认自然排序的反序排序器
      • 如需对null友好操作如下
      • Comparator.nullsLast(CompareKit.naturalReverse())
      • Comparator.nullsFirst(CompareKit.naturalReverse())
      Type Parameters:
      E - 排序节点类型
      Returns:
      默认排序器

    • reverse

      public static <E extends Comparable<? super E>> Comparator<E> reverse(Comparator<E> comparator)
      获取反序排序器，即默认排序器
      • 如需对null友好操作如下
      • Comparator.nullsLast(CompareKit.reverse())
      • Comparator.nullsFirst(CompareKit.reverse())
      Type Parameters:
      E - 排序节点类型
      Parameters:
      comparator - 排序器
      Returns:
      默认排序器

    • compare

      public static <T> int compare(T c1, T c2, Comparator<T> comparator)
      对象比较，比较结果取决于comparator，如果被比较对象为null，传入的comparator对象应处理此情况 如果传入comparator为null，则使用默认规则比较（此时被比较对象必须实现Comparable接口）

      一般而言，如果c1 < c2，返回数小于0，c1==c2返回0，c1 > c2 大于0

      Type Parameters:
      T - 被比较对象类型
      Parameters:
      c1 - 对象1
      c2 - 对象2
      comparator - 比较器
      Returns:
      比较结果
      See Also:

    • compare

      public static <T extends Comparable<? super T>> int compare(T c1, T c2)
      null安全的对象比较，null对象小于任何对象
      Type Parameters:
      T - 被比较对象类型
      Parameters:
      c1 - 对象1，可以为null
      c2 - 对象2，可以为null
      Returns:
      比较结果，如果c1 < c2，返回数小于0，c1==c2返回0，c1 > c2 大于0
      See Also:

    • compare

      public static <T extends Comparable<? super T>> int compare(T c1, T c2, boolean isNullGreater)
      null安全的对象比较
      Type Parameters:
      T - 被比较对象类型（必须实现Comparable接口）
      Parameters:
      c1 - 对象1，可以为null
      c2 - 对象2，可以为null
      isNullGreater - 当被比较对象为null时是否排在后面，true表示null大于任何对象，false反之
      Returns:
      比较结果，如果c1 < c2，返回数小于0，c1==c2返回0，c1 > c2 大于0
      See Also:

    • compare

      public static <T> int compare(T o1, T o2, boolean isNullGreater)
      自然比较两个对象的大小，比较规则如下： 
       1、如果实现Comparable调用compareTo比较
 2、o1.equals(o2)返回0
 3、比较hashCode值
 4、比较toString值
      Type Parameters:
      T - 被比较对象类型
      Parameters:
      o1 - 对象1
      o2 - 对象2
      isNullGreater - null值是否做为最大值
      Returns:
      比较结果，如果o1 < o2，返回数小于0，o1==o2返回0，o1 > o2 大于0

    • comparingPinyin

      public static <T> Comparator<T> comparingPinyin(Function<T,String> keyExtractor)
      中文比较器
      Type Parameters:
      T - 对象类型
      Parameters:
      keyExtractor - 从对象中提取中文(参与比较的内容)
      Returns:
      中文比较器

    • comparingPinyin

      public static <T> Comparator<T> comparingPinyin(Function<T,String> keyExtractor, boolean reverse)
      中文（拼音）比较器
      Type Parameters:
      T - 对象类型
      Parameters:
      keyExtractor - 从对象中提取中文(参与比较的内容)
      reverse - 是否反序
      Returns:
      中文比较器

    • comparingIndexed

      public static <T, U> Comparator<T> comparingIndexed(Function<? super T,? extends U> keyExtractor, U[] objs)
      索引比较器 通过keyExtractor函数，提取对象的某个属性或规则，根据提供的排序数组，完成比较 objs中缺失的，默认排序在前面(atEndIfMiss=false)
      Type Parameters:
      T - 对象类型
      U - 数组对象类型
      Parameters:
      keyExtractor - 从对象中提取中文(参与比较的内容)
      objs - 参与排序的数组，数组的元素位置决定了对象的排序先后
      Returns:
      索引比较器

    • comparingIndexed

      public static <T, U> Comparator<T> comparingIndexed(Function<? super T,? extends U> keyExtractor, Iterable<U> objs)
      索引比较器 通过keyExtractor函数，提取对象的某个属性或规则，根据提供的排序数组，完成比较 objs中缺失的，默认排序在前面(atEndIfMiss=false)
      Type Parameters:
      T - 对象类型
      U - 数组对象类型
      Parameters:
      keyExtractor - 从对象中提取中文(参与比较的内容)
      objs - 参与排序的集合对象，数组的元素位置决定了对象的排序先后
      Returns:
      索引比较器

    • comparingIndexed

      public static <T, U> Comparator<T> comparingIndexed(Function<? super T,? extends U> keyExtractor, boolean atEndIfMiss, U... objs)
      索引比较器 通过keyExtractor函数，提取对象的某个属性或规则，根据提供的排序数组，完成比较
      Type Parameters:
      T - 对象类型
      U - 数组对象类型
      Parameters:
      keyExtractor - 从对象中提取排序键的函数(参与比较的内容)
      atEndIfMiss - 如果不在列表中是否排在后边; true:排在后边; false:排在前边
      objs - 参与排序的数组，数组的元素位置决定了对象的排序先后, 示例：int[] objs = new int[]{3, 2, 1, 4, 5,6};
      Returns:
      索引比较器

    • min

      public static <T extends Comparable<? super T>> T min(T t1, T t2)
      取两个值中的最小值，大小相同返回第一个值
      Type Parameters:
      T - 值类型
      Parameters:
      t1 - 第一个值
      t2 - 第二个值
      Returns:
      最小值

    • max

      public static <T extends Comparable<? super T>> T max(T t1, T t2)
      取两个值中的最大值，大小相同返回第一个值
      Type Parameters:
      T - 值类型
      Parameters:
      t1 - 第一个值
      t2 - 第二个值
      Returns:
      最大值

    • equals

      public static <T extends Comparable<? super T>> boolean equals(T c1, T c2)
      null安全的检查两个对象是否相同，通过调用compare(c1, c2) == 0完成
      Type Parameters:
      T - 被比较对象类型
      Parameters:
      c1 - 对象1，可以为null
      c2 - 对象2，可以为null
      Returns:
      是否相等
      See Also:

    • gt

      public static <T extends Comparable<? super T>> boolean gt(T c1, T c2)
      c1是否大于c2，通过调用compare(c1, c2) > 0完成
      Type Parameters:
      T - 被比较对象类型
      Parameters:
      c1 - 对象1，可以为null
      c2 - 对象2，可以为null
      Returns:
      c1是否大于c2
      See Also:

    • ge

      public static <T extends Comparable<? super T>> boolean ge(T c1, T c2)
      c1是否大于或等于c2，通过调用compare(c1, c2) >= 0完成
      Type Parameters:
      T - 被比较对象类型
      Parameters:
      c1 - 对象1，可以为null
      c2 - 对象2，可以为null
      Returns:
      c1是否大于或等于c2
      See Also:

    • lt

      public static <T extends Comparable<? super T>> boolean lt(T c1, T c2)
      c1是否大小于c2，通过调用compare(c1, c2) < 0完成
      Type Parameters:
      T - 被比较对象类型
      Parameters:
      c1 - 对象1，可以为null
      c2 - 对象2，可以为null
      Returns:
      c1是否小于c2
      See Also:

    • le

      public static <T extends Comparable<? super T>> boolean le(T c1, T c2)
      c1是否小于或等于c2，通过调用compare(c1, c2) <= 0完成
      Type Parameters:
      T - 被比较对象类型
      Parameters:
      c1 - 对象1，可以为null
      c2 - 对象2，可以为null
      Returns:
      c1是否小于或等于c2
      See Also:

    • isIn

      public static <T extends Comparable<? super T>> boolean isIn(T value, T c1, T c2)
      给定的value是否在c1和c2的范围内 即 min(c1,c2) <= value <= max(c1,c2)
      Type Parameters:
      T - 被比较对象类型
      Parameters:
      value - 检查的对象，可以为null
      c1 - 对象1，可以为null
      c2 - 对象2，可以为null
      Returns:
      给定的value是否在c1和c2的范围内

    • isInExclusive

      public static <T extends Comparable<? super T>> boolean isInExclusive(T value, T c1, T c2)
      给定的value是否在c1和c2的范围内，但是不包括边界 即 min(c1,c2) < value < max(c1,c2)
      Type Parameters:
      T - 被比较对象类型
      Parameters:
      value - 检查的对象，可以为null
      c1 - 对象1，可以为null
      c2 - 对象2，可以为null
      Returns:
      c1是否小于或等于c2
      See Also: