Java对象流的作用

java的io流最常见的就是Inpustream和Outputstream了，然后又衍生出一大堆stream。其中一个就是对象流，顾名思义，对象流与对象相关。

对象流也和其它的流相似，可以缓存，也可以借助FileOutputStream写入到本地文件。

于是，通过对象流，就可以将对象克隆与持久化保存。

但是，有一个前提条件，那就是对象的类型、成员类型（不停深挖），统统都必须实现了序列化接口。

示例：

首先创建一个Teacher类并实现序列化接口：

package date0216am.对象流;

import java.io.Serializable;

public class Teacher implements Serializable{


    /** 自动生成一个UID */
    private static final long serialVersionUID = 1L;
    /** id */
    private int id;
    /** 名字 */
    private String name;
    /** 性别 */
    private String sex;
    /** 年龄 */
    private int age;
    /** 主要职务 */
    private String mainJob;

    public Teacher() {
        // TODO Auto-generated constructor stub
    }

    public Teacher(int id, String name, String sex, int age,
            String mainJob) {
        super();
        this.id = id;
        this.name = name;
        this.sex = sex;
        this.age = age;
        this.mainJob = mainJob;
    }

    public int getId() {
        return id;
    }
    public void setId(int id) {
        this.id = id;
    }
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public String getSex() {
        return sex;
    }
    public void setSex(String sex) {
        this.sex = sex;
    }
    public int getAge() {
        return age;
    }
    public void setAge(int age) {
        this.age = age;
    }
    public String getMainJob() {
        return mainJob;
    }
    public void setMainJob(String mainJob) {
        this.mainJob = mainJob;
    }
    @Override
    public String toString() {
        return "Teacher [id=" + id + ", name=" + name + ", sex=" + sex
                + ", age=" + age + ", mainJob=" + mainJob + "]";
    }
}

其次，通过对象输入流和输出流，保存对象，读取对象，克隆对象：

package date0216am.对象流;

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;
import java.io.File;
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 ObjectIO {
    public static void saveObject(Object obj,String filePath){
        File file = new File(filePath);
        try {
            FileOutputStream fos = new FileOutputStream(file);
            ObjectOutputStream oos = new ObjectOutputStream(fos);
            oos.writeObject(obj);
            oos.flush();
            oos.close();
            fos.close();
        } catch (Exception e) {
            e.printStackTrace();
        }
    }
    @SuppressWarnings("unchecked")
    public static <T>T readObject(String filePath){
        File file = new File(filePath);
        Object obj = null;
        try {
            FileInputStream fis = new FileInputStream(file);
            ObjectInputStream ois = new ObjectInputStream(fis);
            obj = ois.readObject();
            ois.close();
            fis.close();
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }
        return (T) obj;
    }
    @SuppressWarnings("unchecked")
    public static <T>T cloneObject(Object obj){
        Object objClone = null;
        try {
            ByteArrayOutputStream baos = new ByteArrayOutputStream();
            ObjectOutputStream oos = new ObjectOutputStream(baos);
            oos.writeObject(obj);//将对象通过对象输出流，缓存到数组输出流中

            oos.flush();
            byte[] objTemp = baos.toByteArray();//对象缓存为数组了

            //开始克隆
            ByteArrayInputStream bais = new ByteArrayInputStream(objTemp);
            ObjectInputStream ois = new ObjectInputStream(bais);
            objClone = ois.readObject();

            ois.close();
            bais.close();
            oos.close();
            baos.close();


        } catch (Exception e) {
            e.printStackTrace();
        }
        return (T) objClone;
    }
}

最后，测试：

package date0216am.对象流;

public class Test {

    public static void main(String[] args) throws InterruptedException {
    //new一个老师
    Teacher teacher = new Teacher(1, "李树人", "女", 23, "扫地");
    System.out.println(teacher.toString());

    //保存对象到文件中
    System.out.println("对象流保存teacher对象");
    ObjectIO.saveObject(teacher, "teacher.txt");

    //线程休眠
    System.out.println("写入完毕，可以去打开teacher.txt看看有什么东西\n");
    Thread.sleep(2500);

    //从本地文件获取并查看保存的对象
    Teacher teacherClone1 = ObjectIO.readObject("teacher.txt");
    System.out.println(teacherClone1.toString());

    if(!teacher.equals(teacherClone1)){
        System.out.println("它们确实不是同一个对象，只是内容相同\n");
    }

    //直接克隆，不写入本地
    Teacher teacherClone2 = ObjectIO.cloneObject(teacher);
    System.out.println(teacherClone2.toString());

    if (!(teacherClone2.equals(teacher) && teacherClone2.equals(teacherClone1))) {
        System.out.println("克隆体，三个都是独立的对象，只是内容相同");
    }
}
}

运行结果：

在项目工程目录下找到teacher.txt文件，打开发现一片片乱码，乱改之后读取就会出错，这就是保存到本地的对象的内容了：

 sr date0216am.瀵硅薄娴?Teacher I ageI idL mainJobt Ljava/lang/String;L nameq ~ L sexq ~ xp t 鎵湴t 鏉庢爲浜簍 濂?

——end