使用序列化和反序列化实现深拷贝（简单易懂，直接run!）

使用序列化和反序列化实现深拷贝

功能：利用序列化和反序列化实现深拷贝，直接上代码

1、示例1：深拷贝一个TreeMap<Integer,Object>对象的value，这个value是一个String类型的简单对象

package com.example;

import java.io.*;
import java.util.Map;
import java.util.TreeMap;

public class DeepCopyExample {
	// 深度拷贝工具方法不用改
	public static <T> T deepCopy(T object) throws IOException, ClassNotFoundException {
		ByteArrayOutputStream bos = new ByteArrayOutputStream();
		ObjectOutputStream oos = new ObjectOutputStream(bos);
		oos.writeObject(object);
		oos.flush();
		ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
		ObjectInputStream ois = new ObjectInputStream(bis);
		return (T) ois.readObject();
	}

	//只需要根据自己代码功能的不同需求修改
	public static void main(String[] args) {
		TreeMap<Integer, Object> a = new TreeMap<>();
		// 示例：填充数据
		a.put(1, new MySerializableClass("test"));
		
		TreeMap<Integer, Object> b = new TreeMap<>();
		try {
			for (Map.Entry<Integer, Object> entry : a.entrySet()) {
				// 键是Integer，不可变，直接使用；值深度拷贝
				Object copiedValue = deepCopy(entry.getValue());
				b.put(entry.getKey(), copiedValue);
			}
		} catch (IOException | ClassNotFoundException e) {
			e.printStackTrace();
		}
		
		// 测试：修改a中的对象，不影响b
		MySerializableClass objA = (MySerializableClass) a.get(1);
		objA.setName("modified");
		MySerializableClass objB = (MySerializableClass) b.get(1);
		objB.setName("test2");
		System.out.println(objB.getName()); // 输出"test"，未受影响
		System.out.println(objA.getName());
	}
}

package com.example;

import java.io.Serializable;// 示例类，需实现Serializable
public class MySerializableClass implements Serializable {
	private String name;
	public MySerializableClass(String name) { this.name = name; }
	public String getName() { return name; }
	public void setName(String name) { this.name = name; }
}

在上述示例代码中，根据不同功能需求修改的部分只有MySerializableClass中的序列化对象的类型，以及main函数中希望被深拷贝的对象以及最终生成的对象类型。

2、示例2：深拷贝一个TreeMap<Integer,Object>对象的value，这个value是一个HashMap<String,Object>类型的嵌套map复杂对象

package com.config;
import java.io.*;
import java.util.*;

/**
 * @author f
 * @date 2025/3/20
 * @Description
 */
public class testDeepCopy {

        // 深度拷贝工具方法不用改
        public static <T> T deepCopy(T object) throws IOException, ClassNotFoundException {
            ByteArrayOutputStream bos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(bos);
            oos.writeObject(object);
            oos.flush();
            ByteArrayInputStream bis = new ByteArrayInputStream(bos.toByteArray());
            ObjectInputStream ois = new ObjectInputStream(bis);
            return (T) ois.readObject();
        }

        public static void main(String[] args) {
			//定义一个被深拷贝的对象，并赋值
            TreeMap<Integer, Object> a = new TreeMap<>();
            HashMap<String, Object> content = new HashMap<String, Object>();
            content.put("id","abc");
            content.put("content","123");
            HashMap<String, Object> content2 = new HashMap<String, Object>();
            content2.put("id","def");
            content2.put("content","456");
            HashMap<String, Object> content3 = new HashMap<String, Object>();
            content3.put("id","hij");
            content3.put("content","789");
            a.put(1, new MySerializableClass(content));
            a.put(2, new MySerializableClass(content2));
            a.put(3, new MySerializableClass(content3));
            
            //定义一个每次取出a中一个对象的深拷贝内容后的存储对象b
            TreeMap<Integer, Object> b = new TreeMap<>();
			//定义一个取出a所有深拷贝内容后的存储对象c
            TreeMap<Integer, Object> c = new TreeMap<>();
            
            //循环对每一个a的map对象进行深拷贝
            for(int i = 0; i < a.size(); i++){
                try {
                    for (Map.Entry<Integer, Object> entry : a.entrySet()) {
                        // 键是Integer，不可变，直接使用；值深度拷贝
                        Object copiedValue = deepCopy(entry.getValue());
                        b.put(entry.getKey(), copiedValue);
                    }
                } catch (IOException | ClassNotFoundException e) {
                    e.printStackTrace();
                }

                MySerializableClass objA = (MySerializableClass) a.get(i+1);
                System.out.println(objA.getContent());

                MySerializableClass objB = (MySerializableClass) b.get(i+1);
                System.out.println(objB.getContent());
                
                // 获取 Map
                Map<String, Object> contentMap = objB.getContent();
                if (contentMap.containsKey("content")) {
                    contentMap.remove("content");
                    c.put(i+1,contentMap);
                }
				System.out.println(c);
               
            }
        }
}

上述代码的逻辑为：有一个被深拷贝的map对象a，它的value也是map对象，需要循环序列化和反序列化a的每一个map元素，赋值给map对象b，然后再将所有的对象b循环写入map对象c，最终c中的所有对象即为a中的所有对象深拷贝而来。