• IO流的讲解（3）

    目录

    处理流-BufferedInputStream和BufferedOutputStream

    BufferedInputStream介绍

    BufferedOutputStream介绍

    处理流的应用实例

    对象流

    序列化和反序列化

    基本介绍

    应用案例1

    应用案例2

    序列化和反序列化的注意事项和细节说明

    标准输入输出流

    转换流

    乱码问题

    处理流-BufferedInputStream和BufferedOutputStream

    在Java中，BufferedInputStream和BufferedOutputStream是两个非常重要的类，它们的主要作用是提高I/O性能。接下来看看

    BufferedInputStream介绍

    BufferedInputStream类是为了提高读取效率而设计的。它在内部维护了一个缓冲区，每次从输入流中读取数据时，它会将数据读入到缓冲区中。然后，它将返回缓冲区中的数据而不是每次直接从输入流中读取数据。这可以大大减少访问底层输入流的次数，从而提高读取效率。

    BufferedOutputStream介绍

    BufferedOutputStream类也是为了提高写入效率而设计的。它在内部维护了一个缓冲区，每次进行写入操作时，它会将数据先写入到缓冲区中，然后再一次性将缓冲区中的数据写出到底层输出流中。这样可以减少写入操作对底层输出流的访问次数，从而提高写入效率。

    相比于直接使用底层输入输出流，使用BufferedInputStream和BufferedOutputStream类能够提高I/O操作的效率和性能。

    处理流的应用实例

    代码演示：

    和之前的读取文件一样，定义要读取文件的路径和写入到哪个文件，这里我们拷贝的是二进制文件，也就是音频等文件

    1. package com.outputstream_;
    2.  
    3. import com.reader_.BufferedReader_;
    4. import com.sun.xml.internal.org.jvnet.mimepull.MIMEConfig;
    5.  
    6. import java.io.*;
    7.  
    8. /**
    9.  * 演示使用BufferedOutputStream 和 BufferedInputStream使用
    10.  * 使用他们，可以完成二进制文件拷贝.
    11.  * 思考：字节流可以操作二进制文件，可以操作文本文件吗？当然可以
    12.  */
    13. public class BufferedCopy02 {
    14.     public static void main(String[] args) {
    15.  
    16. //        String srcFilePath = "e:\\Koala.jpg";
    17.         String srcFilePath = "e:\\asd.java";
    18.         String destFilePath = "e:\\a1.java";
    19.  
    20.         //创建BufferedOutputStream对象BufferedInputStream对象
    21.         BufferedInputStream bis = null;
    22.         BufferedOutputStream bos = null;
    23.  
    24.         try {
    25.             //因为 FileInputStream  是 InputStream 子类
    26.             bis = new BufferedInputStream(new FileInputStream(srcFilePath));
    27.             bos = new BufferedOutputStream(new FileOutputStream(destFilePath));
    28.  
    29.             //循环的读取文件，并写入到 destFilePath
    30.             byte[] buff = new byte[1024];
    31.             int readLen = 0;
    32.             //当返回 -1 时，就表示文件读取完毕
    33.             while ((readLen = bis.read(buff)) != -1) {
    34.                 bos.write(buff, 0, readLen);
    35.             }
    36.  
    37.             System.out.println("文件拷贝完毕~~~");
    38.  
    39.         } catch (IOException e) {
    40.             e.printStackTrace();
    41.         } finally {
    42.  
    43.             //关闭流 , 关闭外层的处理流即可，底层会去关闭节点流
    44.             try {
    45.                 if (bis != null) {
    46.                     bis.close();
    47.                 }
    48.                 if (bos != null) {
    49.                     bos.close();
    50.                 }
    51.             } catch (IOException e) {
    52.                 e.printStackTrace();
    53.             }
    54.  
    55.         }
    56.     }
    57. }

    对象流

    对象流-ObjectInputStream和ObjectOutputStream

    序列化和反序列化

    1.序列化就是在保存数据时，保存数据的值和数据类型

    2.反序列化就是在恢复数据时，恢复数据的值和数据类型

    3.需要让某个对象支持序列化机制，则必须让其类是可序列化的，为了让某个类是可序列化的，该类必须实现如下两个接口之

    -Serializable// 这是一个标记接口，没有方法

    Externalizable // 该接口有方法需要实现，因此我们一般实现上面的 Serializable接口

    基本介绍

    1.功能:提供了对基本类型或对象类型的序列化和反序列化的方法

    2.ObjectOutputStream 提供 序列化功能

    3.ObjectInputStream 提供 反序列化功能

    应用案例1

    完成文件的序列化

    代码演示：

    如果需要序列化某个类的对象，实现 Serializable接口，在序列化对象时，默认将里面所有属性都进行序列化，但除了static或transient修饰的成员，序列化对象时，要求里面属性的类型也需要实现序列化接口，然后使用ObjectOutputStream序列化文件

    1. package com.outputstream_;
    2.  
    3. import java.io.FileNotFoundException;
    4. import java.io.FileOutputStream;
    5. import java.io.ObjectOutputStream;
    6.  
    7. /**
    8.  * 演示ObjectOutputStream的使用, 完成数据的序列化
    9.  */
    10. public class ObjectOutStream_ {
    11.     public static void main(String[] args) throws Exception {
    12.         //序列化后，保存的文件格式，不是存文本，而是按照他的格式来保存
    13.         String filePath = "e:\\data.dat";
    14.  
    15.         ObjectOutputStream oos = new ObjectOutputStream(new FileOutputStream(filePath));
    16.  
    17.         //序列化数据到 e:\data.dat
    18.         oos.writeInt(100);// int -> Integer (实现了 Serializable)
    19.         oos.writeBoolean(true);// boolean -> Boolean (实现了 Serializable)
    20.         oos.writeChar('a');// char -> Character (实现了 Serializable)
    21.         oos.writeDouble(9.5);// double -> Double (实现了 Serializable)
    22.         oos.writeUTF("你好");//String
    23.         //保存一个dog对象
    24.         oos.writeObject(new Dog("旺财", 10, "日本", "白色"));
    25.         oos.close();
    26.         System.out.println("数据保存完毕(序列化形式)");
    27.  
    28.  
    29.     }
    30. }
    31.  
    32. package com.outputstream_;
    33.  
    34. import java.io.Serializable;
    35.  
    36. //如果需要序列化某个类的对象，实现 Serializable
    37. public class Dog implements Serializable {
    38.     private String name;
    39.     private int age;
    40.     //序列化对象时，默认将里面所有属性都进行序列化，但除了static或transient修饰的成员
    41.     private static String nation;
    42.     private transient String color;
    43.     //序列化对象时，要求里面属性的类型也需要实现序列化接口
    44.     private Master master = new Master();
    45.  
    46.     //serialVersionUID 序列化的版本号，可以提高兼容性
    47.     private static final long serialVersionUID = 1L;
    48.  
    49.     public Dog(String name, int age, String nation, String color) {
    50.         this.name = name;
    51.         this.age = age;
    52.         this.color = color;
    53.         this.nation = nation;
    54.     }
    55.  
    56.     @Override
    57.     public String toString() {
    58.         return "Dog{" +
    59.                 "name='" + name + '\'' +
    60.                 ", age=" + age +
    61.                 ", color='" + color + '\'' +
    62.                 '}' + nation + " " +master;
    63.     }
    64.  
    65.     public String getName() {
    66.         return name;
    67.     }
    68.  
    69.     public void setName(String name) {
    70.         this.name = name;
    71.     }
    72.  
    73.     public int getAge() {
    74.         return age;
    75.     }
    76.  
    77.     public void setAge(int age) {
    78.         this.age = age;
    79.     }
    80. }

    应用案例2

    反序列化

    代码演示：

    在反序列化的时候，要注意，反序列化的时候，读取(反序列化)的顺序需要和你保存数据(序列化)的顺序一致，否则会有异常

    1. package com.inputstream_;
    2.  
    3. import com.outputstream_.Dog;
    4.  
    5. import java.io.FileInputStream;
    6. import java.io.IOException;
    7. import java.io.ObjectInputStream;
    8.  
    9. public class ObjectInputStream_ {
    10.     public static void main(String[] args) throws IOException, ClassNotFoundException {
    11.  
    12.         //指定反序列化的文件
    13.         String filePath = "e:\\data.dat";
    14.  
    15.         ObjectInputStream ois = new ObjectInputStream(new FileInputStream(filePath));
    16.  
    17.         //读取
    18.         //解读
    19.         //1. 读取(反序列化)的顺序需要和你保存数据(序列化)的顺序一致
    20.         //2. 否则会出现异常
    21.  
    22.         System.out.println(ois.readInt());
    23.         System.out.println(ois.readBoolean());
    24.  
    25.         System.out.println(ois.readChar());
    26.         System.out.println(ois.readDouble());
    27.         System.out.println(ois.readUTF());
    28.  
    29.  
    30.         //dog 的编译类型是 Object , dog 的运行类型是 Dog
    31.         Object dog = ois.readObject();
    32.         System.out.println("运行类型=" + dog.getClass());
    33.         System.out.println("dog信息=" + dog);//底层 Object -> Dog
    34.  
    35.         //这里是特别重要的细节:
    36.  
    37.         //1. 如果我们希望调用Dog的方法, 需要向下转型
    38.         //2. 需要我们将Dog类的定义，放在到可以引用的位置
    39.         Dog dog2 = (Dog)dog;
    40.         System.out.println(dog2.getName()); //旺财..
    41.  
    42.         //关闭流, 关闭外层流即可，底层会关闭 FileInputStream 流
    43.         ois.close();
    44.  
    45.  
    46.     }
    47. }
    48.  
    49. package com.outputstream_;
    50.  
    51. import java.io.Serializable;
    52.  
    53. //如果需要序列化某个类的对象，实现 Serializable
    54. public class Dog implements Serializable {
    55.     private String name;
    56.     private int age;
    57.     //序列化对象时，默认将里面所有属性都进行序列化，但除了static或transient修饰的成员
    58.     private static String nation;
    59.     private transient String color;
    60.     //序列化对象时，要求里面属性的类型也需要实现序列化接口
    61.     private Master master = new Master();
    62.  
    63.     //serialVersionUID 序列化的版本号，可以提高兼容性
    64.     private static final long serialVersionUID = 1L;
    65.  
    66.     public Dog(String name, int age, String nation, String color) {
    67.         this.name = name;
    68.         this.age = age;
    69.         this.color = color;
    70.         this.nation = nation;
    71.     }
    72.  
    73.     @Override
    74.     public String toString() {
    75.         return "Dog{" +
    76.                 "name='" + name + '\'' +
    77.                 ", age=" + age +
    78.                 ", color='" + color + '\'' +
    79.                 '}' + nation + " " +master;
    80.     }
    81.  
    82.     public String getName() {
    83.         return name;
    84.     }
    85.  
    86.     public void setName(String name) {
    87.         this.name = name;
    88.     }
    89.  
    90.     public int getAge() {
    91.         return age;
    92.     }
    93.  
    94.     public void setAge(int age) {
    95.         this.age = age;
    96.     }
    97. }

    序列化和反序列化的注意事项和细节说明

    1)读写顺序要一致

    2)要求序列化或反序列化对象，需要 实现 Serializable

    3序列化的类中建议添加SerialVersionUID,为了提高版本的兼容性

    4)序列化对象时，默认将里面所有属性都进行序列化，但除了static或transient修饰的成员

    5)序列化对象时，要求里面属性的类型也需要实现序列化接口

    6)序列化具备可继承性,也就是如果某类已经实现了序列化，则它的所有子类也已经默认实现了序列化

    标准输入输出流

    代码演示：

    1. package com.standard;
    2.  
    3. import java.util.Scanner;
    4.  
    5. public class InputAndOutput {
    6.     public static void main(String[] args) {
    7.         //System 类 的 public final static InputStream in = null;
    8.         // System.in 编译类型   InputStream
    9.         // System.in 运行类型   BufferedInputStream
    10.         // 表示的是标准输入 键盘
    11.         System.out.println(System.in.getClass());
    12.  
    13.         //解读
    14.         //1. System.out public final static PrintStream out = null;
    15.         //2. 编译类型 PrintStream
    16.         //3. 运行类型 PrintStream
    17.         //4. 表示标准输出 显示器
    18.         System.out.println(System.out.getClass());
    19.  
    20.         System.out.println("hello, 你好~");
    21.  
    22.         Scanner scanner = new Scanner(System.in);
    23.         System.out.println("输入内容");
    24.         String next = scanner.next();
    25.         System.out.println("next=" + next);
    26.  
    27.  
    28.     }
    29. }

    转换流

    首先我们来看看为什么会出现乱码问题

    乱码问题

    那么乱码可能是以下原因导致的

    1. 编码不匹配：转换流可以将字节流转换成字符流，如果在转换的过程中使用了错误的编码方式，就会出现乱码问题。

    2. 字符集不支持：有些字符集在Java中不被支持，如果在转换流中使用了不支持的字符集，也会出现乱码问题。

    3. 字节流长度不匹配：如果转换流在读取字节流时，读取到的字节长度超出了字符流的长度限制，就会出现乱码问题。

    解决方法

    代码演示

    1. package com.transformation;
    2.  
    3. import java.io.*;
    4.  
    5. /**
    6.  * 演示使用 InputStreamReader 转换流解决中文乱码问题
    7.  * 将字节流 FileInputStream 转成字符流  InputStreamReader, 指定编码 gbk/utf-8
    8.  */
    9. public class InputStreamReader_ {
    10.     public static void main(String[] args) throws IOException {
    11.  
    12.         String filePath = "e:\\abc.txt";
    13.         //解读
    14.         //1. 把 FileInputStream 转成 InputStreamReader
    15.         //2. 指定编码 gbk
    16.         //InputStreamReader isr = new InputStreamReader(new FileInputStream(filePath), "gbk");
    17.         //3. 把 InputStreamReader 传入 BufferedReader
    18.         //BufferedReader br = new BufferedReader(isr);
    19.  
    20.         //将2 和 3 合在一起
    21.         BufferedReader br = new BufferedReader(new InputStreamReader(
    22.                 new FileInputStream(filePath), "gbk"));
    23.  
    24.         //4. 读取
    25.         String s = br.readLine();
    26.         System.out.println("读取内容=" + s);
    27.         //5. 关闭外层流
    28.         br.close();
    29.  
    30.     }
    31. }

  • 相关阅读:
    数据包络分析（DEA）——BCC模型
    ubuntu20.04 jammy 安装ros2
    Python绘制三维图详解
    基于SSM的校园预点餐网站
    beego语言golang编程语言安装bee : 无法将“bee”项识别为 cmdlet、函数、脚本文件或可运行程序的名称。
    记一次spark数据倾斜实践
    C#的反射机制
    Koltin协程：Flow的触发与消费
    深入理解KNN扩展到ANN
    机器视觉技术在现代汽车制造中的应用
  • 原文地址：https://blog.csdn.net/weixin_53616401/article/details/129480822