博客记录-day015-JavaIO字节流、缓冲流、转换流、序列流

在 Java 中，Map 是一种用于存储键值对(key-value pairs)的集合。HashMap，TreeMap 等都是 Map 接口的常见实现。下面是 for (Map.Entry<KeyType, ValueType> entry : map.entrySet()) 的底层逻辑和工作原理的详细解释。

底层逻辑

1. 键值对存储：

   • Map 以键和值的形式存储数据，用户可以通过键快速获取对应的值。每个键在 Map 中是唯一的。

2. 获取条目集：

   • entrySet() 方法返回一个集合（Set<Map.Entry<KeyType, ValueType>>），该集合包含了 Map 中所有的键值对。每个元素都是一个 Map.Entry 对象，它本身包含了一个键和一个对应的值。
   • 例如，对于一个包含 {1: "A", 2: "B"} 的 HashMap，调用 entrySet() 会返回一个包含 {1=A, 2=B} 的集合。

3. 迭代：

   • for-each 循环简化了对集合的遍历。我们可以直接遍历 Set<Map.Entry<KeyType, ValueType>>，每次迭代得到一个 Map.Entry 对象。
   • 在循环内部，可以通过 entry.getKey() 和 entry.getValue() 方法访问当前条目的键和值。

一、沉默王二-JavaIO

1、字符流

字符流是一种用于读取和写入字符数据的输入输出流。与字节流不同，字符流以字符为单位读取和写入数据，而不是以字节为单位。常用来处理文本信息。

如果用字节流直接读取中文，可能会遇到乱码问题。

之所以出现乱码是因为在字节流中，一个字符通常由多个字节组成，而不同的字符编码使用的字节数不同。如果我们使用了错误的字符编码，或者在读取和写入数据时没有正确处理字符编码的转换，就会导致读取出来的中文字符出现乱码。

例如，当我们使用默认的字符编码读取一个包含中文字符的文本文件时，就会出现乱码。因为默认的字符编码通常是 ASCII 编码，它只能表示英文字符，而不能正确地解析中文字符。

从另一角度来说：字符流 = 字节流 + 编码表

1）字符输入流（Reader）

java.io.Reader是字符输入流的超类（父类），它定义了字符输入流的一些共性方法：

• 1、close()：关闭此流并释放与此流相关的系统资源。
• 2、read()：从输入流读取一个字符。
• 3、read(char[] cbuf)：从输入流中读取一些字符，并将它们存储到字符数组 cbuf中

FileReader 是 Reader 的子类，用于从文件中读取字符数据。它的主要特点如下：

• 可以通过构造方法指定要读取的文件路径。
• 每次可以读取一个或多个字符。
• 可以读取 Unicode 字符集中的字符，通过指定字符编码来实现字符集的转换。

FileReader构造方法

• 1、FileReader(File file)：创建一个新的 FileReader，参数为File对象。
• 2、FileReader(String fileName)：创建一个新的 FileReader，参数为文件名。

// 使用File对象创建流对象
File file = new File("a.txt");
FileReader fr = new FileReader(file);

// 使用文件名称创建流对象
FileReader fr = new FileReader("b.txt");

FileReader读取字符数据

1、读取字符：read方法，每次可以读取一个字符，返回读取的字符（转为 int 类型），当读取到文件末尾时，返回-1。

2、读取指定长度的字符：read(char[] cbuf, int off, int len)，并将其存储到字符数组中。其中，cbuf 表示存储读取结果的字符数组，off 表示存储结果的起始位置，len 表示要读取的字符数。

2）字符输出流（Writer）

java.io.Writer 是字符输出流类的超类（父类），可以将指定的字符信息写入到目的地，来看它定义的一些共性方法：

• 1、write(int c) 写入单个字符。
• 2、write(char[] cbuf) 写入字符数组。
• 3、write(char[] cbuf, int off, int len) 写入字符数组的一部分，off为开始索引，len为字符个数。
• 4、write(String str) 写入字符串。
• 5、write(String str, int off, int len) 写入字符串的某一部分，off 指定要写入的子串在 str 中的起始位置，len 指定要写入的子串的长度。
• 6、flush() 刷新该流的缓冲。
• 7、close() 关闭此流，但要先刷新它。

java.io.FileWriter 类是 Writer 的子类，用来将字符写入到文件。

FileWriter 构造方法

• FileWriter(File file)： 创建一个新的 FileWriter，参数为要读取的File对象。
• FileWriter(String fileName)： 创建一个新的 FileWriter，参数为要读取的文件的名称。

// 第一种：使用File对象创建流对象
File file = new File("a.txt");
FileWriter fw = new FileWriter(file);

// 第二种：使用文件名称创建流对象
FileWriter fw = new FileWriter("b.txt");

FileWriter写入数据

1、写入字符：write(int b) 方法，每次可以写出一个字符，

2、写入字符数组：write(char[] cbuf) 方法，将指定字符数组写入输出流。

3、写入指定字符数组：write(char[] cbuf, int off, int len) 方法，将指定字符数组的一部分写入输出流。

4、写入字符串：write(String str) 方法，将指定字符串写入输出流。

5、写入指定字符串：write(String str, int off, int len) 方法，将指定字符串的一部分写入输出流。

关闭close和刷新flush

因为 FileWriter 内置了缓冲区 ByteBuffer，所以如果不关闭输出流，就无法把字符写入到文件中。

但是关闭了流对象，就无法继续写数据了。如果我们既想写入数据，又想继续使用流，就需要 flush 方法了。

• flush ：刷新缓冲区，流对象可以继续使用。

• close ：先刷新缓冲区，然后通知系统释放资源。流对象不可以再被使用了。

flush()这个方法是清空缓存的意思，用于清空缓冲区的数据流，进行流的操作时，数据先被读到内存中，然后再把数据写到文件中。

FileWriter的续写和换行

续写和换行：操作类似于FileOutputStream操作。

// 使用文件名称创建流对象，可以续写数据
FileWriter fw = new FileWriter("fw.txt",true);     
// 写出字符串
fw.write("沉默王二");
// 写出换行
fw.write("\r\n");
// 写出字符串
fw.write("是傻 X");
// 关闭资源
fw.close();

03）IO异常的处理

我们在学习的过程中可能习惯把异常抛出，而实际开发中建议使用try...catch...finally 代码块，处理异常部分，格式代码如下：

// 声明变量
FileWriter fw = null;
try {
    //创建流对象
    fw = new FileWriter("fw.txt");
    // 写出数据
    fw.write("二哥真的帅"); //哥敢摸si
} catch (IOException e) {
    e.printStackTrace();
} finally {
    try {
        if (fw != null) {
            fw.close();
        }
    } catch (IOException e) {
        e.printStackTrace();
    }
}

或者直接使用 try-with-resources 的方式。

try (FileWriter fw = new FileWriter("fw.txt")) {
    // 写出数据
    fw.write("二哥真的帅"); //哥敢摸si
} catch (IOException e) {
    e.printStackTrace();
}

在这个代码中，try-with-resources 会在 try 块执行完毕后自动关闭 FileWriter 对象 fw，不需要手动关闭流。如果在 try 块中发生了异常，也会自动关闭流并抛出异常。因此，使用 try-with-resources 可以让代码更加简洁、安全和易读。

2、缓冲流

Java 的缓冲流是对字节流和字符流的一种封装，通过在内存中开辟缓冲区来提高 I/O 操作的效率。Java 通过 BufferedInputStream 和 BufferedOutputStream 来实现字节流的缓冲，通过 BufferedReader 和 BufferedWriter 来实现字符流的缓冲。

缓冲流的工作原理是将数据先写入缓冲区中，当缓冲区满时再一次性写入文件或输出流，或者当缓冲区为空时一次性从文件或输入流中读取一定量的数据。这样可以减少系统的 I/O 操作次数，提高系统的 I/O 效率，从而提高程序的运行效率。

1）字节缓冲流

BufferedInputStream 和 BufferedOutputStream 属于字节缓冲流，强化了字节流 InputStream 和 OutputStream。

构造方法

• BufferedInputStream(InputStream in) ：创建一个新的缓冲输入流，注意参数类型为InputStream。
• BufferedOutputStream(OutputStream out)： 创建一个新的缓冲输出流，注意参数类型为OutputStream。

代码示例如下：

// 创建字节缓冲输入流，先声明字节流
FileInputStream fps = new FileInputStream(b.txt);
BufferedInputStream bis = new BufferedInputStream(fps)

// 创建字节缓冲输入流（一步到位）
BufferedInputStream bis = new BufferedInputStream(new FileInputStream("b.txt"));

// 创建字节缓冲输出流（一步到位）
BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("b.txt"));

InputStreamReader 和 OutputStreamWriter 是将字节流转换为字符流或者将字符流转换为字节流。通常用于解决字节流和字符流之间的转换问题，可以将字节流以指定的字符集编码方式转换为字符流，或者将字符流以指定的字符集编码方式转换为字节流。

InputStreamReader 类的常用方法包括：

• read()：从输入流中读取一个字符的数据。
• read(char[] cbuf, int off, int len)：从输入流中读取 len 个字符的数据到指定的字符数组 cbuf 中，从 off 位置开始存放。
• ready()：返回此流是否已准备好读取。
• close()：关闭输入流。

OutputStreamWriter 类的常用方法包括：

• write(int c)：向输出流中写入一个字符的数据。
• write(char[] cbuf, int off, int len)：向输出流中写入指定字符数组 cbuf 中的 len 个字符，从 off 位置开始。
• flush()：将缓冲区的数据写入输出流中。
• close()：关闭输出流。

在使用转换流时，需要指定正确的字符集编码方式，否则可能会导致数据读取或写入出现乱码。

缓冲流的高效

传统的 Java IO 是阻塞模式的，它的工作状态就是“读/写，等待，读/写，等待。。。。。。”

字节缓冲流解决的就是这个问题：一次多读点多写点，减少读写的频率，用空间换时间。

• 减少系统调用次数：在使用字节缓冲流时，数据不是立即写入磁盘或输出流，而是先写入缓冲区，当缓冲区满时再一次性写入磁盘或输出流。这样可以减少系统调用的次数，从而提高 I/O 操作的效率。
• 减少磁盘读写次数：在使用字节缓冲流时，当需要读取数据时，缓冲流会先从缓冲区中读取数据，如果缓冲区中没有足够的数据，则会一次性从磁盘或输入流中读取一定量的数据。同样地，当需要写入数据时，缓冲流会先将数据写入缓冲区，如果缓冲区满了，则会一次性将缓冲区中的数据写入磁盘或输出流。这样可以减少磁盘读写的次数，从而提高 I/O 操作的效率。
• 提高数据传输效率：在使用字节缓冲流时，由于数据是以块的形式进行传输，因此可以减少数据传输的次数，从而提高数据传输的效率。

2）字符缓冲流

BufferedReader 类继承自 Reader 类，提供了一些便捷的方法，例如 readLine() 方法可以一次读取一行数据，而不是一个字符一个字符地读取。

BufferedWriter 类继承自 Writer 类，提供了一些便捷的方法，例如 newLine() 方法可以写入一个系统特定的行分隔符。

构造方法

• BufferedReader(Reader in) ：创建一个新的缓冲输入流，注意参数类型为Reader。
• BufferedWriter(Writer out)： 创建一个新的缓冲输出流，注意参数类型为Writer。

代码示例如下：

// 创建字符缓冲输入流
BufferedReader br = new BufferedReader(new FileReader("b.txt"));
// 创建字符缓冲输出流
BufferedWriter bw = new BufferedWriter(new FileWriter("b.txt"));

字符缓冲流特有方法

字符缓冲流的基本方法与普通字符流调用方式一致，这里不再赘述，我们来看字符缓冲流特有的方法。

• BufferedReader：String readLine(): 读一行数据，读取到最后返回 null
• BufferedWriter：newLine(): 换行，由系统定义换行符。

3、转换流

转换流可以将一个字节流包装成字符流，或者将一个字符流包装成字节流。这种转换通常用于处理文本数据，如读取文本文件或将数据从网络传输到应用程序。

转换流主要有两种类型：InputStreamReader 和 OutputStreamWriter。

InputStreamReader 将一个字节输入流转换为一个字符输入流，而 OutputStreamWriter 将一个字节输出流转换为一个字符输出流。它们使用指定的字符集将字节流和字符流之间进行转换。常用的字符集包括 UTF-8、GBK、ISO-8859-1 等。

1）InputStreamReader

java.io.InputStreamReader 是 Reader 类的子类。它的作用是将字节流（InputStream）转换为字符流（Reader），同时支持指定的字符集编码方式，从而实现字符流与字节流之间的转换。

构造方法

• InputStreamReader(InputStream in): 创建一个使用默认字符集的字符流。
• InputStreamReader(InputStream in, String charsetName): 创建一个指定字符集的字符流。

代码示例如下：

InputStreamReader isr = new InputStreamReader(new FileInputStream("in.txt"));
InputStreamReader isr2 = new InputStreamReader(new FileInputStream("in.txt") , "GBK");

2）OutputStreamWriter

java.io.OutputStreamWriter 是 Writer 的子类，字面看容易误以为是转为字符流，其实是将字符流转换为字节流，是字符流到字节流的桥梁。

• OutputStreamWriter(OutputStream in): 创建一个使用默认字符集的字符流。
• OutputStreamWriter(OutputStream in, String charsetName)：创建一个指定字符集的字符流。

代码示例如下：

OutputStreamWriter isr = new OutputStreamWriter(new FileOutputStream("a.txt"));
OutputStreamWriter isr2 = new OutputStreamWriter(new FileOutputStream("b.txt") , "GBK");

通常为了提高读写效率，我们会在转换流上再加一层缓冲流。

4.序列流

Java 的序列流（ObjectInputStream 和 ObjectOutputStream）是一种可以将 Java 对象序列化和反序列化的流。

序列化是指将一个对象转换为一个字节序列（包含对象的数据、对象的类型和对象中存储的属性等信息），以便在网络上传输或保存到文件中，或者在程序之间传递。在 Java 中，序列化通过实现 java.io.Serializable 接口来实现，只有实现了 Serializable 接口的对象才能被序列化。

反序列化是指将一个字节序列转换为一个对象，以便在程序中使用。

1）ObjectOutputStream

java.io.ObjectOutputStream 继承自 OutputStream 类，因此可以将序列化后的字节序列写入到文件、网络等输出流中。

来看 ObjectOutputStream 的构造方法： ObjectOutputStream(OutputStream out)

该构造方法接收一个 OutputStream 对象作为参数，用于将序列化后的字节序列输出到指定的输出流中。例如：

FileOutputStream fos = new FileOutputStream("file.txt");
ObjectOutputStream oos = new ObjectOutputStream(fos);

一个对象要想序列化，必须满足两个条件:

• 该类必须实现java.io.Serializable 接口，否则会抛出NotSerializableException 。
• 该类的所有字段都必须是可序列化的。如果一个字段不需要序列化，则需要使用transient 关键字进行修饰。

2）ObjectInputStream

ObjectInputStream 可以读取 ObjectOutputStream 写入的字节流，并将其反序列化为相应的对象（包含对象的数据、对象的类型和对象中存储的属性等信息）。

说简单点就是，序列化之前是什么样子，反序列化后就是什么样子。

来看一下构造方法：ObjectInputStream(InputStream in) ： 创建一个指定 InputStream 的 ObjectInputStream。

其中，ObjectInputStream 的 readObject 方法用来读取指定文件中的对象，示例如下：

String filename = "logs/person.dat"; // 待反序列化的文件名
try (FileInputStream fileIn = new FileInputStream(filename);
     ObjectInputStream in = new ObjectInputStream(fileIn)) {
     // 从指定的文件输入流中读取对象并反序列化
     Object obj = in.readObject();
     // 将反序列化后的对象强制转换为指定类型
     Person p = (Person) obj;
     // 打印反序列化后的对象信息
     System.out.println("Deserialized Object: " + p);
} catch (IOException | ClassNotFoundException e) {
     e.printStackTrace();
}

我们首先指定了待反序列化的文件名（前面通过 ObjectOutputStream 序列化后的文件），然后创建了一个 FileInputStream 对象和一个 ObjectInputStream 对象。接着我们调用 ObjectInputStream 的 readObject 方法来读取指定文件中的对象，并将其强制转换为 Person 类型。最后我们打印了反序列化后的对象信息。