Java基础之序列化和反序列化

什么是序列化
序列化就是将对象转化为字节流
反序列化就是将字节流转化为对象

序列化的作用
1.将对象保存到磁盘上
2.在网络传输对象

如何序列化
继承序列化接口Serializable

transient关键字，指定元素不会进行jvm默认的序列化
例如：private transient int age;
则在反序列化中拿不到age的值，就会取得int的默认值0
不过我们可以自己实现序列化，具体请看代码

serialVersionUID的作用
防止反序列化失败（当修改了这个类的时候，可能反序列化会失败）
序列化时，会将这个值写入某个地方，反序列化时会对比这个值，如果不一致则会失败，因此一般都将该值指定为1L

一个类实现了序列化接口，它的子类都可以进行序列化

序列化流
ObjectOutputStram writeObject

反序列化流
ObjectInputStream readObject

下面我来上一段代码

public class Worker implements Serializable {
  private static final long serialVersionUID = 1L;

  private String name;
  private String sex;
  private int age;
  //关注点1
  private transient int i; // 指定元素不会进行jvm默认的序列化 ,但是可以自己实现序列化，见代码最下面

  public int getI() {
    return i;
  }

  public void setI(int i) {
    this.i = i;
  }

  public String getName() {
    return name;
  }

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

  public String getSex() {
    return sex;
  }

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

  public int getAge() {
    return age;
  }

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

       //关注点2
  // 自己实现序列化
  private void writeObject(ObjectOutputStream oos) throws IOException {
    oos.defaultWriteObject();
    oos.writeInt(i);
    System.out.println("session serialized");
  }
      //关注点3
  // 自己实现反序列化
  private void readObject(ObjectInputStream ois) throws IOException,
        ClassNotFoundException {
    ois.defaultReadObject();
    i = ois.readInt();
    System.out.println("session deserialized");
  }
}

public class RWObject {

  public static void main(String[] args) {
    // TODO Auto-generated method stub
    String path = "/Users/sufan/Desktop/worker.txt";
    // 创建一个对象
    Worker worker = new Worker();
    worker.setName("张三");
    worker.setSex("男");
    worker.setAge(20);
    worker.setI(10);
    // 创建一个文件
    File file = new File(path);
    if (!file.exists()) {
        try {
            file.createNewFile();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }
    }
             //关注点4
    // 将对象保存到文件
    try {
        FileOutputStream fos = new FileOutputStream(file);
        ObjectOutputStream oos = new ObjectOutputStream(fos);
        oos.writeObject(worker);

        oos.close();
        fos.close();
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }
            //关注点5
    // 从文件中读取对象
    try {
        FileInputStream fis = new FileInputStream(file);
        ObjectInputStream ois = new ObjectInputStream(fis);
        Worker worker2 = (Worker) ois.readObject();
        System.out.println(worker2.getName());
        System.out.println(worker2.getSex());
        System.out.println(worker2.getAge());
        System.out.println(worker2.getI()); 
        ois.close();
        fis.close();
    } catch (FileNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (IOException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    } catch (ClassNotFoundException e) {
        // TODO Auto-generated catch block
        e.printStackTrace();
    }

  }
}

输出结果

张三
男
20
10

结果分析

关注点1，定义了一个transient类型的变量
关注点2，重写了readObject方法，这个方法的作用就是序列化
关注点3，重写了writeObject方法，这个方法的作用就是反序列化
关注点4，通过writeObject，将worker对象写入了文件
关注点5，通过readObject，从文件中读取了worker对象

如果我们不重写readObject和writeObject方法，则最终i的输出应该是0.