对象工具类 - ObjectUtil

简介

ObjectUtil 是 Hutool 提供的一个专门用于处理 Object 类型通用操作的工具类。它封装了一系列针对 Java 对象的常用方法，方便开发者在日常编程中进行对象的比较、克隆、序列化等操作，提高开发效率。

1. 默认值操作

ObjectUtil 提供了 defaultIfNull 方法，用于在对象为空时返回默认值或执行特定逻辑。

示例：判断对象是否为 null 并返回默认值

import cn.hutool.core.util.ObjectUtil;

import java.time.Instant;

public class ObjectUtilExample {
    public static void main(String[] args) {
        final String dateStr = null;

        // 判断 dateStr 是否为 null，如果为 null 则返回当前时间，否则解析日期字符串
        Instant result = ObjectUtil.defaultIfNull(
                dateStr,
                () -> Instant.now(), // 如果 dateStr 为 null，执行这个逻辑
                Instant.now()
        );

        System.out.println("结果: " + result);
    }
}

• defaultIfNull(T obj, Supplier<T> supplier, T defaultValue)：判断对象是否为 null，如果为 null，则执行 supplier 提供的逻辑，否则返回对象本身。

  • obj：要判断的对象。
  • supplier：在对象为 null 时执行的逻辑，返回默认值。
  • defaultValue：当 supplier 为 null 时，返回的默认值。
  • 返回值：原对象或默认值。

  作用： 用于在对象可能为 null 的情况下提供一个安全的默认值或处理逻辑。

  实际开发场景： 在处理配置参数、用户输入等可能为空的情况下，可以使用此方法提供默认行为。

2. 对象比较

ObjectUtil 提供了 equals 方法，用于比较两个对象是否相等。

示例：比较两个对象是否相等

import cn.hutool.core.util.ObjectUtil;

public class ObjectUtilExample {
    public static void main(String[] args) {
        Object a = null;
        Object b = null;

        // 比较两个对象是否相等
        boolean isEqual = ObjectUtil.equals(a, b);

        System.out.println("对象是否相等: " + isEqual);
    }
}

• equals(Object obj1, Object obj2)：比较两个对象是否相等。

  • obj1：第一个对象。
  • obj2：第二个对象。
  • 返回值：如果两个对象相等则返回 true，否则返回 false。

  作用： 用于判断两个对象是否相等，避免因 null 引发的 NullPointerException。

  实际开发场景： 在需要对两个对象进行比较操作时，可以使用此方法进行安全比较。

3. 计算对象长度

ObjectUtil 提供了 length 方法，用于计算对象的长度，支持多种类型的对象。

示例：计算数组、集合的长度

import cn.hutool.core.util.ObjectUtil;

import java.util.HashMap;
import java.util.Map;

public class ObjectUtilExample {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};
        Map<String, String> map = new HashMap<>();
        map.put("a", "a1");
        map.put("b", "b1");
        map.put("c", "c1");

        // 计算数组的长度
        int arrayLength = ObjectUtil.length(array);
        System.out.println("数组长度: " + arrayLength);

        // 计算 Map 的长度
        int mapLength = ObjectUtil.length(map);
        System.out.println("Map 长度: " + mapLength);
    }
}

• length(Object obj)：计算对象的长度。

  • obj：要计算长度的对象，可以是字符串、集合、数组等。
  • 返回值：对象的长度。

  作用： 计算各种类型对象的长度或大小，支持字符串、集合、数组等多种类型。

  实际开发场景： 在需要计算数据结构的元素数量时，可以使用此方法。

4. 判断对象是否包含元素

ObjectUtil 提供了 contains 方法，用于判断对象中是否包含指定元素。

示例：判断数组中是否包含某个元素

import cn.hutool.core.util.ObjectUtil;

public class ObjectUtilExample {
    public static void main(String[] args) {
        int[] array = {1, 2, 3, 4, 5};

        // 判断数组中是否包含元素 3
        boolean contains = ObjectUtil.contains(array, 3);
        System.out.println("数组是否包含 3: " + contains);
    }
}

• contains(Object obj, Object element)：判断对象中是否包含指定元素。

  • obj：要检查的对象，可以是字符串、集合、数组等。
  • element：要查找的元素。
  • 返回值：如果对象包含该元素，则返回 true，否则返回 false。

  作用： 判断对象中是否包含某个元素，适用于字符串、集合、数组等。

  实际开发场景： 在需要检查集合、数组或字符串中是否包含特定元素时，可以使用此方法。

5. 判断对象是否为 null

ObjectUtil 提供了 isNull 和 isNotNull 方法，用于判断对象是否为 null。

示例：判断对象是否为 null

import cn.hutool.core.util.ObjectUtil;

public class ObjectUtilExample {
    public static void main(String[] args) {
        Object obj = null;

        // 判断对象是否为 null
        boolean isNull = ObjectUtil.isNull(obj);
        System.out.println("对象是否为 null: " + isNull);

        // 判断对象是否不为 null
        boolean isNotNull = ObjectUtil.isNotNull(obj);
        System.out.println("对象是否不为 null: " + isNotNull);
    }
}

• isNull(Object obj)：判断对象是否为 null。

  • obj：要判断的对象。
  • 返回值：如果对象为 null，返回 true，否则返回 false。

• isNotNull(Object obj)：判断对象是否不为 null。

  • obj：要判断的对象。
  • 返回值：如果对象不为 null，返回 true，否则返回 false。

  作用： 检查对象是否为 null，便于在逻辑判断中避免 NullPointerException。

  实际开发场景： 在任何可能遇到 null 对象的情况下，使用这些方法进行安全的判断。

6. 对象克隆

ObjectUtil 提供了 clone、cloneIfPossible 和 cloneByStream 方法，用于对象的浅克隆和深克隆。

6.1 clone 方法

clone 方法用于克隆对象。如果对象实现了 Cloneable 接口，则调用其 clone 方法；如果对象实现了 Serializable 接口，则执行深度克隆。

示例：克隆对象

import cn.hutool.core.util.ObjectUtil;

public class ObjectUtilExample {
    public static void main(String[] args) {
        // 定义一个支持克隆的对象
        class Obj extends CloneSupport<Obj> {
            public String doSomething() {
                return "OK";
            }
        }

        Obj obj = new Obj();
        // 克隆对象
        Obj clonedObj = ObjectUtil.clone(obj);

        System.out.println("克隆对象的方法调用结果: " + clonedObj.doSomething());
    }
}

• clone(T obj)：克隆对象。

  • obj：要克隆的对象。
  • 返回值：克隆后的对象，若克隆失败返回 null。

  作用： 复制对象，便于在需要相同数据但不同对象实例时使用。

  实际开发场景： 在需要对对象进行复制时，例如复制复杂对象以避免对原对象的修改，可以使用此方法。

6.2 cloneIfPossible 方法

cloneIfPossible 方法用于克隆对象，如果克隆失败，则返回原对象。

示例：尝试克隆对象

import cn.hutool.core.util.ObjectUtil;

public class ObjectUtilExample {
    public static void main(String[] args) {
        String str = "Hutool";

        // 尝试克隆字符串对象，如果失败则返回原对象
        String clonedStr = ObjectUtil.cloneIfPossible(str);

        System.out.println("克隆结果: " + clonedStr);
    }
}

• cloneIfPossible(T obj)：尝试克隆对象，如果克隆失败，则返回原对象。

  • obj：要克隆的对象。
  • 返回值：克隆后的对象，若克隆失败则返回原对象。

  作用： 安全地尝试克隆对象，适用于对象克隆可能失败的场景。

  实际开发场景： 在某些情况下，需要对对象进行克隆操作，但不确定克隆是否会成功，可以使用此方法，以保证在克隆失败时仍然能够继续使用原对象。

6.3 cloneByStream 方法

cloneByStream 方法使用序列化的方式对对象进行深度克隆，适用于实现了 Serializable 接口的对象。

示例：使用序列化进行深度克隆

import cn.hutool.core.util.ObjectUtil;

import java.io.Serializable;

public class ObjectUtilExample {
    public static void main(String[] args) {
        // 定义一个可序列化的类
        class Person implements Serializable {
            private String name;
            private int age;

            public Person(String name, int age) {
                this.name = name;
                this.age = age;
            }

            @Override
            public String toString() {
                return "Person{name='" + name + "', age=" + age + "}";
            }
        }

        Person person = new Person("John", 30);

        // 使用序列化进行深度克隆
        Person clonedPerson = ObjectUtil.cloneByStream(person);

        System.out.println("原对象: " + person);
        System.out.println("克隆对象: " + clonedPerson);
    }
}

• cloneByStream(T obj)：通过序列化进行深度克隆。

  • obj：要克隆的对象，必须实现 Serializable 接口。
  • 返回值：克隆后的对象。

  作用： 对对象进行深度克隆，适用于复杂对象的复制需求。

  实际开发场景： 在需要复制复杂对象时，使用此方法可以确保所有嵌套的对象也被完整地复制。

7. 序列化和反序列化

ObjectUtil 提供了 serialize 和 deserialize 方法，用于对对象进行序列化和反序列化操作。

示例：对象的序列化与反序列化

import cn.hutool.core.util.ObjectUtil;

import java.io.Serializable;

public class ObjectUtilExample {
    public static void main(String[] args) {
        // 定义一个可序列化的类
        class Person implements Serializable {
            private String name;
            private int age;

            public Person(String name, int age) {
                this.name = name;
                this.age = age;
            }

            @Override
            public String toString() {
                return "Person{name='" + name + "', age=" + age + "}";
            }
        }

        Person person = new Person("John", 30);

        // 序列化对象
        byte[] serializedData = ObjectUtil.serialize(person);

        // 反序列化对象
        Person deserializedPerson = ObjectUtil.deserialize(serializedData);

        System.out.println("序列化后的数据: " + serializedData);
        System.out.println("反序列化后的对象: " + deserializedPerson);
    }
}

• serialize(T obj)：将对象序列化为字节数组。

  • obj：要序列化的对象，必须实现 Serializable 接口。
  • 返回值：对象的字节数组表示。

• deserialize(byte[] data)：将字节数组反序列化为对象。

  • data：对象的字节数组表示。
  • 返回值：反序列化后的对象。

  作用： 对象的序列化与反序列化，适用于对象的持久化存储和网络传输。

  实际开发场景： 在需要将对象存储为文件或通过网络传输对象数据时，可以使用这些方法。

8. 判断基本类型

ObjectUtil 提供了 isBasicType 方法，用于判断对象是否为基本类型（包括其包装类型）。

示例：判断对象是否为基本类型

import cn.hutool.core.util.ObjectUtil;

public class ObjectUtilExample {
    public static void main(String[] args) {
        int a = 1;
        Integer b = 2;

        // 判断 int 是否为基本类型
        boolean isBasicA = ObjectUtil.isBasicType(a);
        System.out.println("a 是否为基本类型: " + isBasicA);

        // 判断 Integer 是否为基本类型的包装类型
        boolean isBasicB = ObjectUtil.isBasicType(b);
        System.out.println("b 是否为基本类型的包装类型: " + isBasicB);
    }
}

• isBasicType(Object obj)：判断对象是否为基本类型或其包装类型。

  • obj：要判断的对象。
  • 返回值：如果对象是基本类型或其包装类型，返回 true，否则返回 false。

  作用： 检查对象是否属于基本数据类型，适用于需要区分基本类型和复杂类型的场景。

  实际开发场景： 在需要处理各种数据类型时，可以使用此方法快速判断数据类型的性质。

---

通过对这些常用功能的总结，ObjectUtil 工具类在处理对象的默认值、比较、克隆、序列化等方面提供了丰富且便捷的工具方法。它适用于各种场景，帮助开发者更高效地操作和处理 Java 对象，提高开发效率。