序列化与[反序列化]

1. 序列化：

1. 将程序中对象的各项信息，序列化输出到文件中保存

2. 方向是Out,使用的流是ObjectOutputStream

3. 使用的方法是out.writeObject(目标对象)；

4. 注意：如果一个类的对象想要被序列化，那么这个类必须实现Serializable接口

2. 反序列化：

1. 将之前输出到文件中的数据，读取回程序中，并把读到的数据重新恢复成对象

2. 方向是in,使用的流是ObjectInputStream

3. 使用的方法是in.readObject();

4. 注意：反序列化指定的文件路径，必须与序列化输出的文件路径一样

5. 注意：一次序列化操作对应一次反序列化操作，或者UID必须保持一致，如果不一致，会报错

 

package cn.tedu.serializable;

import java.io.Serializable;

/*本类用于封装学生类*/
/*如果本类的对象想要被序列化输出，必须实现可序列化接口Serializable
 * 否则会报错：java。io.NoSerializableException:cn.tedu.serializable.Student
 * Serializable是一个空接口，里面一个方法都没有
 * 作用是用作标记，标记这个类的对象可以被序列化*/
public class Student implements Serializable {
    /**
     * JVM会给每个要序列化输出的类分配一个唯一的UID，
     * 只要更改了这个类，自动生成的默认UID就会改变
     */
    //这是我们写死的UID数据，就是1l，但是不推荐这么写
    //private static final long serialVersionUID=1l;
    //1.定义学生类的相关属性并进行封装
    private String name;
    private int age;
    private String addr;
    private char gender;

    //2.1创建本类的无参构造
    public Student() {
        System.out.println("无参构造");
    }

    //2.2创建本类的全参构造
    public Student(String name, int age, String addr, char gender) {
        this.name = name;
        this.age = age;
        this.addr = addr;
        this.gender = gender;
        System.out.println("全参构造");
    }

    //在Student类中添加toString()
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", addr='" + addr + '\'' +
                ", gender=" + gender +
                '}';
    }
}

package cn.tedu.serializable;
/*本类用于测试序列化与反序列化*/

import java.io.*;

/**
 * 序列化：ObjectOutputStream,把java中的对象，保存在磁盘中，相当于对象信息写出保存在文件中
 * 反序列化：ObjectInputStream：把之前序列化输出的数据读取到内存程序中，相当于把对象读取到程序
 * 推荐大家：一次序列化化操作对应一次反序列化操作
 */
public class TestSerializable {
    public static void main(String[] args) {
        method1();//用于测试序列化
        method2();//用于测试反序列化
    }

    //本方法用于测试反序列化
    private static void method2() {
        //1.定义在整个方法中都生效的局部变量，注意手动初始值为null；;
        ObjectInputStream in = null;
        //2.由于方法可能会抛出异常，所以需要完成try-catch-finally结构
        try {
            //3.创建反序列化输入流
            in = new ObjectInputStream(new FileInputStream("D:\\ready\\1.txt"));
            //4.通过流对象反序列化恢复对象
            Object o = in.readObject();
            // Student o1 = (Student) in.readObject();
//            System.out.println(o1);
            System.out.println(o);
            System.out.println("恭喜您，反序列化成功");
        } catch (Exception e) {
            e.printStackTrace();
            System.out.println("很遗憾，反序列化失败");
        } finally {
            try {
                in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    //本方法用于测试序列化
    /*注意：序列化输出的数据我们是看不懂的
     * 我们需要后期通过反序列化技术把之前输出的数据重新恢复成对象，才能使用*/
    private static void method1() {
//1.
        ObjectOutputStream out = null;
        //2.由于代码可能会出现异常，所以需要编写try-catch-finally结构
        try {
            //3.创建序列化输出流对象
            out = new ObjectOutputStream(new FileOutputStream("D:\\ready\\1.txt"));
            //4.指定要序列化输出的对象
            Student obj = new Student("海绵宝宝", 3, "海里", '男');
            //5.将刚刚创建好的学生类对象obj，使用序列化out输出到指定文件1.txt中
            out.writeObject(obj);
            System.out.println("恭喜您，序列化成功");

        } catch (IOException e) {
            e.printStackTrace();
            System.out.println("很遗憾，序列化失败");
        } finally {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}