JAVA实现深拷贝的几种方式代码

@Data
@Accessors(chain = true)
public class User {
    private Integer id;
    private Integer age;
    private String name;
    private Car car;
    private String category;
}

@Data
@Accessors(chain = true)
public class Car {
    private Integer id;
    private String color;
    private String name;
} 

package com.demo;
import com.fasterxml.jackson.core.JsonProcessingException;
import com.fasterxml.jackson.databind.ObjectMapper;
import lombok.Data;
import lombok.experimental.Accessors;
import java.io.*;
@Data
@Accessors(chain = true)
public class User implements Cloneable, Serializable {
    private Integer id;
    private Integer age;
    private String name;
    private Car car;
    private String category;
    @Override
    public User clone() throws CloneNotSupportedException {
        return (User) super.clone();
    }
    /**
     * 方法一：最原始的实现方式，通过构造方法手创建
     * 优点：
     * 1.实现简单直观
     * 2.不需要依赖额外的接口和第三方包
     * 缺点：
     * 1.成员变量发生变动需要修改方法，不满足开闭原则；
     * 2.不具有可复用性；
     */
    public User copyUser1() {
        User copyUser = new User()
                .setId(this.getId())
                .setName(this.getName())
                .setAge(this.getAge())
                .setCategory(this.getCategory());
        if (this.getCar() != null) {
            copyUser.setCar(new Car().setId(this.getCar().getId())
                    .setColor(this.getCar().getColor())
                    .setName(this.getCar().getName()));
        }
        return copyUser;
    }
    /**
     * 方法二：使用Object的clone方法实现
     * 优点：
     * 1.较方式1实现更简单，不需要关注copy细节；
     * 2.不需要依赖第三方包；
     * 3.不修改引用类型成员变量不需要修改代码
     * 缺点：
     * 1.需要实现Cloneable，重写父类clone方法，不满足里式替换；
     * 2.且引用类型成员变量发生变动需要修改方法，不满足开闭原则；
     * 3.不具有可复用性；
     */
    public User copyUser2() throws CloneNotSupportedException {
        User cloneUser = this.clone();
        if(this.getCar() != null) {
            cloneUser.setCar(this.getCar().clone());
        }
        return cloneUser;
    }
    /**
     * 方法三：使用Java自带的流方式实现
     * 优点：
     * 1.不破坏类的封装，无需了解被copy对象的内部
     * 2.不需要依赖第三方包
     * 3.代码可复用
     * 缺点：
     * 1.需要实现Serializable接口，会有额外的开销
     */
    public User copyUser3() throws IOException, ClassNotFoundException {
        ByteArrayOutputStream bos = new ByteArrayOutputStream();
        ObjectOutputStream oos = new ObjectOutputStream(bos);
        oos.writeObject(this);
        ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
        ObjectInputStream ois = new ObjectInputStream(bis);
        return (User) ois.readObject();
    }
    /**
     * 方法四：使用第三方包Jackson实现
     * 优点：
     * 1.不破坏类的封装，无需了解被copy对象的内部
     * 2.不需要实现接口
     * 3.代码可复用
     * 缺点：
     * 1.需要依赖第三方包
     * 2.内部实现复杂
     */
    public User copyUser4() throws JsonProcessingException {
        ObjectMapper objectMapper = new ObjectMapper();
        return objectMapper.readValue(objectMapper.writeValueAsString(this),User.class);
    }
} 

package com.demo;
import java.io.IOException;
public class CopyDemo {
    public static void main(String[] args) throws IOException, CloneNotSupportedException, ClassNotFoundException {
        User user = new User().setAge(10).setName("李四").setId(3).setCategory("工人");
        user.setCar(new Car().setName("保时捷").setId(999).setColor("黑色"));
        User copyUser1 = user.copyUser1();
        System.out.println("copyUser1:" + copyUser1);
        System.out.println("copyUser1与user对象是否是同一个:" + (System.identityHashCode(user) == System.identityHashCode(copyUser1)));
        System.out.println("copyUser1中的car与user中的car是否是同一个:"+(System.identityHashCode(user.getCar()) == System.identityHashCode(copyUser1.getCar())));
        System.out.println("====================");
        User copyUser2 = user.copyUser2();
        System.out.println("copyUser2:" + copyUser2);
        System.out.println("copyUser2与user对象是否是同一个:" + (System.identityHashCode(user) == System.identityHashCode(copyUser2)));
        System.out.println("copyUser2中的car与user中的car是否是同一个:"+(System.identityHashCode(user.getCar()) == System.identityHashCode(copyUser2.getCar())));
        System.out.println("====================");
        User copyUser3 = user.copyUser3();
        System.out.println("copyUser3:" + copyUser3);
        System.out.println("copyUser3与user对象是否是同一个:" + (System.identityHashCode(user) == System.identityHashCode(copyUser3)));
        System.out.println("copyUser3中的car与user中的car是否是同一个:"+(System.identityHashCode(user.getCar()) == System.identityHashCode(copyUser3.getCar())));
        System.out.println("====================");
        User copyUser4 = user.copyUser4();
        System.out.println("copyUser4:" + copyUser4);
        System.out.println("copyUser4与user对象是否是同一个:" + (System.identityHashCode(user) == System.identityHashCode(copyUser4)));
        System.out.println("copyUser4中的car与user中的car是否是同一个:"+(System.identityHashCode(user.getCar()) == System.identityHashCode(copyUser4.getCar())));
    }
}