序列化与反序列化详解（含代码）

对象序列化就是将对象的状态信息转换为可以存储或传输的形式的过程。
序列化（对象输出流）：把Java对象转化为字节序列的过程
反序列化（对象输入流）：把字节序列恢复为Java对象的过程

使用场景有两种：
1. 当两个进程在进行远程通信时，彼此可以发送各种类型的数据。无论是何种类型的数据，都会以二进制序列的形式在网络上传送。发送方需要把这个Java对象转换为字节序列，才能在网络上传送；接收方则需要把字节序列再恢复为Java对象。
2. 把内存中的对象进行输出流操作保存在永久性存储介质中，即在其他介质中存储对象的副本。之后就算是对象在内存中被销毁，我们都可以通过对象流的操作把介质中存储的对象还原到内存中。

使用条件：
只有实现了Serializable接口的类的对象才能进行对象序列化。在Java中，这种类叫做JavaBean类，JavaBean类是符合某种规范的Java类，它必须满足以下四个条件：
（1）私有成员变量
（2）对成员变量操作的公共get/set方法
（3）实现Serializable接口
（4）有公有无参构造方法

接下来用一个小demo来展示序列化的具体用法：

JavaBean类：

package com.zhaoxin.serializable;
import java.io.Serializable;

// 实现了Serializable接口
public class Picachu implements Serializable {

    // 私有成员变量
    private String master;
    private String skill;
    private int level;
    private int hp;
    private int atk;

    // 公有的get/set方法
    public String getMaster() {
        return master;
    }

    public void setMaster(String master) {
        this.master = master;
    }

    public String getSkill() {
        return skill;
    }

    public void setSkill(String skill) {
        this.skill = skill;
    }

    public int getLevel() {
        return level;
    }

    public void setLevel(int level) {
        this.level = level;
    }

    public int getHp() {
        return hp;
    }

    public void setHp(int hp) {
        this.hp = hp;
    }

    public int getAtk() {
        return atk;
    }

    public void setAtk(int atk) {
        this.atk = atk;
    }

    public void show() {
        System.out.println("主人：" + master);
        System.out.println("技能：" + skill);
        System.out.println("等级：" + level);
        System.out.println("生命值：" + hp);
        System.out.println("攻击力：" + atk);
    }

}

序列化：

package com.zhaoxin.serializable;

import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectOutputStream;
import java.io.Serializable;

public class SerializableTest {

    public static final String PATH = "file/myfile/serialize.java";

    public static void main(String[] args) {

        Picachu pi = new Picachu();
        pi.setMaster("小智");
        pi.setSkill("十万伏特");
        pi.setAtk(1000);
        pi.setHp(100);
        pi.setLevel(99);

        serializeObject(pi);
    }

    public static void serializeObject(Serializable s) {

        try {
            // 字节输出流
            FileOutputStream fos = new FileOutputStream(PATH);
            // 对象输出流
            ObjectOutputStream oos = new ObjectOutputStream(fos);

            // 写入文件
            oos.writeObject(s);
            System.out.println("序列化完成");

            oos.flush();
            oos.close();

        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }

}

反序列化：

package com.zhaoxin.deserializable;

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.IOException;
import java.io.ObjectInputStream;
import com.zhaoxin.serializable.Picachu;
import com.zhaoxin.serializable.SerializableTest;

public class DeserializableTest {

    public static void main(String[] args) {

        Object o = deserializeObject();

        if (o instanceof Picachu) {

            Picachu pi = (Picachu) o;
            pi.show();
        }
    }

    public static Object deserializeObject() {

        try {
            // 输入流
            FileInputStream fis = new FileInputStream(SerializableTest.PATH);
            // 对象输入流
            ObjectInputStream ois = new ObjectInputStream(fis);
            // 读取对象
            Object o = ois.readObject();
            // 关闭资源
            ois.close();
            // 返回对象
            return o;
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return null;
    }

}