java 对象流

对象流

对象序列化 (Serialization)
ObjectOutputStream  ->序列化->写对象，将对象以“二进
制/字节”的形式写到（文件）
ObjectInputStream  ->反序列化 ->读对象

将 Java 对象转换成字节序列（IO 字节流）

对象反序列化 (DeSerialization)
从字节序列中恢复 Java 对象

为什么序列化
序列化以后的对象可以保存到磁盘上，也可以在网络上传输，
使得不同的计算机可以共享对象.（序列化的字节序列是平
台无关的）

对象序列化的条件
只有实现了 Serializable 接口的类的对象才可以被序列化。
Serializable 接口中没有任何的方法，实现该接口的类不需要
实现额外的方法。
如果对象的属性是对象，属性对应类也必须实现 Serializable
接口

如何实现序列化
创建 ObjectOutputStream 对象
调用 writeObject()输出对象

如何实现反序列化
创建 ObjectInputStream 对象
调用 readObject()读取对象

写个小例子说明一下

因为是对象流，肯定要用到对象，先写创建个Person类，包含姓名，年龄属性，实现get() set() toString() 有参和无参构造方法，最重要的是Person类要实现Serializable接口

import java.io.Serializable;

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;
    }
    @Override
    public String toString() {
        return "Person [name=" + name + ", 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;
    }
}

再写个测试类，先调用write()把对象从内存写入到磁盘，再调用read()把对象从磁盘读到内存

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutput;
import java.io.ObjectOutputStream;

public class TestObjectOutputStream {

    public static void main(String[] args) {
        //write();
        read();
    }
    
    public static void read() {
        //（1）创建流对象
        ObjectInputStream ois = null;
        try {
            ois = new ObjectInputStream(new FileInputStream("D:\object.txt"));
            //（2）读对象
            System.out.println(ois.readInt());
            System.out.println(ois.readUTF());
            System.out.println(ois.readObject());
        } catch (FileNotFoundException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        } catch (IOException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }finally {
            //（3）关闭流
            if(ois != null) {
                try {
                    ois.close();
                } catch (IOException e) {
                    // TODO 自动生成的 catch 块
                    e.printStackTrace();
                }
            }
        }        
    }
    
    //写对象的方法
    public static void write() {
        //（1）创建对象流对象
        ObjectOutputStream oos = null;
        try {
            oos = new ObjectOutputStream(new FileOutputStream("D:\object.txt"));
            //（2）写对象
            oos.writeInt(999);
            oos.writeUTF("shabi");
            oos.writeObject(new Person("ting",20));
        } catch (FileNotFoundException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        } catch (IOException e) {
            // TODO 自动生成的 catch 块
            e.printStackTrace();
        }finally {
            //（3）关闭流
            if(oos != null) {
                try {
                    oos.close();
                } catch (IOException e) {
                    // TODO 自动生成的 catch 块
                    e.printStackTrace();
                }
            }
        }
    }
}

序列化与反序列化

序列化与反序列化
1) 序列化能保存的元素
a) 只能保存对象的非静态成员变量
b) 不能保存任何成员方法和静态的成员变量(只是保存属性)
c) 不保存 transient 成员变量
d) 如果一个对象的成员变量是一个对象，这个对象的成 
员变量也会保存
e) 串行化保存的只是变量的值，对于变量的任何修饰符，
都不能保存

2) 使用对象流把一个对象写到文件时不仅保证该对象是序
列化的，而且该对象的成员对象也必须是可序列化的。

3) 如果一个可序列化的对象包含对某个不可序列化的对象
的引用，那么整个序列化操作将会失败，并且会抛出一个
NotSerializableException。我们可以将这个引用标记为
transient，那么对象仍然可以序列化。

写个小例子说明一下

先创建个Student类，实现Serializable接口，包含姓名、年龄、学校名称(static修饰)、密码(transient修饰)属性，还有get() set() toString() 有参(参数不含schoolName)和无参构造方法

import java.io.Serializable;

public class Student implements Serializable  {
    /**
     * 
     */
    private static final long serialVersionUID = -4502633718082654465L;
    private String name;
    private int age;
    public static String schoolName;//学校名称
    private transient String pwd; //密码 属性的值将不再被序列化
    public Student() {
        super();
    }
    public Student(String name, int age, String pwd) {
        super();
        this.name = name;
        this.age = age;
        this.pwd = pwd;
    }
    public String getPwd() {
        return pwd;
    }
    public void setPwd(String pwd) {
        this.pwd = pwd;
    }
    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 "Student [name=" + name + ", age=" + age + ", pwd=" + pwd + "]"+"schoolName="+schoolName;
    }    
}

再写个测试类，先调用write()把对象从内存写入到磁盘，再调用read()把对象从磁盘读到内存

import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.ObjectInputStream;
import java.io.ObjectOutputStream;

public class Test {
    public static void main(String[] args) {
        //调用写对象的方法
        //write();
        //调用读对象的方法
        read();
    }
    public static void write(){
        ObjectOutputStream oos=null;
        try {
            oos=new ObjectOutputStream(new FileOutputStream("E:\student.txt"));
            Student stu=new Student("marry", 20, "888888");
            Student.schoolName="JN校区";
            oos.writeObject(stu);
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            //关闭
            if(oos!=null){
                try {
                    oos.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
    public static void read(){
        ObjectInputStream ois=null;
        try {
            ois=new ObjectInputStream(new FileInputStream("E:\student.txt"));
            Student stu=(Student) ois.readObject();
            System.out.println(stu);
            //结果输出：Student [name=marry, age=20, pwd=null]schoolName=null
            //pwd为空是因为transient修饰  schoolName为空是因为是static的
        } catch (FileNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        } catch (IOException e) {
            // TODO Auto-generated catch block
            e.printStackTrace();
        }finally{
            //关闭流
            if(ois!=null){
                try {
                    ois.close();
                } catch (IOException e) {
                    // TODO Auto-generated catch block
                    e.printStackTrace();
                }
            }
        }
    }
}

对象序列化注意事项
1) 同一个对象多次序列化的处理
a) 所有保存到磁盘中的对象都有一个序列化编号
b) 序列化一个对象中，首先检查该对象是否已经序列化过

c) 如果没有，进行序列化
d) 如果已经序列化，将不再重新序列化，而是输出编号
即可

2) 如果不希望某些属性（敏感）序列化，或不希望出现递归
序列
a) 为属性添加 transient 关键字（完成排除在序列化之外）
b) 自定义序列化（不仅可以决定哪些属性不参与序列化，
还可以定义属性具体如何序列化）

3) 序列化版本不兼容
a) 修改了实例属性后,会影响版本号，从而导致反序列化
不成功
b) 解 决 方 案 ： 为 Java 对 象 指 定 序 列 化 版 本 号
serialVersionUID