如果两个对象引用指向同一个可序列化的对象，则在Java的序列化过程中会发生什么？

Question

如果两个对象引用指向同一个可序列化的对象，则在Java的序列化过程中会发生什么？ 可序列化对象是否保存两次？
例如 ：

    class King implements java.io.Serializable {
        private String name="Akbar";
    }

    class Kingdom implements java.io.Serializable {
        King goodKing=new King();
        King badKing=goodKing;
    }

    public class TestSerialization {
        public static void serializeObject(String outputFileName,
                                           Object serializableObject) throws IOException {
            FileOutputStream fileStream=new FileOutputStream(outputFileName);
            ObjectOutputStream outStream=new ObjectOutputStream(fileStream);
            outStream.writeObject(serializableObject);
            outStream.close();
        }

        public static void main(String[] args) {
            Kingdom kingdom=new Kingdom();
            try {
                TestSerialization.serializeObject("Kingdom1.out", kingdom);
            }catch(IOException ex) {
                ex.getMessage();
            }
        }
    }

现在，是否只为 GoodKing 和 BadKing引用 保存了一个对象状态，还是将King对象保存了两次？

Answer 1

文档ObjectOutputStream说明发生了什么：

对象的默认序列化机制将写入对象的类，类签名以及所有非瞬态和非静态字段的值。对其他对象的引用（在瞬态或静态字段中除外）也导致这些对象也被写入。
使用引用共享机制对单个对象的多个引用进行编码，以便可以将对象的图恢复为与编写原始图时相同的形状。

（我的重点）

例如，如果您对单个对象有多个引用，则在重构图形时，最终会获得对该对象的单个重构版本的多个引用，而不是对该对象的多个等效实例的引用。

当然，如果要序列化的容器实现了另一种机制，则该行为由该机制决定，而不是默认机制。

例如，如果我们有Thing和Test：

Thing.java：

import java.io.*;
import java.util.*;

public class Thing implements Serializable {
    private Map<String,String> map1;
    private Map<String,String> map2;

    public Thing() {
        this.map1 = new HashMap();
        this.map2 = this.map1; // Referring to same object
    }

    public void put(String key, String value) {
        this.map1.put(key, value);
    }

    public boolean mapsAreSameObject() {
        return this.map1 == this.map2;
    }
}

Test.java：

import java.io.*;

public class Test implements Serializable {

    public static final void main(String[] args) {
        try
        {
            // Create a Thing
            Thing t = new Thing();
            t.put("foo", "bar");

            // Write it out
            ObjectOutputStream os = new ObjectOutputStream(new FileOutputStream("foo"));
            os.writeObject(t);
            os.close();
            os = null;

            // Read it in
            Thing t2;
            ObjectInputStream is = new ObjectInputStream(new FileInputStream("foo"));
            t2 = (Thing)is.readObject();
            is.close();
            is = null;

            // Same underlying map for both properties?
            System.out.println("t2.mapsAreSameObject? " + t2.mapsAreSameObject());
        }
        catch (Exception e)
        {
            System.out.println("Exception: " + e.getMessage());
        }
    }
}

运行java Test，我们得到：

t2.mapsAreSameObject？真正

......因为两者Thing的成员，map1并map2最终指向一个HashMap实例。