Java对象的序列化、反序列化

 1 //要实现Serializable接口（并不用实现任何方法）
 2 class Student implements Serializable{
 3     private int id;
 4     private String name;
 5     private int age;
 6 
 7     public Student(int id,String name,int age){
 8         this.id=id;
 9         this.name=name;
10         this.age=age;
11     }
12 
13    public int getId(){
14         return this.id;
15    }
16 
17    public void setId(int id){
18         this.id=id;
19    }
20 
21    public String getName(){
22         return this.name;
23    }
24 
25    public void setName(String name){
26         this.name=name;
27    }
28 
29    public int getAge(){
30         return this.age;
31    }
32 
33    public void setAge(int age){
34         this.age=age;
35    }

 1  //序列化
 2         ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("./obj.txt"));  //处理流，要建立在节点流之上
 3         Student zhangsan=new Student(1,"张三",20);
 4         oos.writeObject(zhangsan);   //writeObject(Object obj)用于序列化一个对象（输出到文件/网络节点）
 5 
 6         //反序列化
 7         ObjectInputStream ois=new ObjectInputStream(new FileInputStream("./obj.txt"));
 8         Student student=(Student)ois.readObject();   //返回的是Object类型，所以往往要强制类型转换
 9 
10         System.out.println("学号："+student.getId());
11         System.out.println("姓名："+student.getName());
12         System.out.println("年龄："+student.getAge());

 1  //序列化，向同一文件中写入多个对象
 2         ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("./obj.txt"));  //处理流，要建立在节点流之上
 3         Student zhangsan=new Student(1,"张三",20);
 4         Student lisi=new Student(2,"李四",20);
 5         Student wangwu=new Student(3,"王五",20);
 6         oos.writeObject(zhangsan);  //张三
 7         oos.writeObject(lisi);  //李四
 8         oos.writeObject(wangwu);  //王五
 9 
10         //反序列化，读取顺序和写入顺序是一致的
11         ObjectInputStream ois=new ObjectInputStream(new FileInputStream("./obj.txt"));
12         Student zhangsan1=(Student)ois.readObject();    //张三
13         Student lisi1=(Student)ois.readObject();  //李四
14         Student wangwu1=(Student)ois.readObject();  //王五

1 class Student extends People implements Serializable{
2     //......
3 }

1 class Student implements Serializable {
2     private int id;
3     private String name;  //Java自带的类基本都实现了可序列化，不用管
4     private int age;
5     private Teacher teacher;    //此类持有一个Teacher类的引用。Teacher类必须要是可序列化的，Student类才是可序列化的。
6     //......
7 }

1   ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("./obj.txt"));
2         Student zhangsan=new Student(1,"张三",20);
3 
4         oos.writeObject(zhangsan);   //第一次序列化这个对象，输出此对象的字节序列。假设此对象的编号为1，编号唯一标识此对象。
5         oos.writeObject(zhangsan);  //再次输出此对象，输出的是此对象的编号，直接输出1。读取此对象时读取的仍是zhangsan这个对象。
6         oos.writeObject(zhangsan);  //直接输出1。
7         //类似于c++中的指针，通过编号指向某个已存在对象。减少了重新序列化对象的时间、内存开销。

 1  ObjectOutputStream oos=new ObjectOutputStream(new FileOutputStream("./obj.txt"));
 2         Student zhangsan=new Student(1,"张三",20);
 3 
 4         oos.writeObject(zhangsan);   //初次序列化，输出此对象的字节序列。假设编号为1
 5         zhangsan.setName("李四");   //之后修改了此对象
 6         oos.writeObject(zhangsan);  //再次输出此对象，输出的是编号1。1代表编号为1的对象。
 7 
 8         /*
 9         在此对象第一次序列化之后，对此对象做修改，后面再次输出此对象时，都是指向第一次输出的那个对象，做的修改并不会写到文件/网络节点中。
10         读取的也都是第一次输出的那个对象。
11 
12         实际上，序列化一个对象时，JVM会先检查在本次虚拟机中是否已序列化过这个对象，如果已序列化过，直接输出对应的序列化编号，未序列化过才序列化。
13 　　　　　JVM是以对象名来区分序列化的是否是同一个对象。对象名相同，JVM就认为序列化的是同一个对象，直接输出该对象的编号，并不判断此对象是否修改过。
14
15         修改此对象后，就算我们把此对象序列化到另一个文件中，输出的也是此对象第一次序列化时的编号，修改并不会同步到这个文件中。
16         */