Java序列化/反序列化对象重复问题求助

问题原因 #

Java默认的对象序列化机制会在同一个序列化流中维护对象引用的唯一性：第一次写入对象时会保存完整数据并分配唯一ID，后续写入同一对象时仅写入ID；反序列化时也会根据ID复用实例。你的场景中出现重复实例，大概率是因为：

• 多个数据结构（两棵BST、优先级队列）被分开序列化（比如调用多次save方法分别保存），每个流都会将Node视为新对象重新序列化
• 顶层序列化对象没有包含所有共享Node的结构，导致对象引用链断裂

解决方案 #

方案1：统一序列化顶层容器对象 #

将所有依赖共享Node的结构封装到一个顶层容器类中，只做一次序列化/反序列化操作，让JVM自动维护对象引用的唯一性。

1. 创建顶层容器类：

import java.io.Serializable;
import java.util.PriorityQueue;

public class NodeDataStore implements Serializable {
    private BSTStructure bst1;
    private BSTStructure bst2;
    private PriorityQueue<Node> priorityQueue;

    // 构造器
    public NodeDataStore(BSTStructure bst1, BSTStructure bst2, PriorityQueue<Node> priorityQueue) {
        this.bst1 = bst1;
        this.bst2 = bst2;
        this.priorityQueue = priorityQueue;
    }

    // Getter方法
    public BSTStructure getBst1() { return bst1; }
    public BSTStructure getBst2() { return bst2; }
    public PriorityQueue<Node> getPriorityQueue() { return priorityQueue; }
}

2. 修改保存/加载逻辑，只操作这个容器对象：

public NodeDataStore load() {
    NodeDataStore dataStore = null;
    try {
        File file = new File("data_store.ser");
        // 如果文件不存在则创建空容器
        if (!file.exists()) {
            return new NodeDataStore(new BSTStructure(), new BSTStructure(), new PriorityQueue<>());
        }
        try (FileInputStream fileInput = new FileInputStream(file);
             ObjectInputStream in = new ObjectInputStream(fileInput)) {
            dataStore = (NodeDataStore) in.readObject();
        }
    } catch (FileNotFoundException e) {
        System.out.println("数据文件未找到");
    } catch (ClassNotFoundException e) {
        System.out.println("找不到对应类");
    } catch (EOFException e) {
        System.out.println("文件为空，创建新容器");
        dataStore = new NodeDataStore(new BSTStructure(), new BSTStructure(), new PriorityQueue<>());
    } catch (Exception e) {
        e.printStackTrace();
    }
    return dataStore;
}

public void save(NodeDataStore dataStore) {
    try (FileOutputStream file = new FileOutputStream("data_store.ser");
         ObjectOutputStream out = new ObjectOutputStream(file)) {
        out.writeObject(dataStore);
    } catch (IOException e) {
        e.printStackTrace();
    }
}

方案2：自定义序列化，手动维护对象引用 #

如果必须分开序列化各个结构，可以给Node添加唯一标识，反序列化时通过Map复用实例：

1. 修改Node类，添加唯一ID：

import java.io.Serializable;
import java.util.UUID;

public class Node implements Serializable {
    private final String nodeId;
    // 原有字段：左右指针、其他业务数据
    private Node left1; // 第一棵BST的左指针
    private Node right1; // 第一棵BST的右指针
    private Node left2; // 第二棵BST的左指针
    private Node right2; // 第二棵BST的右指针
    // 其他字段...

    public Node() {
        this.nodeId = UUID.randomUUID().toString();
    }

    // Getter方法
    public String getNodeId() { return nodeId; }
    // 其他getter/setter...
}

2. 反序列化时先加载所有Node到Map，再重建结构：

// 先加载所有Node的映射（比如单独保存一个Node列表）
private Map<String, Node> loadNodeMap() {
    Map<String, Node> nodeMap = new HashMap<>();
    // 从文件加载Node列表并放入map，确保每个Node只实例化一次
    // 省略具体实现
    return nodeMap;
}

// 重建BST时，通过nodeId获取已实例化的Node
private BSTStructure rebuildBST(List<NodeSerializedData> bstData, Map<String, Node> nodeMap) {
    BSTStructure bst = new BSTStructure();
    // 遍历序列化的BST数据，用nodeMap中的Node实例重建树结构
    // 省略具体实现
    return bst;
}

注意事项 #

• 确保Node类及其所有引用的字段都正确实现Serializable接口
• 避免在Node类中自定义readObject/writeObject方法时破坏引用共享，除非明确知道如何维护对象ID
• 原代码中的笔误需修正：BSTSTructre应为BSTStructure，load方法结尾返回的moviesByID应改为bstStructure

内容的提问来源于stack exchange，提问作者dgezgin