【java:ObjectOutputStream对象输出流】对象序列化和反序列化

叁歲伎倆 2024-04-03 11:30 91阅读 0赞

要求：

学生类：

包含私有属性 id, name,address, age;

age属性用transient修饰，不需要被序列化；

测试类1：

序列化：传入参数：1，Jack，北京，18；

利用ObjectOutputStream，把该对象序列化，写进文件，命名为：student.txt；

测试类2：

反序列化：利用 ObjectInputStream ,把序列化后得到的student.txt文件的内容反序列化，读取出来，在控制台打印输出。

Student.java学生类：

>     package mypackage;
>     
>     import java.io.Serializable;
>     
>     public class Student implements Serializable {
>         //属性
>         private int id;
>         private String name;
>         private String address;
>         private transient int age;//transient瞬态属性不需要被序列化
>     
>         //无参构造方法
>         public Student() {
>         }
>         //含全部参数构造方法
>     
>         public Student(int id, String name, String address, int age) {
>             this.id = id;
>             this.name = name;
>             this.address = address;
>             this.age = age;
>         }
>         //右键generate，快速构建get/set方法
>     
>         public int getId() {
>             return id;
>         }
>     
>         public void setId(int id) {
>             this.id = id;
>         }
>     
>         public String getName() {
>             return name;
>         }
>     
>         public void setName(String name) {
>             this.name = name;
>         }
>     
>         public String getAddress() {
>             return address;
>         }
>     
>         public void setAddress(String address) {
>             this.address = address;
>         }
>     
>         public int getAge() {
>             return age;
>         }
>     
>         public void setAge(int age) {
>             this.age = age;
>         }
>     }

Test99.java测试类:

package mypackage;
    
    import java.io.FileOutputStream;
    import java.io.IOException;
    import java.io.ObjectOutputStream;
    import java.io.Serializable;
    
    public class Test99 implements Serializable {
        public static void main(String[] args) {
            Student stu = new Student();
            stu.setId(1);
            stu.setName("Jack");
            stu.setAddress("北京");
            stu.setAge(18);
            ObjectOutputStream out = null;
            //创建序列化流对象
            //FileOutputStream下方有红线，选择提示，try...catch
            try {
                out = new ObjectOutputStream(new FileOutputStream("Student.txt"));
                out.writeObject(stu);
                System.out.println("该对象已经被序列化了");
            } catch (IOException e) {
                e.printStackTrace();
            }finally {
                try {
                    out.close();
                } catch (IOException e) {
                    e.printStackTrace();
                }
            }
        }
    }

Test100.java测试类：

>     package mypackage;
>     
>     import java.io.FileInputStream;
>     import java.io.IOException;
>     import java.io.ObjectInputStream;
>     import java.io.Serializable;
>     
>     public class Test100 implements Serializable {
>         public static void main(String[] args) {
>             ObjectInputStream ois = null;
>             Student stu = null;
>     
>             try {
>                 ois = new ObjectInputStream(new FileInputStream("Student.txt"));
>                 stu = (Student)ois.readObject();
>             } catch (IOException var14) {
>                 var14.printStackTrace();
>             } catch (ClassNotFoundException var15) {
>                 var15.printStackTrace();
>             } finally {
>                 try {
>                     ois.close();
>                 } catch (IOException var13) {
>                     var13.printStackTrace();
>                 }
>             }
>             System.out.println("id:" + stu.getId());
>             System.out.println("name:" + stu.getName());
>             System.out.println("address:" + stu.getAddress());
>             System.out.println("age:" + stu.getAge());
>         }
>     }

运行结果：

Test99.java，进行序列化后：（这是对象序列化以后，文件的内容，不知道可不可以显示成正常的文字，有知道的小伙伴吗？）

![0a82a9355f12469a828ccb6dc03795f6.png][]

Test100.java,进行反序列化后：

![839b3755d81b44f592061528e780df03.png][]

总结：

序列化：对象序列化的机制，用一个字节序列可以表示一个对象，将对象写入文件，相当于在文件中持久保存。

反之，该字节序列还可以从文件中读取出来，重构对象，对它进行反序列化。

ObjectInputStream 序列化 对象转换为字节

ObjectOutputStream 反序列化 字节重构为对象

作用：将java对象的数据写出到文件，实现对象的持久存储

注意：age属性用transient修饰，不需要被序列化，所以文件里面是没有age这个属性的信息的。

[0a82a9355f12469a828ccb6dc03795f6.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/5cdfbb689d40426b810bc4bb257457ad.png
[839b3755d81b44f592061528e780df03.png]: https://image.dandelioncloud.cn/pgy_files/images/2024/04/03/7627d9b1990746ac8ad40c9d807d11fa.png