对象处理流ObjectInputStream和ObjectOutputStream

概念

1. 对象流实现了将基本数据类型或对象进行序列化和反序列化操作
2. 序列化：保存值和数据类型
3. 反序列化：就是在恢复数据时，恢复数据的值和数据类型
4. 如果需要让某个对象支持序列化机制，则必须让其类是可序列化的，则该类必须继承如下两个接口之一：Serializable(一个标记接口，没有方法)，Externalizable(该接口有方法需要实现，因此一般推荐使用Serializable接口)

• ObjectInputStream：提高反序列化功能
• ObjectOutputStream：提供序列化功能

注意事项和细节说明

1. 读写顺序要一致
2. 要求实现序列化或反序列化对象需要实现Serializable接口
3. 序列化的类中建议添加SerialVersionUID,为了提高版本的兼容性
4. 序列化对象时，默认将里面所有属性都进行序列化，除了static和transient修饰的成员
5. 序列化对象时，要求里面属性的类型也需要实现序列化接口
6. 序列化具备可继承性，即如果某类已经实现了序列化，则它的所有子类也已经默认实现了序列化

ObjectOutputStream（序列化）

package com.ftn.outPutStream;

import com.ftn.cpoyExample.Dog;
import java.io.FileOutputStream;
import java.io.ObjectOutputStream;


public class ObjectOutputStream_ {
    public static void main(String[] args) throws Exception {
        //序列化一个基本数据类型和一个Dog(name,age)对象,并保存到data.dat文件中

        String filePath = "d:\\data.dat";

        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));
        //序列化数据到 d:\data.dat 中
        oos.writeInt(100);     //自动装箱 int -> Integer (实现了serializable)
        oos.writeBoolean(true);     //自动装箱 boolean -> Boolean (实现了Serializable)
        oos.writeChar('a');        //char -> Character (实现了Serializable)
        oos.writeDouble(9.9);       //double -> Double (实现了Serializable)
        oos.writeUTF("Java");     //String (实现了Serializable)
        //保存一个Dog对象
        oos.writeObject(new Dog("小黄",3,"japen","black"));

        oos.close();
        System.out.println("数据保存完毕（序列化形式）");
    }
}

ObjectInputStream（反序列化）

package com.ftn.inputStream;

import com.ftn.cpoyExample.Dog;
import java.io.FileInputStream;
import java.io.ObjectInputStream;

public class ObjectInputStream_ {
    public static void main(String[] args) throws Exception {
        //指定反序列化文件路径
        String filePath = "d:\\data.dat";
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath));
        //1.反序列化的顺序需要和序列化顺序一致
        System.out.println(ois.readInt());
        System.out.println(ois.readBoolean());
        System.out.println(ois.readChar());
        System.out.println(ois.readDouble());
        System.out.println(ois.readUTF());
        //反序列化一个Dog对象
        Object dog = ois.readObject();
        Dog dog1 = (Dog) dog;
        System.out.println(dog);

        ois.close();

    }
}

使用细节

package com.ftn.cpoyExample;

import java.io.Serializable;

public class Dog implements Serializable {
        //如果需要序列化某个类的对象，实现Serializable接口
        private String name;
        private int age;
        //序列化对象时默认将里面所有属性都进行序列化，但除了static或transient修饰的成员
        private static String nation;
        private transient String color;
        //序列化对象时，要求里面的属性的类型也需要实现序列化接口
        private Master master = null;
        //serialVersionUID 序列化的版本号，可以提高兼容性
        private static final long serialVersionUID = 1L;

        public Dog(String name, int age,String nation,String color) {
            this.name = name;
            this.age = age;
            this.nation = nation;
            this.color = color;
        }

    @Override
    public String toString() {
        return "Dog{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", color='" + color + '\'' + ", nation='" + nation + '\'' + master +
                '}';
    }

    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;
    }
}

class Master implements Serializable{
}