序列化/反序列化

Student类–需要执行序列化和反序列化的类

public class Student implements Serializable {
    /*如果本类的对象想要被序列化输出，必须实现可序列化接口Serializable，否则报错
    * Serializable接口是一个空接口，里面一个方法也没有，作用是用来当作标志
    * 标志当前这个类的对象可以被序列化
    *
    * UID可以写死*/
    private static final long serialVersionUID=1L;
    private String name;
    private int age;
    private String addr;
    private char gender;

    public  Student(){
        System.out.println("无参构造");
    }
    @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", addr='" + addr + '\'' +
                ", gender=" + gender +
                '}';
    }
    public Student(String name, int age, String addr, char gender) {

        this.name = name;
        this.age = age;
        this.addr = addr;
        this.gender = gender;

    }

    public String getName() {
        return name;
    }

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

    public int getAge() {
        return age;
    }

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

    public String getAddr() {
        return addr;
    }

    public void setAddr(String addr) {
        this.addr = addr;
    }

    public char getGender() {
        return gender;
    }

    public void setGender(char gender) {
        this.gender = gender;
    }


}

序列化和反序列化

/*序列化：把程序中的Java对象，永久保存在磁盘中，相当于是写出的过程
 * 方向是out，对应的流是：ObjectOutputStream
 * 反序列化：
 * 是指把已经序列化在文件中保存的数据，读取/恢复到Java程序当中的过程
 * 方向是in，对应的流是ObjectInputStream*/
public class TestSerializable {
    public static void main(String[] args) {
        method1();//序列化
        method2();//反序列化
    }

    private static void method2() {
        //在本方法定义一个局部变量
        ObjectInputStream in= null;
        System.out.println("1");
        try {
            System.out.println("2");
            in=new ObjectInputStream(new FileInputStream("D:\\Test\\ready\\1.txt"));

            System.out.println("3");
           //通过反序列化流，读取恢复对象
            System.out.println(in.readObject());
            System.out.println("反序列化成功");
        } catch (Exception e) {
            System.out.println("反序列化失败");
            e.printStackTrace();
        } finally {
            try {
               in.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

    private static void method1() {
        //1.声明一个在本方法都生效的局部变量，局部变量需要初始化
        ObjectOutputStream out = null;
        try {
            //3.创建流对象
            out = new ObjectOutputStream(
                    new FileOutputStream("D:\\Test\\ready\\1.txt", true));
            //4.指定要序列化（输出）的对象
            Student s = new Student("李峥", 22, "浙江杭州", '男');
            //5.通过ObjectOutputStream流对象来序列化输出Student对象
            out.writeObject(s);
            System.out.println("序列化成功");
        } catch (Exception e) {
            System.out.println("序列化失败");
            e.printStackTrace();
        } finally {
            try {
                out.close();
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }
}

自定义类（要执行序列化反序列化）中的****UID，与反序列化中的UID保持一致
一次序列化对应一次反序列化
一次序列化后不修改自定义类中的内容，然后修改反序列化

UID可以写死，但是一般不会写死，默认使用默认的UID

private static final long serialVersionUID=1L;