java 笔记 io流-3对象序列化

可爱的静静

对象序列化

对象序列化作用：把对象存到文件里，想用的时候可以读取

ObjectOutputStream和ObiectInputStream是直接操作对象（对象当中会封装一些数据）的输入流和输出流，对象的持久化，可以长久存放数据的文件

ObjectOutputStream和ObiectInputStream是在io包里面的

对象序列话和反序列话例子：

1. <div>     import java.io.*;</div><div>      public class xulie {</div><div>      public static void main(String[] args) {
   
2.       xulie a=new xulie();
   
3.          a.WritePut();
   
4.          a.read();</div><div>       }
   
5. 
   
6.         public void  WritePut(){
   
7.             try {
   
8.                    FileOutputStream out =new FileOutputStream("D://Student.dat");
   
9.                    ObjectOutputStream oos=new ObjectOutputStream(out);
   
10.                    Contact contact=new Contact("小明","123456789","1609368211@qq.com");
    
11.                     oos.writeObject(contact);
    
12.        oos.close();
    
13.       
    
14.            } catch (FileNotFoundException e) {
    
15.                    // TODO Auto-generated catch block
    
16.                    e.printStackTrace();
    
17.            } catch (IOException e) {
    
18.                    // TODO Auto-generated catch block
    
19.                    e.printStackTrace();
    
20.            }
    
21.         }
    
22.         public void read(){
    
23.          try {
    
24.     FileInputStream in=new FileInputStream("D://Student.dat");
    
25.     ObjectInputStream ois = null;
    
26.      ois = new ObjectInputStream(in);
    
27.     Contact contact = null;
    
28.      contact = (Contact)ois.readObject();
    
29.      System.out.println(contact);
    
30.     } catch (FileNotFoundException e) {
    
31.      e.printStackTrace();
    
32.     } catch (IOException e) {
    
33.      // TODO Auto-generated catch block
    
34.      e.printStackTrace();
    
35.     } catch (ClassNotFoundException e) {
    
36.      // TODO Auto-generated catch block
    
37.      e.printStackTrace();
    
38.    
    
39.    }
    
40.         }
    
41.         }
    
42. </div></div>

复制代码

1. 
   
2. import java.io.Serializable;
   
3. public class Contact  implements Serializable{
   
4. 
   
5.         private String name;
   
6.         private String phone;
   
7.         private String email;
   
8.         public Contact ( String name,String phone,String email){
   
9.                 this.name=name;
   
10.                 this.phone=phone;
    
11.                 this.email=email;
    
12.         }
    
13.         public String toString()
    
14.         {
    
15.                 return "姓名"+name+",电话："+phone+",email:"+email;
    
16.         }
    
17. }
    

复制代码

输出结果是：
姓名小明,电话：123456789,email:1609368211@qq.com

想要被序列化的例子必须是要有资格，只有类实现接口Serializable接口才会有资格，这个接口没有方法，只是标记这个对象可以序例化
如果每一次改变了类里面的内容，之前对象序列化的文件就没什么用，如果你重新建一个类，这就很麻烦了

怎样给这个标记可以序例化

其实就是给个类加了一个ID号，例如：static final long serialVersionUID = 42L;

假设已经把某类序例化了，如果某类改变了，

id号就改变了，再次读取这个文件的时候就读取不了了，如果我们自己给这个类id号的话，修改了类之后id号不会改，修改之前保存的对象文件也就是可以读取了

例如：刚刚已经对象序列话了，再来假设把成员name 访问方式改为public的话

再读取这个文件的时候运行会有错误

可以这样纸办：代码如下

1. [b]
   
2. 
   
3. import java.io.Serializable;
   
4. public class Contact  implements Serializable{
   
5. 
   
6.         static final long serialVersionUID = 42L;
   
7.         private String name;
   
8.         private String phone;
   
9.         private String email;
   
10.         public Contact ( String name,String phone,String email){
    
11.                 this.name=name;
    
12.                 this.phone=phone;
    
13.                 this.email=email;
    
14.         }
    
15.         public String toString()
    
16.         {
    
17.                 return "姓名"+name+",电话："+phone+",email:"+email;
    
18.         }
    
19. }[/b]
    
20. 
    

复制代码

代码改完后，先对喜爱那个序列化，再改类的内容，在读取文件，运行结果如下：

姓名小明,电话：123456789,email:1609368211@qq.com

其实就是加了个ID号 无论类的代码怎么改变也好，都可以读回之前的对象序列化文件

静态的成员，即使new了一个对象赋值了，序列化也不会有改变，如果不想对非静态的成员序列化的话，可以在成员变量前面加关键字transient

例如：

代码还是上面那样，transient  int phone

运行结果当然那就是没有phone的值没有改变