对象序列化 --《JAVA编程思想》85

最新推荐文章于 2024-11-13 23:54:12 发布

原创最新推荐文章于 2024-11-13 23:54:12 发布 · 252 阅读

0 ·

CC 4.0 BY-SA版权

文章标签：

#java #开发语言 #后端 #IO #序列化

JAVA编程思想专栏收录该内容

90 篇文章

订阅专栏

本文介绍了Java对象序列化的过程，通过实现Serializable接口将对象持久化保存到文件或字节数组中。示例展示了如何创建Worm对象及其内部Data数组和引用的序列化和反序列化，强调了序列化不仅保存对象基本信息，还保存引用的对象网络。文章最后通过文件流和字节数组流进行了序列化和反序列化的演示。

当创建对象时，只要你需要，它就会一直存在，但当程序终止时，创建的对象也会不复存在。

假设我们想在程序不运行的情况下，也能保存对象的信息，这时可以通过 JAVA 的对象序列化将对象进行持久化保存（虽然可以通过写入文件或者数据库达到相同的效果，但任何实现方式都有适合它自己的场景，技多不压身）。

序列化的对象必须实现 Serializable 接口，它会转换成字节序列，并能够将这个字节序列完全恢复为原来的对象，这一过程可以通过网络运行，能弥补不同操作系统之间的差异，即在 windows 系统创建的对象进行序列化后，发送至 unix 机器进行反序列化还原出原本的对象。

要序列化一个对象，要创建 OutputStream 对象，然后调用 writeObject(Object obj) 即可将对象序列化；要反序列化，则需要通过创建 ObjectInputStream ，调用 readObject() ，会返回一个 Object 的引用，我们需要将其强制向下转型才能正常使用，需要注意的时，写入对象的顺序和读取的顺序需保持一致。

序列化不仅仅保存了对象自身的基本信息，还保存了每个引用，每个引用对象中的引用也同样被保存下来，依次类推，最终形成了整个“对象网”。

下面我们通过一个例子，来巩固序列化的基础知识点，创建一个 Worm 对象，它包含了一个 Data 类型的数组，还有一个指向下一个 Worm 对象的引用。

public class Data implements Serializable {

    private int n;

    public Data(int n) {
        this.n = n;
    }

    @Override
    public String toString() {
        return Integer.toString(n);
    }

}

public class Worm implements Serializable {

    private static Random rand = new Random(47);

    private Data[] d = {
            new Data(rand.nextInt(10)),
            new Data(rand.nextInt(10)),
            new Data(rand.nextInt(10))
    };

    //下一个Worm的引用
    private Worm next;

    private char c;

    /**
     * @param i 构造Worm的长度
     * @param c 存储的字符
     */
    public Worm(int i, char c) {
        System.out.println("Worm construction: " + i);
        this.c = c;
        //下一个构造的Worm长度-1,字符+1
        if (--i > 0) {
            next = new Worm(i, (char) (c + 1));
        }
    }


    @Override
    public String toString() {
        StringBuilder result = new StringBuilder(":");
        result.append(c);
        result.append("(");
        for (Data data : d) {
            result.append(data);
        }
        result.append(")");
        if (next != null) {
            result.append(next);
        }
        return result.toString();
    }

    public static void main(String[] args) throws IOException, ClassNotFoundException {
        Worm w = new Worm(6, 'a');
        System.out.println("w =" + w);
        //通过文件流写入
        ObjectOutputStream out = new ObjectOutputStream(new FileOutputStream("worm.out"));
        out.writeObject("Worm storage \n");
        out.writeObject(w);
        out.close();
        //通过文件流读取
        ObjectInputStream in = new ObjectInputStream(new FileInputStream("worm.out"));
        String s = (String) in.readObject();
        Worm w2 = (Worm) in.readObject();
        System.out.println(s + "w2 = " + w2);
        //通过字节数组流写入
        ByteArrayOutputStream bout = new ByteArrayOutputStream();
        ObjectOutputStream out2 = new ObjectOutputStream(bout);
        out2.writeObject("Worm storage \n");
        out2.writeObject(w);
        out2.flush();
        //通过字节数组流读取
        ObjectInputStream in2 = new ObjectInputStream(new ByteArrayInputStream(bout.toByteArray()));
        s = (String) in2.readObject();
        Worm w3 = (Worm) in2.readObject();
        System.out.println(s + "w3 = " + w3);
    }

}

Worm construction: 6
Worm construction: 5
Worm construction: 4
Worm construction: 3
Worm construction: 2
Worm construction: 1
w =:a(853):b(119):c(802):d(788):e(199):f(881)
Worm storage 
w2 = :a(853):b(119):c(802):d(788):e(199):f(881)
Worm storage 
w3 = :a(853):b(119):c(802):d(788):e(199):f(881)

通过上述例子，我们可以发现序列化不仅仅只保留了单个 Worm 本身，它所引用的对象网也同时被保存了下来。我们可以通过文件流（FileOutputStream、FileInputStream）和字节数组（ByteArrayOutputStream、ByteArrayInputStream）流来进行序列化和反序列化（进行反序列化时，要保证虚拟机能找到对应的.class文件）。

本次分享至此结束，希望本文对你有所帮助，若能点亮下方的点赞按钮，在下感激不尽，谢谢您的【精神支持】。

若有任何疑问，也欢迎与我交流，若存在不足之处，也欢迎各位指正！