【大数据】学习笔记 1 Java SE 第14章 File类与IO流 14.7 数据流与对象流

阳光穿透心脏的1/2处 2024-03-22 14:29 61阅读 0赞

### 【大数据】学习笔记 ###

#### 文章目录 ####

*   *  【大数据】学习笔记
     *   *  1 Java SE
         *   *  第14章 File类与IO流
             *   *  14.7 数据流与对象流
                 *   *  14.7.1 使用对象流读写各种类型的数据
                     *  14.7.2 序列化与反序列化概念
                     *  14.7.3 Serializable序列化接口与transient关键字
                     *  14.7.4 反序列化失败问题
                     *  14.7.5 序列化多个对象

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

#### 1 Java SE ####

##### 第14章 File类与IO流 #####

###### 14.7 数据流与对象流 ######

前面学习的IO流，在程序代码中，要么将数据直接按照字节处理，要么按照字符处理。那么，如果读写Java其他数据类型的数据，怎么办呢？

String name = “巫师”;
    int age = 300;
    char gender = ‘男’;
    int energy = 5000;
    double price = 75.5;
    boolean relive = true;
    
    Student stu = new Student("张三",23,89);

Java提供了数据流和对象流来处理这些类型的数据：

*  DataOutputStream：数据输出流允许应用程序以适当方式将基本 Java 数据类型写入输出流中。然后，应用程序可以使用数据输入流（DataInputStream）将数据读入。
 *  DataInputStream：数据输入流允许应用程序以与机器无关方式从底层输入流中读取基本 Java 数据类型。
 *  ObjectOutputStream：将 Java 基本数据类型和对象写入字节输出流中。稍后可以使用 ObjectInputStream 将数据读入。通过在流中使用文件可以实现Java各种基本数据类型的数据以及对象的持久存储。如果流是网络套接字流，则可以在另一台主机上或另一个进程中接收这些数据或重构对象。
 *  ObjectInputStream：ObjectInputStream 对以前使用 ObjectOutputStream 写入的基本数据和对象进行反序列化。

因为DataOutputStream和DataInputStream只支持Java基本数据类型和字符串的读写，而不支持Java对象的对象。而ObjectOutputStream和ObjectInputStream既支持Java基本数据类型的数据读写，又支持Java对象的读写，所以下面直接介绍对象流ObjectOutputStream和ObjectInputStream即可。

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

构造举例，代码如下：

FileOutputStream fos = new FileOutputStream("game.dat");
    ObjectOutputStream oos = new ObjectOutputStream(fos);

FileInputStream fis = new FileInputStream("game.dat");
    ObjectInputStream ois = new ObjectInputStream(fis);

###### 14.7.1 使用对象流读写各种类型的数据 ######

ObjectOutpuStream也从OutputStream父类中继承基本方法：

*  `public void write(int b)` ：将指定的字节输出流。虽然参数为int类型四个字节，但是只会保留一个字节的信息写出。
 *  `public void write(byte[] b)`：将 b.length字节从指定的字节数组写入此输出流。
 *  `public void write(byte[] b, int off, int len)` ：从指定的字节数组写入 len字节，从偏移量 off开始输出到此输出流。
 *  `public void flush()` ：刷新此输出流并强制任何缓冲的输出字节被写出。
 *  `public void close()` ：关闭此输出流并释放与此流相关联的任何系统资源。

还支持将各种Java数据类型的数据写入输出流中：

*  public void writeBoolean(boolean val)：写入一个 boolean 值。
 *  public void writeByte(int val)：写入一个8位字节。
 *  public void writeShort(int val)：写入一个16位的 short 值。
 *  public void writeChar(int val)：写入一个16位的 char 值。
 *  public void writeInt(int val)：写入一个32位的 int 值。
 *  public void writeLong(long val)：写入一个64位的 long 值。
 *  public void writeFloat(float val)：写入一个32位的 float 值。
 *  public void writeDouble(double val)：写入一个64位的 double 值。
 *  public void writeUTF(String str)：将表示长度信息的两个字节写入输出流，后跟字符串 s 中每个字符的 UTF-8 修改版表示形式。如果 s 为 null，则抛出 NullPointerException。根据字符的值，将字符串 s 中每个字符转换成一个字节、两个字节或三个字节的字节组。注意，将 String 作为基本数据写入流中与将它作为 Object 写入流中明显不同。

ObjectInputStream除了从InputStream父类中继承基本方法之外，

*  `public int read()`： 从输入流读取一个字节。返回读取的字节值。虽然读取了一个字节，但是会自动提升为int类型。如果已经到达流末尾，没有数据可读，则返回-1。
 *  `public int read(byte[] b)`： 从输入流中读取一些字节数，并将它们存储到字节数组 b中 。每次最多读取b.length个字节。返回实际读取的字节个数。如果已经到达流末尾，没有数据可读，则返回-1。
 *  `public int read(byte[] b,int off,int len)`：从输入流中读取一些字节数，并将它们存储到字节数组 b中，从b\[off\]开始存储，每次最多读取len个字节 。返回实际读取的字节个数。如果已经到达流末尾，没有数据可读，则返回-1。
 *  `public void close()` ：关闭此输入流并释放与此流相关联的任何系统资源。

还支持从输入流中读取各种Java数据类型的数据：

*  public boolean readBoolean()：读取一个 boolean 值。
 *  public byte readByte()：读取一个 8 位的字节。
 *  public short readShort()：读取一个 16 位的 short 值。
 *  public char readChar()：读取一个 16 位的 char 值。
 *  public int readInt()：读取一个 32 位的 int 值。
 *  public long readLong()：读取一个 64 位的 long 值。
 *  public float readFloat()：读取一个 32 位的 float 值。
 *  public double readDouble()：读取一个 64 位的 double 值。
 *  public String readUTF()：读取 UTF-8 修改版格式的 String。

> 注意：读的顺序和方法与写的顺序和方法要一一对应。

示例代码：

package com.dingjiaxiong.object;
    
    import org.junit.Test;
    
    import java.io.*;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: ReadWriteDataOfAnyType
     * @Author: Ding Jiaxiong
     * @Date:2023/4/28 13:41
     */
    
    public class ReadWriteDataOfAnyType {
        
        @Test
        public void save() throws IOException {
        
            String name = "巫师";
            int age = 300;
            char gender = '男';
            int energy = 5000;
            double price = 75.5;
            boolean relive = true;
    
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("game.dat"));
            oos.writeUTF(name);
            oos.writeInt(age);
            oos.writeChar(gender);
            oos.writeInt(energy);
            oos.writeDouble(price);
            oos.writeBoolean(relive);
            oos.close();
        }
    
        @Test
        public void reload() throws IOException {
        
            ObjectInputStream ois = new ObjectInputStream(new FileInputStream("game.dat"));
            String name = ois.readUTF();
            int age = ois.readInt();
            char gender = ois.readChar();
            int energy = ois.readInt();
            double price = ois.readDouble();
            boolean relive = ois.readBoolean();
    
            System.out.println(name + "," + age + "," + gender + "," + energy + "," + price + "," + relive);
    
            ois.close();
        }
    }

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

加载回来

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

###### 14.7.2 序列化与反序列化概念 ######

Java 提供了一种对象**序列化**的机制。用一个字节序列可以表示一个对象，该字节序列包含该`对象的类型`和`对象中存储的属性`等信息。字节序列写出到文件之后，相当于文件中**持久保存**了一个对象的信息。

反之，该字节序列还可以从文件中读取回来，重构对象，对它进行**反序列化**。`对象的数据`、`对象的类型`和`对象中存储的数据`信息，都可以用来在内存中创建对象。看图理解序列化：

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

ObjectOutputStream流中支持序列化的方法是：

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

ObjectInputStream流中支持反序列化的方法是：

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

###### 14.7.3 Serializable序列化接口与transient关键字 ######

某个类的对象需要序列化输出时，该类必须实现`java.io.Serializable` 接口，`Serializable` 是一个标记接口，不实现此接口的类将不会使任何状态序列化或反序列化，会抛出`NotSerializableException` 。

*  如果对象的某个属性也是引用数据类型，那么如果该属性也要序列化的话，也要实现`Serializable` 接口
 *  该类的所有属性必须是可序列化的。如果有一个属性不需要可序列化的，则该属性必须注明是瞬态的，使用`transient` 关键字修饰。
 *  静态变量的值不会序列化。因为静态变量的值不属于某个对象。

package com.dingjiaxiong.object;
    
    import java.io.Serializable;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: Employee
     * @Author: Ding Jiaxiong
     * @Date:2023/4/28 13:43
     */
    
    public class Employee implements Serializable {
        
        public static String company; //static修饰的类变量，不会被序列化
        public String name;
        public String address;
        public transient int age; // transient瞬态修饰成员,不会被序列化
    
        public Employee(String name, String address, int age) {
        
            this.name = name;
            this.address = address;
            this.age = age;
        }
    
        public static String getCompany() {
        
            return company;
        }
    
        public static void setCompany(String company) {
        
            Employee.company = company;
        }
    
        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;
        }
    
        @Override
        public String toString() {
        
            return "Employee{" +
                    "name='" + name + '\'' +
                    ", address='" + address + '\'' +
                    ", age=" + age +
                    ", company=" + company +
                    '}';
        }
    }

package com.dingjiaxiong.object;
    
    import org.junit.Test;
    
    import java.io.*;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: ReadWriteObject
     * @Author: Ding Jiaxiong
     * @Date:2023/4/28 13:43
     */
    
    public class ReadWriteObject {
        
        @Test
        public void save() throws IOException {
        
            Employee.setCompany("尚硅谷");
            Employee e = new Employee("张三", "宏福苑", 23);
            // 创建序列化流对象
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("employee.dat"));
            // 写出对象
            oos.writeObject(e);
            // 释放资源
            oos.close();
            System.out.println("Serialized data is saved"); // 姓名，地址被序列化，年龄没有被序列化。
        }
    
        @Test
        public void reload() throws IOException, ClassNotFoundException {
        
            // 创建反序列化流
            FileInputStream fis = new FileInputStream("employee.dat");
            ObjectInputStream ois = new ObjectInputStream(fis);
            // 读取一个对象
            Employee e = (Employee) ois.readObject();
            // 释放资源
            ois.close();
            fis.close();
    
            System.out.println(e);
        }
    
        @Test
        public void writeString() throws IOException {
        
            ObjectOutputStream oos1 = new ObjectOutputStream(new FileOutputStream("str1.dat"));
            oos1.writeUTF("atguigu");
            oos1.writeInt(1);
            oos1.close();
    
            ObjectOutputStream oos2 = new ObjectOutputStream(new FileOutputStream("str2.dat"));
            oos2.writeObject("atguigu");
            oos2.writeObject(1);
            oos2.close();
        }
    }

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

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

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

###### 14.7.4 反序列化失败问题 ######

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

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

*  该类的序列版本号与从流中读取的类描述符的版本号不匹配
 *  该类包含未知数据类型

`Serializable` 接口给需要序列化的类，提供了一个序列版本号。`serialVersionUID` 该版本号的目的在于验证序列化的对象和对应类是否版本匹配。如果没有声明serialVersionUID，则每次编译都会产生新的serialVersionUID序列化版本ID值，这样如果在序列化完成之后修改了类导致类重新编译，则原来的数据将无法反序列化。所以通常我们都会在实现Serializable接口时，声明一个serialVersionUID，并为其指定一个值。serialVersionUID必须是static和final修饰的long类型的数据，它的值由程序员随意指定即可。

如果声明了serialVersionUID，即使在序列化完成之后修改了类导致类重新编译，则原来的数据也能正常反序列化，只是新增的字段值是默认值而已。

package com.dingjiaxiong.object;
    
    import java.io.Serializable;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: Employee
     * @Author: Ding Jiaxiong
     * @Date:2023/4/28 13:43
     */
    
    public class Employee implements Serializable {
        
        private static final long serialVersionUID = 1L; //增加serialVersionUID
        public static String company; //static修饰的类变量，不会被序列化
        public String name;
        public String address;
        public transient int age; // transient瞬态修饰成员,不会被序列化
    
        public Employee(String name, String address, int age) {
        
            this.name = name;
            this.address = address;
            this.age = age;
        }
    
        public static String getCompany() {
        
            return company;
        }
    
        public static void setCompany(String company) {
        
            Employee.company = company;
        }
    
        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;
        }
    
        @Override
        public String toString() {
        
            return "Employee{" +
                    "name='" + name + '\'' +
                    ", address='" + address + '\'' +
                    ", age=" + age +
                    ", company=" + company +
                    '}';
        }
    }

###### 14.7.5 序列化多个对象 ######

如果有多个对象需要序列化，则可以将对象放到集合中，再序列化集合对象即可。

package com.dingjiaxiong.object;
    
    import org.junit.Test;
    
    import java.io.*;
    import java.util.ArrayList;
    
    /**
     * @Projectname: BigDataStudy
     * @Classname: ReadWriteCollection
     * @Author: Ding Jiaxiong
     * @Date:2023/4/28 13:45
     */
    
    public class ReadWriteCollection {
        
        @Test
        public void save() throws IOException {
        
            ArrayList<Employee> list = new ArrayList<>();
            list.add(new Employee("张三", "宏福苑", 23));
            list.add(new Employee("李四", "白庙", 24));
            list.add(new Employee("王五", "平西府", 25));
            // 创建序列化流对象
            ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream("employees.dat"));
            // 写出对象
            oos.writeObject(list);
            // 释放资源
            oos.close();
        }
    
        @Test
        public void reload() throws IOException, ClassNotFoundException {
        
            // 创建反序列化流
            FileInputStream fis = new FileInputStream("employees.dat");
            ObjectInputStream ois = new ObjectInputStream(fis);
            // 读取一个对象
            ArrayList<Employee> list = (ArrayList<Employee>) ois.readObject();
            // 释放资源
            ois.close();
            fis.close();
    
            System.out.println(list);
        }
    }

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

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

[5c8fdf6101f04abe92a47baf173dc9cf.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/1b7929c5e7c44c10bb5ba4e70dc41367.png
[a8ae5d3253e74175ab97a94ce1b660ff.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/7f8e411aad854e4d857d3037bc46ed24.png
[d5ffb6cd297d446b9e92f4fcea3779a7.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/c7d79ab58990401aa191027fcb2fbd6c.png
[225f98d5df0d4f9c9952f6fcf72e7995.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/02d127ed58ac4810b401aa928420bd6a.png
[ba2a0a2d7e7244399d93d06f2b5ccf2a.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/a8ae0626f18144c3985e6a2c44f2c7c9.png
[cf43a57b78bf40d892d682f884db5392.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/36486526d5604350b22782527838fec7.png
[f3f62e4f50104768a8066b7312c3ae67.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/14636b547d58479a925a64b5227283ad.png
[457339c36be641bdbfb9651c7b6da63b.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/ace6e5f2365c4f38ba86be3d9f5c8a35.png
[e21945a739f248cd9a27f25b251392c6.png_pic_center]: https://image.dandelioncloud.cn/pgy_files/images/2024/03/22/ce70f027f3264fbd8fca6f950e9f9a2a.png