zoukankan      html  css  js  c++  java
  • java之IO流(序列化流与反序列化流)

    一.对象序列化流ObjectOutputStream

    用于向流中写入对象的操作流 ObjectOutputStream   称为 序列化流

    ObjectOutputStream 将 Java 对象的基本数据类型和图形写入 OutputStream。可以使用 ObjectInputStream 读取(重构)对象。通过在流中使用文件可以实现对象的持久存储。

    注意:只能将支持 java.io.Serializable 接口的对象写入流中

    构造方法摘要:

    ObjectOutputStream(OutputStream out):创建写入指定OutputStream的ObjectOutputStream。

    方法摘要:

    writeObject(Object obj):将指定的对象写入ObjectOutputStream。

    //Person类
    public class Person implements Serializable {
        private String name;
        private int age;
        public Person() {
            super();
        }
        public Person(String name, int age) {
            super();
            this.name = name;
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        @Override
        public String toString() {
            return "Person [name=" + name + ", age=" + age + "]";
        }
    }
    //测试类
    public class ObjectStreamDemo {
        public static void main(String[] args) throws IOException, ClassNotFoundException {
            /*
             * 将一个对象存储到持久化(硬盘)的设备上。
             */
            writeObj();//对象的序列化。
        }
        public static void writeObj() throws IOException {
            //1,明确存储对象的文件。
            FileOutputStream fos = new FileOutputStream("tempfile\obj.object");
            //2,给操作文件对象加入写入对象功能。
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            //3,调用了写入对象的方法。
            oos.writeObject(new Person("wangcai",20));
            //关闭资源。
            oos.close();
        }
    }

    二.对象反序列化流ObjectInputStream

    ObjectInputStream 对以前使用 ObjectOutputStream 写入的基本数据和对象进行反序列化。支持 java.io.Serializable接口的对象才能从流读取

    构造方法摘要:

    ObjectInputStream(InputStream in):创建从指定InputStream读取的ObjectInputStream。

    方法摘要:

    readObject(Object obj):从ObjectInputStream读取对象

    public class ObjectStreamDemo {
        public static void main(String[] args) throws IOException, ClassNotFoundException {
            readObj();//对象的反序列化。
        }
        public static void readObj() throws IOException, ClassNotFoundException {
            
            //1,定义流对象关联存储了对象文件。
            FileInputStream fis = new FileInputStream("tempfile\obj.object");
            
            //2,建立用于读取对象的功能对象。
            ObjectInputStream ois = new ObjectInputStream(fis);
            
            Person obj = (Person)ois.readObject();
            
            System.out.println(obj.toString());
            
        }
    }

    三.序列化接口

    当一个对象要能被序列化,这个对象所属的类必须实现Serializable接口。否则会发生异常NotSerializableException异常。同时当反序列化对象时,如果对象所属的class文件在序列化之后进行的修改,那么进行反序列化也会发生异常InvalidClassException。

    原因:

    1.该类的序列版本号与从流中读取的类描述符的版本号不匹配

    2.该类包含未知数据类型

    3.该类没有可访问的无参数构造方法

    Serializable标记接口。该接口给需要序列化的类,提供了一个序列版本号。serialVersionUID. 该版本号的目的在于验证序列化的对象和对应类是否版本匹配。

    public class Person implements Serializable {
        //给类显示声明一个序列版本号。
        private static final long serialVersionUID = 1L;
        private String name;
        private int age;
        public Person() {
            super();
            
        }
        public Person(String name, int age) {
            super();
            this.name = name;
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
        @Override
        public String toString() {
            return "Person [name=" + name + ", age=" + age + "]";
        }
    }

    四.瞬态关键字transient

    当一个类的对象需要被序列化时,某些属性不需要被序列化,这时不需要序列化的属性可以使用关键字transient修饰。只要被transient修饰了,序列化时这个属性就不会序列化了。同时静态修饰也不会被序列化,因为序列化是把对象数据进行持久化存储,而静态的属于类加载时的数据,不会被序列化。

    public class Person implements Serializable {
        /*
         * 给类显示声明一个序列版本号。
         */
        private static final long serialVersionUID = 1L;
        private static String name;
        private transient/*瞬态*/ int age;
        
        public Person() {
            super();
            
        }
        
        public Person(String name, int age) {
            super();
            this.name = name;
            this.age = age;
        }
    
        public String getName() {
            return name;
        }
        public void setName(String name) {
            this.name = name;
        }
        public int getAge() {
            return age;
        }
        public void setAge(int age) {
            this.age = age;
        }
    
        @Override
        public String toString() {
            return "Person [name=" + name + ", age=" + age + "]";
        }
    }
  • 相关阅读:
    斐波那契数列 的两种实现方式(Java)
    单链表反转
    单链表合并
    两个有序list合并
    list去重 转载
    RemoveAll 要重写equals方法
    Java for LeetCode 138 Copy List with Random Pointer
    Java for LeetCode 137 Single Number II
    Java for LeetCode 136 Single Number
    Java for LeetCode 135 Candy
  • 原文地址:https://www.cnblogs.com/akiyama/p/10224568.html
Copyright © 2011-2022 走看看