IO流(03)--序列化流、打印流

序列化流

Java提供了一種對象序列化的機制，用一個字節序列能夠表示一個對象，該字節序列包含該對象的數據、對象的類型和對象中存儲的屬性等信息。字節序列寫入到文件中後，就至關於在文件中保存了一個對象信息。

反之，該字節序列還能夠從文件讀取出來，重構對象，對它進行反序列化。對象的數據、對象的類型和對象中存儲的數據信息，均可以用來在內存中建立對象。

ObjectOutputStream類

java.io.ObjectOutputStream類，將Java對象的原始數據類型寫入到文件中，實現對象的持久化存儲。

構造方法

• public ObjectOutputStream(OutputStream out)：建立一個指定的OutputStream的ObjectOutputStream類對象

特有的獨有方法：

• void writeObject(Object obj)：將指定的對象寫入到ObjectOutputStream類對象中。

序列化操做

1. ​ 一個對象想要可以序列化和反序列化，必須知足兩個條件：

   • 該類必須實現java.io.Serializable接口，Serializable接口，是一個標記型接口，若是該類沒有實現Serializable接口，將會拋出NotSerializableException。

   • 該類的全部屬性必須是能夠實現序列化或者反序列化。若是有一個屬性不想讓它參與序列化，則該屬性必須標明是瞬態的，瞬時的，這個關鍵字是transient。

public class Student implements Serializable {

    private String name;
    private transient Integer age;// 不讓age屬性參與序列化
    
}

ObjectInputStream類

java.io.ObjectInputStream類是反序列化流，將以前使用ObjectOutputStream序列化流的原始數據恢復爲對象。

構造方法

• ​ public ObjectInputStream(InputStream in)：建立一個指定的InputStream的對象反序列化流對象。

特有的方法：

• ​ public final Object readObject()：從反序列化流中讀取一個對象。

對於JVM來講，可以進行反序列的對象 ，前提條件是必須可以找到class文件的類，若是找不到該類的class文件，則會拋出一個ClassNotFoundException異常。

另外，當JVM序列化對象時，可以找到class文件，可是class文件在序列化對象時，發生了修改，那麼反序列化操作會拋出一個InvalidClassException異常。緣由以下：

• 該類的序列化版本號與從流中讀取出來描述該類的版本號不一致。

• 該類包含了未知數據類型。

• 該類沒有可訪問的無參構造方法。

Serializable接口給須要序列化的類，提供了一個序列化版本號，serialVersionUID 該版本號的目的就是在於驗證序列化的對象和對應的類是不是版本一致的。

代碼演示：

// 序列化操做類
public class Demo01ObjectOutputStream {
    public static void main(String[] args) throws IOException {
        //1.建立ObjectOutputStream流對象，構造方法中傳遞指定的字節輸出流。
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("day30_IO\\student.txt"));
        //2.使用ObjectOutputStream對象中的方法writeObject,把對象寫入到文件中。
        //2.1 先建立一個對象
        Student s = new Student("小孫", 30);
        s.score = 60;
        //2.2寫對象到文件中
        oos.writeObject(s);
        //3.釋放資源。
        oos.close();
    }
}
// 反序列化類操做
public class Demo02ObjectInputStream {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        // 1. 建立一個ObjectInputStream流對象，構造方法中傳遞一個字節輸入流對象
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("day30_IO\\student.txt"));
        // 2. 使用ObjectInputStream流對象中的方法readObject，讀取保存在文件中的對象數據
        Object obj = ois.readObject();
        // 3.釋放資源。
        ois.close();
        // 4. 查看對象的數據
        System.out.println(obj);// Student{name='小孫', age=30}
        if ( obj instanceof Student) {
            Student student = (Student)obj;
            System.out.println(student.getAge() + "--" + student.getName());
        } else {
            System.out.println("轉換失敗");
        }
    }
}
// 須要被序列化的類
import java.io.Serializable;
public class Student implements Serializable {
    // 能夠選擇手動自定義一個序列化版本號
    private static final long serialVersionUID = 1L;
    //private static String name;
    private String name;
    private Integer age;
    private transient String address = "鄭州市";
    transient int score;// 0
}

原理分析：

練習：存儲一堆對象，實現序列化和反序列化動做。

import java.io.Serializable;

public class Student implements Serializable {
    // 能夠選擇手動自定義一個序列化版本號
    private static final long serialVersionUID = 1L;
    //private static String name;
    private String name;
    private Integer age;
    private transient String address = "鄭州市";
    transient int score;// 0
    public String getName() {
        return name;
    }
    public void setName(String name) {
        this.name = name;
    }
    public Integer getAge() {
        return age;
    }
    public void setAge(Integer age) {
        this.age = age;
    }
    public String getAddress() {
        return address;
    }
    public void setAddress(String address) {
        this.address = address;
    }
    public Student() {
    }
    public Student(String name, Integer age) {
        this.name = name;
        this.age = age;
        address = "鄭州市";
    }
   @Override
    public String toString() {
        return "Student{" +
                "name='" + name + '\'' +
                ", age=" + age +
                ", address='" + address + '\'' +
                ", score=" + score +
                '}';
    }
}


@SuppressWarnings("unchecked")
public class DemoTestSerialize {
    public static void main(String[] args) throws IOException, ClassNotFoundException {
        //1.定義多個對象，存儲在集合中
        ArrayList<Student> list = new ArrayList<>();
        list.add(new Student("小孫",30));
        list.add(new Student("小王",20));
        list.add(new Student("小趙",40));
        list.add(new Student("小劉",10));
        list.add(new Student("小麗",25));
        //2.使用序列化技術，把該集合對象寫入到文件中
        ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("day30_IO\\student.txt"));
        //3.寫入進去，調用writeObject
        oos.writeObject(list);
        //4.使用反序列化技術，把文件中保存的集合對象讀取出來
        ObjectInputStream ois = new ObjectInputStream(new FileInputStream("day3_IO\\student.txt"));
        //5.讀取對象數據，調用readObject()方法
        Object obj = ois.readObject();
        //6.向下轉型
        if (obj instanceof ArrayList){
            ArrayList<Student> students = (ArrayList<Student>)obj;
            //7.遍歷該集合對象
            for (Object student:students){
                System.out.println(student);
            }
        }
    }
}

打印流

java.io.PrintStream類可以很方便打印各類數據類型的值。

構造方法

• public PrintStream(String filename)：使用指定的文件名建立一個新的打印流對象。

改變打印流的方向

正常System.out就是PrintStream類型的，數據的流動的位置在控制檯中。改變數據的流動位置。經過System.setOut(PrintStream print)來改變流向。

PrintStream out = System.out;
 out.print(123);// 在控制檯中
 // 構造方法建立一個打印流對象
 PrintStream printStream = new PrintStream("day30_IO\\print.txt");
 // 改變打印流的方向爲"day30_IO\\print.txt"路徑
 System.setOut(printStream);
 System.out.println("我已經改變了輸出數據的位置");
 System.out.println("我想在控制檯中輸出數據");
 System.out.println("啦啦啦啦啦");