IO流-ObjectInputStream对象处理流（序列化与反序列化）

对象处理流

ObjectInputStream （反序列化）, ObjectOutputStream（序列化）

在开发中会有这样一些需求， 例如 要求将 int 100 ， Dog对象 序列化到 文件中， 需要时再反序列化 到 代码中。 

序列化和反序列化

1.序列化就是在保存数据时，保存数据的值和数据类型

2.反序列化就是在恢复数据时，恢复数据的值和数据类型

3.需要让某个对象支持序列化机制，则必须让其类是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之一：

serializable //这是一个标记接口,  推荐使用

Externalizable //需要重写方法，较为麻烦，不推荐

类图

构造方法

常用方法

序列化与反序列化示例

特别注意： 序列化与反序列化的顺序必须一致，否则会报错

ObjectOutputStream objectOutputStream = null;
        //序列化后是特殊的格式， 序列化的文件后缀可以任意写， 没有固定格式
        String s = "f:\\xuliehua.dat";

        try {
            objectOutputStream = new ObjectOutputStream(new FileOutputStream(s));
            objectOutputStream.writeInt(100); //先自动装箱，Integer实现了Serializable接口
            objectOutputStream.writeBoolean(true);//先自动装箱，Boolean实现了Serializable接口
            objectOutputStream.writeChar('a');//.....
            objectOutputStream.writeDouble(1.2);//.....
           objectOutputStream.writeUTF("爱你一万年");//.....
            objectOutputStream.writeObject(new Pigg(1,1.2));//.....
            System.out.println("序列化完成");

        } catch (IOException e) {
            throw new RuntimeException(e);
        }finally {
            if(objectOutputStream != null) {
                try {
                    objectOutputStream.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }

   ObjectInputStream objectInputStream = null;
        String s = "f:\\xuliehua.dat";
        int val = 0;
        try {
            //反序列化一定要按照序列化的顺序来写代码
            objectInputStream = new ObjectInputStream(new FileInputStream(s));

            System.out.println(objectInputStream.readInt());
            System.out.println(objectInputStream.readBoolean());
            System.out.println(objectInputStream.readChar());
            System.out.println(objectInputStream.readDouble());
            System.out.println(objectInputStream.readUTF());
            Object object = objectInputStream.readObject();
            System.out.println(object.getClass());
            Pigg pigg = (Pigg)object;
            System.out.println(pigg.toString());

        }
        catch (IOException  e) {
            throw new RuntimeException(e);
        }
//        catch (ClassNotFoundException e) {
//            throw new RuntimeException(e);
//        }
        finally {
            if(objectInputStream != null){
                try {
                    objectInputStream.close();
                } catch (IOException e) {
                    throw new RuntimeException(e);
                }
            }
        }

public class Pigg implements Serializable {
    int a;
    double b;
    public static final long serialVersionUID = 1L; //增加这个版本号，提高兼容性

    public Pigg(int a, double b) {
        this.a = a;
        this.b = b;
    }

    public int getA() {
        return a;
    }

    public void setA(int a) {
        this.a = a;
    }

    public double getB() {
        return b;
    }

    public void setB(double b) {
        this.b = b;
    }

    @Override
    public String toString() {
        return "pigg{" +
                "a=" + a +
                ", b=" + b +
                '}';
    }
}

 public static final long serialVersionUID = 1L; //增加这个版本号，提高兼容性

节点流和处理流注意事项和细节说明

1）读写顺序要一致

2)要求实现序列化或反序列化对象，需要实现 Serializable

3)序列化的类中建议添加SerialVersionUID,为了提高版本的兼容性

4)序列化对象时，默认将里面所有属性都进行序列化，但除了static或transient修饰的成员

5）序列化对象时，要求里面属性的类型也需要实现序列化接口

6）序列化具备可继承性，也就是如果某类已经实现了序列化，则它的所有子类也已经默认实现了序列化