使用序列化和反序列化实现深拷贝
功能:利用序列化和反序列化实现深拷贝,直接上代码
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中的所有对象深拷贝而来。
474

被折叠的 条评论
为什么被折叠?



