对象的序列化和反序列化

谁践踏了优雅 2022-09-12 12:53 251阅读 0赞

什么是序列化？  
为了把对象的成员属性和成员方法进行持久化的保存，需要把**对象转换为字节序列**，以便于存储，这个过程就叫序列化。

反之，反序列化就是把字节序列恢复成对象。

1.  **实现序列化的对象需要实现一个标记接口，并且给这个添加一个Long类型的标记**

Serializable 这个接口里面没有任何东西，只是作为一个标记
    private static final long serialVersionUID = 1L;常量，默认设置为1L

当我们进行序列化和反序列化时就会检测该类上面是否有这个标记，没有会抛出异常 `NotSerializableException`

1.  使用`ObjectOutputStream`类`writeObject()`方法写入对象

public class ObjectOutputStream
        extends OutputStream implements ObjectOutput, ObjectStreamConstants{ 
        }

该类继承了字节流的输出流`OutputStream`类

1.  要读取时，使用`ObjectInputStream`类的`readObject()`方法

public class ObjectInputStream
        extends InputStream implements ObjectInput, ObjectStreamConstants
    { }

该类继承字节流的输入流`InputStream`类

package com.study.SerializableImpl;
    
    import java.io.Serializable;
    
    /** * @Description 实现对象序列化 * @Date 2021/9/12 13:09 * @Created by 折腾的小飞 */
    public class Student implements Serializable { 
        private static final long serialVersionUID = 1L;
        private String name;
        private Integer age;
    
        public String getName() { 
            return name;
        }
    
        public void setName(String name) { 
            this.name = name;
        }
    
        public Integer getAge() { 
            return age;
        }
    
        public void setAge(Integer age) { 
            this.age = age;
        }
    
        public Student() { 
        }
    
        public Student(String name, Integer age) { 
            this.name = name;
            this.age = age;
        }
    
        @Override
        public String toString() { 
            return "Student{" +
                    "name='" + name + '\'' +
                    ", age=" + age +
                    '}';
        }
    }

package com.study.SerializableImpl;
    
    import java.io.*;
    import java.util.ArrayList;
    import java.util.Arrays;
    import java.util.List;
    
    /** * @Description 3种方法实现对象的反序列化 * @Date 2021/9/12 14:23 * @Created by 折腾的小飞 */
    public class StudentSerializable { 
        public static void main(String[] args) { 
            Student stu = new Student("胡梓卓", 22);
            Student stu1 = new Student("涂鏊飞", 21);
            Student[] stus = { stu, stu1};
            try { 
                ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(new File("./stu.txt")));
    
                /*oos.writeObject(stus); // 写入一个对象数组 oos.flush();*/
    
                // 遍历写入单个对象
                /*for (Student student : stus) { oos.writeObject(student); oos.flush(); } oos.writeObject(null);*/
    
                for (Student student : stus) { 
                    oos.writeObject(student);
                    oos.flush();
                }
    
                System.out.println("对象序列化成功");
    
    
                ObjectInputStream ois = new ObjectInputStream(new FileInputStream("./stu.txt"));
                // 存入文件时，将几个对象放入一个Object[] 数组中，然后再读取。
                /*Object[] arrStu = (Object[]) ois.readObject(); for (Object o : arrStu) { System.out.println(o); }*/
    
    
                // 第二种方法，在写入时最后写入null
                /*Student s=null; while ((s= (Student) ois.readObject())!=null){ System.out.println(s); }*/
    
                // 用available判断是否达到了文件末尾
                /*Object obj = null; while (ois.available() > 0) { obj = ois.readObject(); System.out.println(obj); }*/
    
                /*System.out.println(ois.available());*/
                System.out.println("对象反序列化成功");
                oos.close();
                ois.close();
            } catch (IOException e) { 
                e.printStackTrace();
            }
    
        }
    }

把两个对象stu和stu1写入文件**stu.txt**后，查看文件

�� sr "com.study.SerializableImpl.Student        L aget Ljava/lang/Integer;L namet Ljava/lang/String;xpsr java.lang.Integer⠤���8 I valuexr java.lang.Number������  xp   t 	胡梓卓sq ~  sq ~    t 	涂鏊飞