Java序列化和反序列化

序列化和反序列化

定义

序列化：
就是将Java对象转换为字节序列的过程
反序列化:
就是把字节序列恢复为Java对象的过程

通过对象序列化，可以方便实现对象的传输和保存

作用

当两个进程进行远程通信时，可以相互发送各种类型的数据，包括文本、图片、音频、视频等，而这些数据都会以二进制序列的形式在网络上传送。那么当两个Java进程进行通信时，实现进程间的对象传送，就需要Java序列化与反序列化了。换句话说，一方面，发送方需要把这个Java对象转换为字节序列，然后在网络上传送;另一方面，接收方需要从字节序列中恢复出Java对象。

实现

// 实现Serializable 表示该对象可以被序列化，Serializable内没有方法，就像一个标志作用
public class Student implements Serializable {

package com.yjy.work;

import java.io.Serializable;

// 实现Serializable 表示该对象可以被序列化，Serializable内没有方法，就像一个标志作用
public class Student implements Serializable {
    private transient String userId;
    private String username;
    private String sex;
    private String profession;

    public Student() {
    }

    public Student(String userId, String username, String sex, String profession) {
        this.userId = userId;
        this.username = username;
        this.sex = sex;
        this.profession = profession;
    }

    public String getUserId() {
        return userId;
    }

    public void setUserId(String userId) {
        this.userId = userId;
    }

    public String getUsername() {
        return username;
    }

    public void setUsername(String username) {
        this.username = username;
    }

    public String getSex() {
        return sex;
    }

    public void setSex(String sex) {
        this.sex = sex;
    }

    public String getProfession() {
        return profession;
    }

    public void setProfession(String profession) {
        this.profession = profession;
    }

    @Override
    public String toString() {
        return "Student{" +
                "userId='" + userId + '\'' +
                ", username='" + username + '\'' +
                ", sex='" + sex + '\'' +
                ", profession='" + profession + '\'' +
                '}';
    }
}

// transient表示该属性不可被序列化
private transient String userId;

序列化

// 序列化
    public static void test8(File file, Student[] students) {
        if (!file.getParentFile().exists()) {
            file.getParentFile().mkdirs();
        }
        // 序列化
        OutputStream os = null;
        ObjectOutputStream cout = null;

        try {
            os = new FileOutputStream(file);
            cout = new ObjectOutputStream(os);
            cout.writeObject(students);
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        }finally {
            try {
                if (os != null) {
                    os.close();
                }
                if (cout != null) {
                    cout.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }

序列化后保存到磁盘

反序列化

// 反序列化
    public static void test9(File file) {
        if (!file.getParentFile().exists()) {
            file.getParentFile().mkdirs();
        }
        InputStream is = null;
        ObjectInputStream sin = null;

        try {
            is = new FileInputStream(file);
            sin = new ObjectInputStream(is);
            Object o = sin.readObject();
            System.out.println(o);
            for (Student student : (Student[]) o) {
                System.out.println(student);
            }
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        } finally {
            try {
                if (is != null) {
                    is.close();
                }
                if (sin != null) {
                    sin.close();
                }
            } catch (IOException e) {
                e.printStackTrace();
            }
        }
    }