Java是序列化和反序列化是什么，怎么实现？

序列化是把Java对象转化成字节流，反序列化就是把字节流转化成Java对象，字节流是什么呢？就是存储文件的二进制文件。我们在计算机上所存储的一切东西都是以二进制形式存在的，都是由数不清的0和1组成的，我们看到的其实是计算机加工处理后的数据。

序列化有什么用？

序列化可以帮助我们把对象存储为一个文件，举个例子，类似于把文件打包。反序列化相当于就是拿到需要解压的地方解压后使用，虽然序列化不是压缩，但是都是为了方便传输，换个地方再反序列化使用，比如需要使用网络传输到另一台机器上使用，这时候就需要使用到序列化了。

序列化怎么实现？

Java实现序列化需要使用到对象流，ObjectOutputStream和ObjectInputStream。其中ObjectOutputStream用于序列化，ObjectInputStream用于反序列化。

首先定义一个需要序列化的类Person：

import java.io.Serializable;

public class Person implements Serializable {

    private int age;

    private String name;

    public Person(int age, String name) {
        this.age = age;
        this.name = name;
    }

    public Person() {
    }

    public int getAge() {
        return age;
    }

    public void setAge(int age) {
        this.age = age;
    }

    public String getName() {
        return name;
    }

    public void setName(String name) {
        this.name = name;
    }

    @Override
    public String toString() {
        return "Person{" +
                "age=" + age +
                ", name='" + name + '\'' +
                '}';
    }
}

然后写一段处理对象的逻辑：

package com.huajieyu.code.at0910a;

import java.io.*;

public class Example {

    /**
     * @param object 需要序列化的对象
     * @param path   存储序列化文件的路径
     */
    public static void toStream(Object object, String path) {
        // 创建一个File对象，用于后面的序列化
        File file = new File("example.txt");

        //输出一下查看对象
        System.out.println(object);
        try (
                // 创建对象输出流，用于把对象写为文件
                ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file))) {

            oos.writeObject(object);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 反序列化
     *
     * @param path 需要读取字节流的文件路径
     * @return 目标对象
     */
    public static Object toObject(String path) {
        // 创建一个File对象，用于后面的反序列化
        File file = new File(path);
        Object object = null;
        try (
                // 创建对象输入流，用于读取文件
                ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file))) {

            // 使用readObject方法获取反序列化的对象
            object = ois.readObject();
        } catch (Exception e) {
            e.printStackTrace();
        }

        return object;
    }

    public static void main(String[] args) {
        Person person = new Person(24, "徐悲鸿");

        // 执行序列化
        toStream(person, "example.txt");
    }
}

通过执行上列代码的toStream把person对象序列化，可以看到项目根目录出现了一个名为"example.txt"的文件

打开可以看到完全看不懂，这其实就是我们序列化后的字节序列

接下来可以读取这个文件反序列化，看看能不能获取我们想要的对象。

package com.huajieyu.code.at0910a;

import java.io.*;

public class Example {

    /**
     * @param object 需要序列化的对象
     * @param path   存储序列化文件的路径
     */
    public static void toStream(Object object, String path) {
        // 创建一个File对象，用于后面的序列化
        File file = new File("example.txt");

        //输出一下查看对象
        System.out.println(object);
        try (
                // 创建对象输出流，用于把对象写为文件
                ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(file))) {

            oos.writeObject(object);
        } catch (Exception e) {
            e.printStackTrace();
        }
    }

    /**
     * 反序列化
     *
     * @param path 需要读取字节流的文件路径
     * @return 目标对象
     */
    public static Object toObject(String path) {
        // 创建一个File对象，用于后面的反序列化
        File file = new File(path);
        Object object = null;
        try (
                // 创建对象输入流，用于读取文件
                ObjectInputStream ois = new ObjectInputStream(new FileInputStream(file))) {

            // 使用readObject方法获取反序列化的对象
            object = ois.readObject();
        } catch (Exception e) {
            e.printStackTrace();
        }

        return object;
    }

    public static void main(String[] args) {
        // 执行反序列化
        Object object = toObject("example.txt");
        // 输出查看结果
        System.out.println(object);
    }
}

可以看到对象成功创建，输出的内容和之前创建的一模一样。

需要注意的是，序列化的对象必须实现java.io.Serializable接口，不然无法序列化。如果此对象实现了该接口，但是又引用了其他对象未实现java.io.Serializable接口的，也会序列化失败，必须引用的类也实现此接口才行。

序列化一般用于网络传输对象，也可用于存储对象等，另外还能破解没有加readResolve方法的单例模式，想了解的朋友可以去了解一下单例模式的破坏。