Java基础：序列化&打印流

た入场券 2024-03-30 09:59 25阅读 0赞

## 第一章 序列化 ##

### 1.1 概述 ###

`Java`提供了一种对象**序列化**的机制。用一个字节序列可以表示一个对象，该字节序列包含该`对象的数据` 、`对象的类型`和`对象中存储的属性`等信息。字节序列写出到文件之后，相当于文件中**持久保存**了一个对象的信息。  
  反之，该字节序列还可以从文件中读取回来，重构对象，对它进行**反序列化**。`对象的数据`、`对象的类型`和`对象中存储的数据`信息，都可以用来在内存中创建对象。看图理解序列化：

![在这里插入图片描述][9fc7187b322742b0a9a29352ac59ea3b.png_pic_center]

### 1.2 `ObjectOutputStream`类 ###

`java.io.ObjectOutputStream`类，将`Java`对象的原始数据类型写出到文件，实现对象的持久存储。

#### 构造方法 ####

*  `public ObjectOutputStream(OutputStream out)`：创建一个指定`OutputStream`的`ObjectOutputStream`。

构造举例，代码如下：

FileOutputStream fileOut = new FileOutputStream("employee.txt");
    ObjectOutputStream out = new ObjectOutputStream(fileOut);

#### 序列化操作 ####

*  一个对象要想序列化，必须满足两个条件：
    
     *  该类必须实现`java.io.Serializable`接口，`Serializable`是一个标记接口，不实现此接口的类将不会使任何状态序列化或反序列化，会抛出`NotSerializableException`。
     *  该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的，则该属性必须注明是瞬态的，使用`transient`关键字修饰。

package com.dcxuexi.java26;
    
    import java.io.Serializable;
    
    /***
     * @Title Employee
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/16 21:47
     * @Version 1.0.0
     */
    public class Employee implements Serializable {
        
        private String name;
        private String address;
    
        private transient int age; // transient瞬态修饰成员,不会被序列化
    
        public Employee(String name, String address, int age) {
        
            this.name = name;
            this.address = address;
            this.age = age;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public String getAddress() {
        
            return address;
        }
    
        public void setAddress(String address) {
        
            this.address = address;
        }
    
        public int getAge() {
        
            return age;
        }
    
        public void setAge(int age) {
        
            this.age = age;
        }
    
        public void addressCheck(){
        
            System.out.println("Address check : " + name + " ‐‐ " + address);
        }
    }

*  写出对象方法
    
     *  `public final void writeObject (Object obj)`: 将指定的对象写出。

package com.dcxuexi.java26;
    
    import java.io.*;
    
    /***
     * @Title SerializeDemo
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/16 21:55
     * @Version 1.0.0
     */
    public class SerializeDemo {
        
        public static void main(String[] args) throws IOException {
        
    
            Employee employee = new Employee("张三","北京天安门",20);
            Employee employee2 = new Employee("zhansan","beijing",24);
            // 创建序列化流对象
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("D:\\java\\javaCode\\serialize\\employee.txt"));
            // 写出对象
            objectOutputStream.writeObject(employee);
            objectOutputStream.writeObject(employee2);
            // 释放资源
            objectOutputStream.close();
            System.out.println("Serialized data is saved"); // 姓名，地址被序列化，年龄没有被序列化。
        }
    }

![在这里插入图片描述][1c719b453c014de08cf02ab972f413da.png_pic_center]

### 1.3 `ObjectInputStream`类 ###

`ObjectInputStream`反序列化流，将之前使用`ObjectOutputStream`序列化的原始数据恢复为对象。

#### 构造方法 ####

*  `public ObjectInputStream(InputStream in)`： 创建一个指定`InputStream`的`ObjectInputStream`。

#### 反序列化操作一 ####

如果能找到一个对象的`class`文件，我们可以进行反序列化操作，调用`ObjectInputStream`读取对象的方法：

*  `public final Object readObject ()`: 读取一个对象。

package com.dcxuexi.java26;
    
    import java.io.FileInputStream;
    import java.io.IOException;
    import java.io.ObjectInputStream;
    
    /***
     * @Title DeserializeDemo
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/16 22:22
     * @Version 1.0.0
     */
    public class DeserializeDemo {
        
        public static void main(String[] args) throws IOException, ClassNotFoundException {
        
            // 创建反序列化流
            ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("D:\\java\\javaCode\\serialize\\employee.txt"));
            // 读取一个对象
            Employee employee = (Employee) objectInputStream.readObject();
            Employee employee2 = (Employee) objectInputStream.readObject();
    
            // 释放资源
            objectInputStream.close();
    
            System.out.println("Name: " + employee.getName()); // 张三
            System.out.println("Address: " + employee.getAddress()); // 北京天安门
            System.out.println("age: " + employee.getAge()); // 0
    
            System.out.println("Name: " + employee2.getName()); // zhansan
            System.out.println("Address: " + employee2.getAddress()); // beijing
            System.out.println("age: " + employee2.getAge()); // 0
        }
    }

![在这里插入图片描述][1c203d000faa4634909df3965d68e012.png_pic_center]

**对于`JVM`可以反序列化对象，它必须是能够找到`class`文件的类。如果找不到该类的`class`文件，则抛出一个`ClassNotFoundException`异常**。

#### 反序列化操作二 ####

**另外，当`JVM`反序列化对象时，能找到`class`文件，但是`class`文件在序列化对象之后发生了修改，那么反序列化操作也会失败，抛出一个`InvalidClassException` 异常。** 发生这个异常的原因如下：

*  该类的序列版本号与从流中读取的类描述符的版本号不匹配
 *  该类包含未知数据类型
 *  该类没有可访问的无参数构造方法

`Serializable`接口给需要序列化的类，提供了一个序列版本号。`serialVersionUID`该版本号的目的在于验证序列化的对象和对应类是否版本匹配。

package com.dcxuexi.java26;
    
    import java.io.Serializable;
    
    /***
     * @Title Employee2
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/17 10:27
     * @Version 1.0.0
     */
    public class Employee2  implements Serializable {
        
        // 加入序列版本号
        private static final long serialVersionUID = 1L;
        private String name;
        // transient 修饰的成员变量不参与序列化
        private transient String address;
        // 添加新的属性 ,重新编译, 可以反序列化,该属性赋为默认值.
        private int eid;
    
        public Employee2(String name, String address, int eid) {
        
            this.name = name;
            this.address = address;
            this.eid = eid;
        }
    
        public String getName() {
        
            return name;
        }
    
        public void setName(String name) {
        
            this.name = name;
        }
    
        public String getAddress() {
        
            return address;
        }
    
        public void setAddress(String address) {
        
            this.address = address;
        }
    
        public int getEid() {
        
            return eid;
        }
    
        public void setEid(int eid) {
        
            this.eid = eid;
        }
    
        @Override
        public String toString() {
        
            return "Employee2{" +
                    "name='" + name + '\'' +
                    ", address='" + address + '\'' +
                    ", eid=" + eid +
                    '}';
        }
    }

### 1.4 练习：序列化集合 ###

1.  将存有多个自定义对象的集合序列化操作，保存到`list.txt`文件中。
2.  反序列化`list.txt`，并遍历集合，打印对象信息。

#### 案例分析 ####

1.  把若干学生对象 ，保存到集合中。
2.  把集合序列化。
3.  反序列化读取时，只需要读取一次，转换为集合类型。
4.  遍历集合，可以打印所有的学生信息

#### 案例实现 ####

package com.dcxuexi.java26;
    
    import java.io.Serializable;
    
    /***
     * @Title Student
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/17 10:58
     * @Version 1.0.0
     */
    public class Student implements Serializable {
        
        private static final  long serialVersionUID = 1L; // 加入序列版本号
        private String username;
        private String loginName;
        private String passwd;
        private transient String address; // transient 修饰的成员变量不参与序列化
    
        public Student(String username, String loginName, String passwd, String address) {
        
            this.username = username;
            this.loginName = loginName;
            this.passwd = passwd;
            this.address = address;
        }
    
        public String getUsername() {
        
            return username;
        }
    
        public void setUsername(String username) {
        
            this.username = username;
        }
    
        public String getLoginName() {
        
            return loginName;
        }
    
        public void setLoginName(String loginName) {
        
            this.loginName = loginName;
        }
    
        public String getPassword() {
        
            return passwd;
        }
    
        public void setPassword(String password) {
        
            this.passwd = password;
        }
    
        public String getAddress() {
        
            return address;
        }
    
        public void setAddress(String address) {
        
            this.address = address;
        }
    
        @Override
        public String toString() {
        
            return "Student{" +
                    "username='" + username + '\'' +
                    ", loginName='" + loginName + '\'' +
                    ", passwd='" + passwd + '\'' +
                    ", address='" + address + '\'' +
                    '}';
        }
    }

package com.dcxuexi.java26;
    
    import java.io.*;
    import java.util.ArrayList;
    
    /***
     * @Title StudentSerializeDemo
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/17 11:07
     * @Version 1.0.0
     */
    public class StudentSerializeDemo {
        
        public static void main(String[] args) throws IOException, ClassNotFoundException {
        
            // 创建 学生对象
            Student student1 = new Student("张三", "zhangsan", "zs678", "南蛮");
            Student student2 = new Student("李四", "lisi", "ls321", "北疆");
            Student student3 = new Student("王五", "wangwu", "ww888", "西凉");
            Student student4 = new Student("陈六", "chenliu", "cl999", "东华");
            ArrayList<Student> studentLists = new ArrayList<Student>();
            studentLists.add(student1);
            studentLists.add(student2);
            studentLists.add(student3);
            studentLists.add(student4);
            // 序列化操作
            serializ(studentLists);
            // 反序列化
            deSerializ();
        }
    
        // 序列化 方法
        public static void serializ(ArrayList<Student> studentLists) throws IOException {
        
            // 创建序列化流对象
            ObjectOutputStream objectOutputStream = new ObjectOutputStream(new FileOutputStream("D:\\java\\javaCode\\serialize\\Student.txt"));
            // 写出对象
            objectOutputStream.writeObject(studentLists);
            // 释放资源
            objectOutputStream.close();
        }
    
        // 反序列 方法
        public static void deSerializ() throws IOException, ClassNotFoundException {
        
            // 创建反序列化流
            ObjectInputStream objectInputStream = new ObjectInputStream(new FileInputStream("D:\\java\\javaCode\\serialize\\Student.txt"));
            // 读取一个对象
            ArrayList<Student> studentLists = (ArrayList<Student>)objectInputStream.readObject();
            // 释放资源
            objectInputStream.close();
            // 打印
            studentLists.forEach(System.out::println);
        }
    }

![在这里插入图片描述][e50d92b4b5a3437f9d8f9ba7241ec864.png_pic_center]

## 第二章 打印流 ##

### 2.1 概述 ###

平时我们在控制台打印输出，是调用`print`方法和`println`方法完成的，这两个方法都来自于`java.io.PrintStream`类，该类能够方便地打印各种数据类型的值，是一种便捷的输出方式。

### 2.2 `PrintStream`类 ###

#### **构造方法** ####

*  `public PrintStream(String fileName)`：使用指定的文件名创建一个新的打印流。

构造举例，代码如下：

PrintStream ps = new PrintStream("ps.txt")；

#### 改变打印流向 ####

`System.out`就是`PrintStream`类型的，只不过它的流向是系统规定的，打印在控制台上。不过，既然是流对象，那我们就可以改变它的流向。

package com.dcxuexi.java26;
    
    import java.io.FileNotFoundException;
    import java.io.PrintStream;
    
    /***
     * @Title PrintStreamDemo
     * @Description TOTD
     * @Auter DongChuang
     * @Date 2022/12/17 11:31
     * @Version 1.0.0
     */
    public class PrintStreamDemo {
        
        public static void main(String[] args) throws FileNotFoundException {
        
            // 调用系统的打印流,控制台直接输出97
            System.out.println(97);
            // 创建打印流,指定文件的名称
            PrintStream printStream = new PrintStream("D:\\java\\javaCode\\serialize\\printStream.txt");
            // 设置系统的打印流流向,输出到printStream.txt
            System.setOut(printStream);
            // 调用系统的打印流,printStream.txt中输出97。。。
            System.out.println(97);
            System.out.println("我爱北京天安门~~~");
        }
    }

![在这里插入图片描述][813b7683a24e4952bc36f64c987ddbdb.png_pic_center]

[9fc7187b322742b0a9a29352ac59ea3b.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/9fb47b27759a4839872190040a3e6cf0.png
[1c719b453c014de08cf02ab972f413da.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/b155a51c84664ab2b559d7ab52a1085c.png
[1c203d000faa4634909df3965d68e012.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/4136b424be024b8db478d557acf33af4.png
[e50d92b4b5a3437f9d8f9ba7241ec864.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/baad347978e04016b1afb183ec068705.png
[813b7683a24e4952bc36f64c987ddbdb.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/30/db0d28042c5949a48f63a6e0deb3043d.png