ObjectInputStream 和 ObjectOutStream流

1. 簡介

對象流：ObjectInputStream 和 ObjectOutStream，DataInputStream/DataOutputStream流隻是解決了Java8種基礎資料類型的流，而對象流不僅僅有讀寫Java的8種基礎資料類型還可以将一個執行個體化的對象寫入磁盤。

序列化：将一個執行個體化對象寫入磁盤叫做序列化。
反序列化：将一個寫入磁盤的的執行個體化讀取出來轉化為一個對象叫做反序列化。
需要序列化的對象類一定要實作Serializable接口。

2. 序列化(ObjectOutputStream)

ObjectOutputStream流是一個位元組流，是以它是基于位元組的。構造方法裡面需要傳入一個OutputStream對象。
ObjectOutputStream流和DataOutputStream流一樣，寫入檔案的資料會出現亂碼的情況。
需要執行個體化的類一定要實作Serializable接口。

import java.io.*;
/*
    ObjectOutputStream實作對象的序列化
    需要序列化的對象類一定要實作Serializable接口
 */
class Student implements Serializable {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        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 "Student{" + "name='" + name + '\'' + ", age=" + age + '}';
    }
}

public class Demo01 {
    public static void main(String[] args) {
        try {
            ObjectOutputStream oos = new ObjectOutputStream(
                    new FileOutputStream("C:\\Users\\Splay\\Desktop\\IO\\stu.txt"));
            Student zhangsan = new Student("zhangsan",22);
            oos.writeObject(zhangsan);
            oos.flush();
            System.out.println("序列化完成!");
            oos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

ObjectInputStream 和 ObjectOutStream流

3. 反序列化(ObjectInputStream流)

import java.io.*;
class Student implements Serializable {
    private String name;
    private int age;

    public Student() {
    }

    public Student(String name, int age) {
        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 "Student{" + "name='" + name + '\'' + ", age=" + age + '}';
    }
}

public class Demo01 {
    public static void main(String[] args) {
        try{
            ObjectOutputStream oos = new ObjectOutputStream(
                    new FileOutputStream("C:\\Users\\Splay\\Desktop\\IO\\stu.txt"));
            Student zhangsan = new Student("zhangsan",22);
            oos.writeObject(zhangsan);
            System.out.println("序列化完成!");

            ObjectInputStream ois = new ObjectInputStream(
                    new FileInputStream("C:\\Users\\Splay\\Desktop\\IO\\stu.txt"));
            Student s = (Student) ois.readObject();

            ois.close();
            System.out.println(s.toString());
            System.out.println("反序列化完成!");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

    }
}

ObjectInputStream 和 ObjectOutStream流

4. 序列化和反序列化注意事項

序列化的類一定要實作Serializable接口。
序列化類中的對象屬性也要求實作Serializable接口。

import java.io.*;
class Person{

}
class Student implements Serializable {
    private String name;
    private int age;
    private Person person;
    public Student(String name, int age,Person person) {
        this.name = name;
        this.age = age;
        this.person = person;
    }

    @Override
    public String toString() {
        return "Student{" + "name='" + name + '\'' + ", age=" + age + ", person=" + person + '}';
    }
}

public class Demo01 {
    public static void main(String[] args) {
        try{
            ObjectOutputStream oos = new ObjectOutputStream(
                    new FileOutputStream("C:\\Users\\Splay\\Desktop\\IO\\stu.txt"));
            Student zhangsan = new Student("zhangsan",22,new Person());
            oos.writeObject(zhangsan);
            System.out.println("序列化完成!");

            ObjectInputStream ois = new ObjectInputStream(
                    new FileInputStream("C:\\Users\\Splay\\Desktop\\IO\\stu.txt"));
            Student s = (Student) ois.readObject();

            ois.close();
            System.out.println(s.toString());
            System.out.println("反序列化完成!");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

    }
}

ObjectInputStream 和 ObjectOutStream流

serialVersionUID是序列化版本号ID，用來保證序列化的類和反序列化的類是同一個。如果反序列化和序列化寫入的ID不比對那麼會報出異常。

import java.io.*;
class Student implements Serializable {

    private static final long serialVersionUID = 50L;
    private String name;
    private int age;
    public Student(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student{" + "name='" + name + '\'' + ", age=" + age + '}';
    }
}

public class Demo01 {
    public static void main(String[] args) {
        try{

            //最開始已經寫入一個沒有設定serialVersionUID的 Student{name='zhangsan', age=22}
            //然後我們設定serialVersionUID = 50L   再去反序列化
            ObjectInputStream ois = new ObjectInputStream(
                    new FileInputStream("C:\\Users\\Splay\\Desktop\\IO\\stu.txt"));
            Student s = (Student) ois.readObject();

            ois.close();
            System.out.println(s.toString());
            System.out.println("反序列化完成!");
        } catch (FileNotFoundException e) {
            e.printStackTrace();
        } catch (IOException e) {
            e.printStackTrace();
        } catch (ClassNotFoundException e) {
            e.printStackTrace();
        }

    }
}

ObjectInputStream 和 ObjectOutStream流

transient修飾的屬性和 static修飾的屬性無法被序列化。

import java.io.*;

class Student3 implements Serializable {

    private static final long serialVersionUID = 50L;
    private String name;
    private int age;
    private transient int id;
    private static String classname = "一班";
    public Student3(String name, int age, int id) {
        this.name = name;
        this.age = age;
        this.id = id;
    }

    @Override
    public String toString() {
        return "Student3{" + "name='" + name + '\'' + ", age=" + age + ", id=" + id + '}';
    }
}
public class Demo03 {
    public static void main(String[] args) {
        try{
            ObjectOutputStream oos = new ObjectOutputStream(
                    new FileOutputStream("C:\\Users\\Splay\\Desktop\\IO\\stu.txt"));
            Student3 zhangsan = new Student3("zhangsan",22,1);
            oos.writeObject(zhangsan);
            System.out.println("序列化完成!");

            ObjectInputStream ois = new ObjectInputStream(
                    new FileInputStream("C:\\Users\\Splay\\Desktop\\IO\\stu.txt"));
            Student3 s = (Student3) ois.readObject();

            ois.close();
            System.out.println(s.toString());
            System.out.println("反序列化完成!");
        } catch (Exception e){
            e.printStackTrace();
        }
    }
}

ObjectInputStream 和 ObjectOutStream流

序列化多個對象可以使用一些實作了Serializable接口的集合類來完成。比如ArrayList類。

import java.io.*;
import java.util.ArrayList;

class Student4 implements Serializable {

    private static final long serialVersionUID = 50L;
    private String name;
    private int age;
    public Student4(String name, int age) {
        this.name = name;
        this.age = age;
    }

    @Override
    public String toString() {
        return "Student4{" + "name='" + name + '\'' + ", age=" + age + '}';
    }
}
public class Demo04 {
    public static void main(String[] args) {
        try{
            ObjectOutputStream oos = new ObjectOutputStream(
                    new FileOutputStream("C:\\Users\\Splay\\Desktop\\IO\\stu.txt"));
            Student4 zhangsan = new Student4("zhangsan",22);
            Student4 lisi = new Student4("lisi",21);


            ArrayList<Student4> list = new ArrayList<>();
            list.add(zhangsan);
            list.add(lisi);

            oos.writeObject(list);
            System.out.println("序列化完成!");

            ObjectInputStream ois = new ObjectInputStream(
                    new FileInputStream("C:\\Users\\Splay\\Desktop\\IO\\stu.txt"));
            list = (ArrayList<Student4>)ois.readObject();
            System.out.println(list.toString());
            System.out.println("反序列化完成!");
            ois.close();
        } catch (Exception e){
            e.printStackTrace();
        }
    }
}

ObjectInputStream 和 ObjectOutStream流

ObjectInputStream 和 ObjectOutStream流

1. 簡介

2. 序列化(ObjectOutputStream)

3. 反序列化(ObjectInputStream流)

4. 序列化和反序列化注意事項

繼續閱讀

[Java基礎]-- java 建立檔案夾

拷貝文本檔案

Java I/OJava I/O

JAVA中常用IO流類：FileReader和FileWriter

【Java】IO ---- RandomAccessFile

Java IO RandomAccessFile 類随機通路流的使用細節詳解

檔案的讀寫，java中的IO

java的讀寫檔案IO操作

Java Util：Zip批量下載下傳&檔案打包

Java IO - PushbackInputStream&PushbackReader

（九）字元輸入流/輸出流

Java IO - InputStream&OutputStream

java io流之OutputStream

源碼剖析之java.io.OutputStream

Java IO：BIO和NIO差別及各自應用場景

Java IO檔案操作類 File