2022.5.5 I/O对象流

对象流

ObjectOutputStream / ObjectInputStream

  • 增强了缓冲区功能

  • 增强了读写8种基本数据类型和字符串的功能

  • 增强了读写对象的功能

    • readObject() 从流中读取一个对象：反序列化

    • writeObject(Object obj) 向流中写入一个对象：序列化

使用流传输对象的过程称为序列化、反序列化

序列化与反序列化

序列化：向流中写入一个对象

序列化类必须继承接口Serializable

 1 package com.xing;
 2 
 3 import java.io.FileOutputStream;
 4 import java.io.IOException;
 5 import java.io.ObjectOutputStream;
 6 import java.io.Serializable;
 7 
 8 public class Demo06 {
 9     public static void main(String[] args) throws IOException {
10         //创建输出流
11         FileOutputStream fos = new FileOutputStream("d:\\stu.bin");
12         //创建对象输出流
13         ObjectOutputStream oos = new ObjectOutputStream(fos);
14 
15         //序列化 ：写入对象
16         Student s = new Student("小明", 23);
17         oos.writeObject(s);//写入一个对象
18 
19         //关闭
20         oos.close();
21     }
22 }
23 //继承接口Serializable  标记接口：表示此类可以序列化  里面无方法   标记接口
24 class Student implements Serializable {
25     private String name;
26     private int age;
27 
28     public Student() {
29     }
30 
31     public Student(String name, int age) {
32         this.name = name;
33         this.age = age;
34     }
35 
36     public String getName() {
37         return name;
38     }
39 
40     public void setName(String name) {
41         this.name = name;
42     }
43 
44     public int getAge() {
45         return age;
46     }
47 
48     public void setAge(int age) {
49         this.age = age;
50     }
51 
52     @Override
53     public String toString() {
54         return "Student{" +
55                 "name='" + name + '\'' +
56                 ", age=" + age +
57                 '}';
58     }
59 }

反序列化：从流中读取一个对象

 1 package com.xing;
 2 
 3 import java.io.FileInputStream;
 4 import java.io.IOException;
 5 import java.io.ObjectInputStream;
 6 
 7 public class Demo07 {
 8     public static void main(String[] args) throws IOException, ClassNotFoundException {
 9         //创建输入流
10         FileInputStream fis = new FileInputStream("d:stu.bin");
11         //创建对象输入流
12         ObjectInputStream ois = new ObjectInputStream(fis);
13 
14         //反序列化：读文件
15         Student s = (Student) ois.readObject();//返回值为Object类型   做强转
16 
17         //关闭
18         ois.close();
19         System.out.println(s.toString());
20     }
21 }

注意事项

  1. 某个类要想序列化必须实现Serializable接口

  2. 序列化类中对象（class）属性要求实现Serializable接口

  3. 序列化版本号ID，保证序列化的类和反序列化的类是同一个类

  4. 使用transient修饰属性，这个属性就不能序列化

  5. 静态属性不能序列化

  6. 序列化多个对象，可以借助集合来实现

 1 package com.xing;
 2 
 3 import java.io.FileOutputStream;
 4 import java.io.IOException;
 5 import java.io.ObjectOutputStream;
 6 import java.io.Serializable;
 7 import java.util.ArrayList;
 8 
 9 public class Demo06 {
10     public static void main(String[] args) throws IOException {
11         //创建输出流
12         FileOutputStream fos = new FileOutputStream("d:\\stu.bin");
13         //创建对象输出流
14         ObjectOutputStream oos = new ObjectOutputStream(fos);
15 
16         //序列化 ：写入对象
17         Student s1 = new Student("小红", 23);
18         Student s2 = new Student("小嘿", 23);
19         ArrayList<Student> arrayList = new ArrayList<>();
20         arrayList.add(s1);
21         arrayList.add(s2);
22         oos.writeObject(arrayList);//写入一个集合
23 
24         //关闭
25         oos.close();
26     }
27 }
28 //继承接口Serializable  标记接口：表示此类可以序列化  里面无方法   标记接口
29 class Student implements Serializable {
30     private String name;
31     private int age;
32 
33     public Student() {
34     }
35 
36     public Student(String name, int age) {
37         this.name = name;
38         this.age = age;
39     }
40 
41     public String getName() {
42         return name;
43     }
44 
45     public void setName(String name) {
46         this.name = name;
47     }
48 
49     public int getAge() {
50         return age;
51     }
52 
53     public void setAge(int age) {
54         this.age = age;
55     }
56 
57     @Override
58     public String toString() {
59         return "Student{" +
60                 "name='" + name + '\'' +
61                 ", age=" + age +
62                 '}';
63     }
64 }
 1 package com.xing;
 2 
 3 import java.io.FileInputStream;
 4 import java.io.IOException;
 5 import java.io.ObjectInputStream;
 6 import java.util.ArrayList;
 7 
 8 public class Demo07 {
 9     public static void main(String[] args) throws IOException, ClassNotFoundException {
10         //创建输入流
11         FileInputStream fis = new FileInputStream("d:stu.bin");
12         //创建对象输入流
13         ObjectInputStream ois = new ObjectInputStream(fis);
14 
15         //反序列化：读文件
16         ArrayList<Student> list = (ArrayList<Student>) ois.readObject();//返回集合类型 做强转
17 
18         //关闭
19         ois.close();
20         System.out.println(list.toString());
21 
22     }
23 }
24 
25  
26 
27

 

posted @ 2022-05-06 10:03  暴躁C语言  阅读(27)  评论(0)    收藏  举报