Java通过序列化实现深复制

    /**
     * 序列化实现深复制<br>
     * 被序列化的对象及其引用对象都必须实现{@link Serializable}接口
     *
     * @param clz 被反序列化的类型
     * @param t   被序列化的对象
     * @param <T> 实现{@link Serializable}接口的类
     * @return 复制后的对象
     */
    public static <T extends Serializable> T deepClone(Class<T> clz, T t) {
    
        return bytesToObject(clz,  objectToBytes(t));
    }


    /**
     * 对象序列化为二进制数组
     *
     * @param t   被序列化的对象
     * @param <T> 实现{@link Serializable}接口的类
     * @return 对象的二进制数组
     */
    public static <T extends Serializable> byte[] objectToBytes(T t) {

        byte[] bytes = null;

        try (ByteArrayOutputStream baos = new ByteArrayOutputStream();
             ObjectOutputStream oos = new ObjectOutputStream(baos)) {

            oos.writeObject(t);
            bytes = baos.toByteArray();

        } catch (IOException e) {
            e.printStackTrace();
        }
        return bytes;
    }

    /**
     * 二进制数组反序列化为对象
     *
     * @param clz   被反序列化的类型
     * @param bytes 二进制数组
     * @param <T>   实现{@link Serializable}接口的类
     * @return 被反序列化或得到的对象
     */
    public static <T extends Serializable> T bytesToObject(Class<T> clz,
                                                           byte[] bytes) {

        Object obj = null;

        try (ByteArrayInputStream bais = new ByteArrayInputStream(bytes);
             ObjectInputStream ois = new ObjectInputStream(bais)) {

            obj = ois.readObject();

        } catch (IOException | ClassNotFoundException e) {
            e.printStackTrace();
        }
        return clz.cast(obj);
    }

测试
getter/setter/构造器就不写了

public class Person implements Serializable {

    private String name;
    private int age;
    private String sex;
    private Address address;

public class Address implements Serializable {
	//邮编
    private int postcode;

    public static void main(String[] args) {

        Person person = new Person("xyz", 11, "男", new Address(100000));

        long start = System.nanoTime();
        //进行复制
        Person clone = deepClone(Person.class, person);
        long end = System.nanoTime();
        System.out.println((end - start) / 1000000.0 + "毫秒");

        System.out.println(person.getAddress().equals(clone.getAddress()));
        System.out.println(person.getAddress().getPostcode());
        System.out.println(clone.getAddress().getPostcode());
    }

结果:

51.800092毫秒
false
100000
100000