JAVA幾種方式實現深拷貝

準備

定義兩個類用於測試拷貝，類內容以下，目的是深拷貝一個User類的對象：

@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())));

    }


}

 

驗證結果

copyUser1:User(id=3, age=10, name=李四, car=Car(id=999, color=黑色, name=保時捷), category=工人)
copyUser1與user對象是不是同一個:false
copyUser1中的car與user中的car是不是同一個:false
====================
copyUser2:User(id=3, age=10, name=李四, car=Car(id=999, color=黑色, name=保時捷), category=工人)
copyUser2與user對象是不是同一個:false
copyUser2中的car與user中的car是不是同一個:false
====================
copyUser3:User(id=3, age=10, name=李四, car=Car(id=999, color=黑色, name=保時捷), category=工人)
copyUser3與user對象是不是同一個:false
copyUser3中的car與user中的car是不是同一個:false
====================
copyUser4:User(id=3, age=10, name=李四, car=Car(id=999, color=黑色, name=保時捷), category=工人)
copyUser4與user對象是不是同一個:false
copyUser4中的car與user中的car是不是同一個:false

結論

使用java原生推薦方法三，方法1、方法二缺點過於明顯，第三方庫的方式能夠用方法四，spring boot默認的序列化反序列化就是Jackson，另外比照方法四同類的類庫也能實現