ObjectKit (bus-core 6.0.2 API)

java.lang.Object
- org.aoju.bus.core.toolkit.ObjectKit

```
public class ObjectKit
extends Object
```
一些通用的函数

Since:

JDK 1.8+

Version:

6.0.2

Author:

Kimi Liu

Constructor Summary

Constructors
Constructor and Description

ObjectKit()

Constructors
Constructor and Description
`ObjectKit()`

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static <T> void`	`cleanInitValue(T bean)` 清空对象中所有属性的初始值
`static <T> T`	`clone(T obj)` 克隆对象如果对象实现Cloneable接口,调用其clone方法如果实现Serializable接口,执行深度克隆否则返回null
`static <T> T`	`cloneByStream(T obj)` 序列化后拷贝流的方式克隆对象必须实现Serializable接口
`static <T> T`	`CloneObject(Class<T> clazz, Object bean)` 克隆有序列化的对象
`static <T> T`	`CloneObject(T bean)` 克隆有序列化的对象
`static int`	`compare(String v1, String v2, boolean complete)` 比较2个版本号
`static <T extends Comparable<? super T>> int`	`compare(T c1, T c2)` `null`安全的对象比较，`null`对象小于任何对象
`static <T> int`	`compare(T o1, T o2, boolean isNullGreater)` 自然比较两个对象的大小，比较规则如下：
`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接口) 一般而言，如果c1 < c2，返回数小于0，c1==c2返回0，c1 > c2 大于0
`static boolean`	`contains(Object obj, Object element)` 对象中是否包含元素
`static <T extends CharSequence> T`	`defaultIfBlank(T str, T defaultValue)` 如果给定对象为`null`或者""或者空白符返回默认值
`static <T extends CharSequence> T`	`defaultIfEmpty(T str, T defaultValue)` 如果给定对象为`null`或者 "" 返回默认值
`static <T> T`	`defaultIfNull(T object, T defaultValue)` 如果给定对象为`null`返回默认值
`static <T> T`	`deserialize(byte[] bytes)` byte反序列化对象必须实现Serializable接口
`static boolean`	`equal(byte[] byte1, byte[] byte2)` 比较两个摘要是否相等
`static boolean`	`equal(Object obj1, Object obj2)` 比较两个对象是否相等
`static Field[]`	`getAllFields(Object object)` 获取包括父类所有的属性
`static Object`	`getAttributeValue(Object obj, 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 void`	`identityToString(Appendable appendable, Object object)` 如果类没有覆盖toString本身，则附加由`Object`生成的toString.
`static String`	`identityToString(Object object)` 获取如果类没有覆盖toString本身，则`Object`将生成的toString.
`static void`	`identityToString(StrBuilder builder, 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 <T> T`	`initObject(Class<T> clazz, Map<String,Object> attrMap)` 初始化对象
`static void`	`insertObj(Object baseData, Object newData)` 将新数据的非空属性值插入到基本数据中
`static boolean`	`isArray(Object object)` 确定给定的对象是一个数组:对象数组还是基元数组
`static boolean`	`isBaseClass(Object value)` 校验是否是九种基础类型(即：非用户定义的类型)
`static boolean`	`isEmpty(Object... object)` 判断对象是否Empty(null或元素为0) 实用于对如下对象做判断:String Collection及其子类 Map及其子类
`static boolean`	`isEmpty(Object object)` 判断指定对象是否为空，支持：
`static boolean`	`isFalse(Boolean object)` 判断对象为false
`static boolean`	`isNotEmpty(Object... object)` 判断对象是否为NotEmpty(!null或元素大于0) 实用于对如下对象做判断:String Collection及其子类 Map及其子类
`static boolean`	`isNotEmpty(Object object)` 判断对象是否为NotEmpty(!null或元素大于0) 实用于对如下对象做判断:String Collection及其子类 Map及其子类
`static boolean`	`isNotNull(Object obj)` 检查对象是否不为null
`static boolean`	`isNull(Object obj)` 检查对象是否为null
`static boolean`	`isTrue(Boolean object)` 判断对象为true
`static boolean`	`isValidIfNumber(Object obj)` 检查是否为有效的数字检查Double和Float是否为无限大,或者Not a Number 非数字类型和Null将返回true
`static int`	`length(Object obj)` 计算对象长度,如果是字符串调用其length函数, 集合类调用其size函数, 数组调用其length属性, 其他可遍历对象遍历计算长度
`static boolean`	`notEqual(Object obj1, Object obj2)` 比较两个对象是否不相等
`static boolean`	`nullSafeEquals(Object o1, Object o2)` 确定给定的对象是否相等，如果两个对象都是`null`，则返回`true`;如果只有一个对象是`null`，则返回`false`
`static <T> T`	`parseByteForObj(byte[] bts)` 将byte字节转换成对象
`static byte[]`	`parseObjForByte(Object obj)` 将对象转换为byte数据
`static <T> T`	`parseToObject(Object value, Class<T> type)` 转换类型
`static <T> byte[]`	`serialize(T obj)` 对象序列化对象必须实现Serializable接口
`static void`	`setAttribute(Object obj, String attrName, Object value)` 给对象的属性赋值
`static byte[]`	`toByte(Object obj)` 将对象进行序列化
`static <T> T`	`toObject(byte[] bts)` 将序列化数据转换为对象
`static <T> T`	`toObject(String base64)` 将base64的序列化数据转换为对象
`static Object[]`	`toObjectArray(Object source)` 将给定的数组(可能是原始数组)转换为对象数组(如果需要原始包装器对象) 一个`null`源值将被转换为一个空的对象数组.
`static String`	`toString(Object obj)` 将Object转为String 策略为：

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Constructor Detail
  - ObjectKit
```
public ObjectKit()
```
- Method Detail
  - isNull
```
public static boolean isNull(Object obj)
```
    检查对象是否为null
    
    Parameters:
    
    obj - 对象
    
    Returns:
    
    是否为null
  - isNotNull
```
public static boolean isNotNull(Object obj)
```
    检查对象是否不为null
    
    Parameters:
    
    obj - 对象
    
    Returns:
    
    是否为null
  - defaultIfNull
```
public static <T> T defaultIfNull(T object,
                                  T defaultValue)
```
    如果给定对象为null返回默认值
    
    Type Parameters:
    
    T - 对象类型
    
    Parameters:
    
    object - 被检查对象,可能为null
    
    defaultValue - 被检查对象为null返回的默认值,可以为null
    
    Returns:
    
    被检查对象为{ null}返回默认值,否则返回原值
  - defaultIfEmpty
```
public static <T extends CharSequence> T defaultIfEmpty(T str,
                                                        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:
    
    str - 被检查对象，可能为null
    
    defaultValue - 被检查对象为null或者 ""返回的默认值，可以为null或者 ""
    
    Returns:
    
    被检查对象为null或者 ""返回默认值，否则返回原值
  - defaultIfBlank
```
public static <T extends CharSequence> T defaultIfBlank(T str,
                                                        T defaultValue)
```
    如果给定对象为null或者""或者空白符返回默认值
```
 ObjectKit.defaultIfEmpty(null, null)      = null
 ObjectKit.defaultIfEmpty(null, "")        = ""
 ObjectKit.defaultIfEmpty("", "zz")        = "zz"
 ObjectKit.defaultIfEmpty(" ", "zz")       = "zz"
 ObjectKit.defaultIfEmpty("abc", *)        = "abc"
 
```
    Type Parameters:
    
    T - 对象类型(必须实现CharSequence接口)
    
    Parameters:
    
    str - 被检查对象，可能为null
    
    defaultValue - 被检查对象为null或者 ""或者空白符返回的默认值，可以为null或者 ""或者空白符
    
    Returns:
    
    被检查对象为null或者 ""或者空白符返回默认值，否则返回原值
  - 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
  - isEmpty
```
public static final boolean isEmpty(Object... object)
```
    判断对象是否Empty(null或元素为0) 实用于对如下对象做判断:String Collection及其子类 Map及其子类
    
    Parameters:
    
    object - 待检查对象
    
    Returns:
    
    boolean 返回的布尔值
  - isNotEmpty
```
public static final boolean isNotEmpty(Object object)
```
    判断对象是否为NotEmpty(!null或元素大于0) 实用于对如下对象做判断:String Collection及其子类 Map及其子类
    
    Parameters:
    
    object - 待检查对象
    
    Returns:
    
    boolean 返回的布尔值
  - isNotEmpty
```
public static final boolean isNotEmpty(Object... object)
```
    判断对象是否为NotEmpty(!null或元素大于0) 实用于对如下对象做判断:String Collection及其子类 Map及其子类
    
    Parameters:
    
    object - 待检查对象
    
    Returns:
    
    boolean 返回的布尔值
  - isValidIfNumber
```
public static boolean isValidIfNumber(Object obj)
```
    检查是否为有效的数字检查Double和Float是否为无限大,或者Not a Number 非数字类型和Null将返回true
    
    Parameters:
    
    obj - 被检查类型
    
    Returns:
    
    检查结果, 非数字类型和Null将返回true
  - equal
```
public static boolean equal(Object obj1,
                            Object obj2)
```
    比较两个对象是否相等
    
    Parameters:
    
    obj1 - 对象1
    
    obj2 - 对象2
    
    Returns:
    
    是否相等
  - equal
```
public static boolean equal(byte[] byte1,
                            byte[] byte2)
```
    比较两个摘要是否相等
    
    Parameters:
    
    byte1 - 字节比较信息1
    
    byte2 - 字节比较信息2
    
    Returns:
    
    如果相等，则为true，否则为false
  - notEqual
```
public static boolean notEqual(Object obj1,
                               Object obj2)
```
    比较两个对象是否不相等
    
    Parameters:
    
    obj1 - 对象1
    
    obj2 - 对象2
    
    Returns:
    
    是否不等
  - length
```
public static int length(Object obj)
```
    计算对象长度,如果是字符串调用其length函数, 集合类调用其size函数, 数组调用其length属性, 其他可遍历对象遍历计算长度
    
    Parameters:
    
    obj - 被计算长度的对象
    
    Returns:
    
    长度
  - contains
```
public static boolean contains(Object obj,
                               Object element)
```
    对象中是否包含元素
    
    Parameters:
    
    obj - 对象
    
    element - 元素
    
    Returns:
    
    是否包含
  - clone
```
public static <T> T clone(T obj)
```
    克隆对象如果对象实现Cloneable接口,调用其clone方法如果实现Serializable接口,执行深度克隆否则返回null
    
    Type Parameters:
    
    T - 对象类型
    
    Parameters:
    
    obj - 被克隆对象
    
    Returns:
    
    克隆后的对象
  - toString
```
public static String toString(Object obj)
```
    将Object转为String 策略为：
```
  1、null转为"null"
  2、调用Convert.toStr(Object)转换
 
```
    Parameters:
    
    obj - Bean对象
    
    Returns:
    
    Bean所有字段转为Map后的字符串
  - cloneByStream
```
public static <T> T cloneByStream(T obj)
```
    序列化后拷贝流的方式克隆对象必须实现Serializable接口
    
    Type Parameters:
    
    T - 对象类型
    
    Parameters:
    
    obj - 被克隆对象
    
    Returns:
    
    克隆后的对象
    
    Throws:
    
    InstrumentException - IO异常和ClassNotFoundException封装
  - 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:
    
    Comparator.compare(Object, Object)
  - compare
```
public static int compare(String v1,
                          String v2,
                          boolean complete)
```
    比较2个版本号
    
    Parameters:
    
    v1 - 版本1
    
    v2 - 版本2
    
    complete - 是否完整的比较两个版本
    
    Returns:
    
    (v1 小于 v2) ? -1 : ((v1 等于 v2) ? 0 : 1)
  - 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:
    
    Comparator.compare(Object, Object)
  - 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:
    
    Comparator.compare(Object, Object)
  - 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
  - getAllFields
```
public static Field[] getAllFields(Object object)
```
    获取包括父类所有的属性
    
    Parameters:
    
    object - 对象
    
    Returns:
    
    the field
  - toByte
```
public static byte[] toByte(Object obj)
```
    将对象进行序列化
    
    Parameters:
    
    obj - 对象
    
    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 obj,
                                String attrName,
                                Object value)
```
    给对象的属性赋值
    
    Parameters:
    
    obj - 对象
    
    attrName - 对象的属性名
    
    value - 对象的属性值
  - getAttributeValue
```
public static Object getAttributeValue(Object obj,
                                       String attrName)
```
    从对象中取值
    
    Parameters:
    
    obj - 对象
    
    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:
    
    泛型类型
  - parseByteForObj
```
public static <T> T parseByteForObj(byte[] bts)
```
    将byte字节转换成对象
    
    Type Parameters:
    
    T - 对象
    
    Parameters:
    
    bts - 字节数据
    
    Returns:
    
    对象
  - parseObjForByte
```
public static byte[] parseObjForByte(Object obj)
```
    将对象转换为byte数据
    
    Parameters:
    
    obj - 对象
    
    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:
    
    克隆后的对象
  - insertObj
```
public static void insertObj(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(StrBuilder 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:
    
    Object.equals(Object), Arrays.equals(long[], long[])
  - toObjectArray
```
public static Object[] toObjectArray(Object source)
```
    将给定的数组(可能是原始数组)转换为对象数组(如果需要原始包装器对象) 一个null源值将被转换为一个空的对象数组.
    
    Parameters:
    
    source - 数组
    
    Returns:
    
    对应的对象数组
  - serialize
```
public static <T> byte[] serialize(T obj)
```
    对象序列化对象必须实现Serializable接口
    
    Type Parameters:
    
    T - 对象类型
    
    Parameters:
    
    obj - 要被序列化的对象
    
    Returns:
    
    序列化后的字节码
  - deserialize
```
public static <T> T deserialize(byte[] bytes)
```
    byte反序列化对象必须实现Serializable接口
    
    Type Parameters:
    
    T - 对象类型
    
    Parameters:
    
    bytes - 反序列化的字节码
    
    Returns:
    
    反序列化后的对象

Class ObjectKit

Constructor Summary

Method Summary

Methods inherited from class java.lang.Object

Constructor Detail

ObjectKit

Method Detail

isNull

isNotNull

defaultIfNull

defaultIfEmpty

defaultIfBlank

isTrue

isFalse

isArray

isEmpty

isEmpty

isNotEmpty

isNotEmpty

isValidIfNumber

equal

equal

notEqual

length

contains

clone

toString

cloneByStream

compare

compare

compare

compare

compare

getAllFields

toByte

toObject

toObject

getClassByName

initObject

setAttribute

getAttributeValue

getFields

getFieldNames

getNotNullFields

getNotNullFields

getNotNullFieldsParam

getNotNullFieldsParam

getNotNullFieldsForStructure

getGeneric

parseByteForObj

parseObjForByte

parseToObject

isBaseClass

CloneObject

CloneObject

insertObj

cleanInitValue

identityToString

identityToString

identityToString

identityToString

identityToString

nullSafeEquals

toObjectArray

serialize

deserialize