Java中对象的序列化方式克隆详解

什么是对象的序列化？

在Java中，对象的序列化是指将Java对象转换为二进制流的过程。序列化可以将对象存储在文件或者在网络传输中进行传输，也可以通过反序列化将二进制流转换为Java对象。

Java中提供了java.io.Serializable接口，如果一个类实现了这个接口，则该类的对象可以被序列化。

Java中的序列化实现

Java中的序列化实现由系统提供，我们可以通过以下代码将一个Java对象序列化：

public static void serialize(Object obj, File file) throws IOException {
    try (ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file))) {
        oos.writeObject(obj);
    }
}

上面代码的serialize方法接收一个Java对象和一个文件路径作为参数，将该Java对象序列化并存储到指定路径下的文件中。

Java中的反序列化实现

Java中的反序列化实现也由系统提供，我们可以通过以下代码将一个二进制流反序列化为Java对象：

public static Object deserialize(File file) throws IOException, ClassNotFoundException {
    try (ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file))) {
        return ois.readObject();
    }
}

上面代码的deserialize方法接收一个存储了Java对象序列化结果的文件路径，并将其反序列化为Java对象。

对象的克隆

当我们需要复制一个Java对象时，我们可以使用对象的序列化和反序列化实现对象的克隆。

下面是一个示例，使用对象的序列化和反序列化实现对象的克隆：

public static Object clone(Object obj) throws IOException, ClassNotFoundException {
    //将对象序列化到byte[]数组中
    ByteArrayOutputStream bos = new ByteArrayOutputStream();
    try (ObjectOutputStream oos = new ObjectOutputStream(bos)) {
        oos.writeObject(obj);
    }
    //将byte[]数组反序列化为对象
    ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
    try (ObjectInputStream ois = new ObjectInputStream(bis)) {
        return ois.readObject();
    }
}

示例1

下面是一个示例，将一个Java对象序列化并存储在文件中，然后再将文件中的二进制流反序列化为Java对象：

public static void main(String[] args) throws IOException, ClassNotFoundException {
    Person person = new Person("小明", 18);
    File file = new File("person.ser");
    //将对象序列化到文件中
    serialize(person, file);
    //将文件中的二进制流反序列化为Java对象
    Person clonePerson = (Person) deserialize(file);
    //打印克隆的对象
    System.out.println(clonePerson);
}

static 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{name='小明', age=18}

示例2

下面是另一个示例，将一个Java对象序列化并存储在文件中，然后再通过对象的克隆实现对象的深度复制：

public static void main(String[] args) throws IOException, ClassNotFoundException {
    Address address = new Address("中国", "北京", "朝阳区");
    Person person = new Person("小明", 18, address);
    File file = new File("person.ser");
    //将对象序列化到文件中
    serialize(person, file);
    //深度复制
    Person clonePerson = (Person) clone(person);
    clonePerson.getAddress().setCity("上海");
    //打印克隆的对象和原对象的地址信息，验证是否实现了深度复制
    System.out.println(person.getAddress().getCity());
    System.out.println(clonePerson.getAddress().getCity());
}

static class Person implements Serializable {
    private String name;
    private int age;
    private Address address;

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

    public Address getAddress() {
        return address;
    }

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

static class Address implements Serializable {
    private String country;
    private String city;
    private String district;

    public Address(String country, String city, String district) {
        this.country = country;
        this.city = city;
        this.district = district;
    }

    public String getCity() {
        return city;
    }

    public void setCity(String city) {
        this.city = city;
    }

    @Override
    public String toString() {
        return "Address{" +
                "country='" + country + '\'' +
                ", city='" + city + '\'' +
                ", district='" + district + '\'' +
                '}';
    }
}

运行以上代码，输出结果为：

朝阳区
上海

从输出结果可以看到，对象的克隆实现了深度复制，克隆对象和原对象地址信息已经不同。