InputStreamReader是Java将字节流转换为字符流的中间桥梁

InputStreamReader用于处理字节流与字符流之间的转换。在Java中，存在着字节流和字符流两种基本的输入输出流类型，字节流主要用于处理二进制数据，而字符流则主要用于处理文本数据。InputStreamReader就是将字节流转换为字符流的中间桥梁。

使用InputStreamReader，可以指定一个字符集用于将字节流解码为字符流。
例如，在读取一个文本文件时，可以使用FileInputStream来读取文件的字节流，然后再使用InputStreamReader将字节流转换为字符流，这样就可以按照字符的方式逐行读取文件内容了。

InputStreamReader 的字符编码取决于底层字节流使用的字符集。这是因为 `InputStreamReader` 将字节流解码为字符流，并且需要知道字节是如何编码为字符的。
当创建 `InputStreamReader` 时，可以使用构造函数参数指定字符集（例如 `UTF-8` 或 `GBK`）。如果未指定字符集，则 `InputStreamReader` 将使用系统默认字符集。
示例：
使用 UTF-8 字符集创建 `InputStreamReader`：
FileInputStream fileInputStream = new FileInputStream("input.txt");
InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream, "UTF-8");
注意：
* 如果字节流的字符集与 `InputStreamReader` 指定的字符集不匹配，则可能会导致乱码或字符损坏。
* 了解底层字节流使用的字符集非常重要，以便正确配置 `InputStreamReader`。

 BufferedReader是 Java 中一个用于从字符流中读取文本数据的缓冲字符输入流。它提供了比基本 `Reader` 类更方便和高效的读取操作。
用途：
* 从文本文件、字符串或其他字符数据源读取数据。
* 提供缓冲区，以提高从底层字符流读取数据的效率。
构造函数：
BufferedReader(Reader in)
其中，`in` 是要缓冲的字符流。
方法：
* read()：读取下一个字符并返回它。
* read(char[] cbuf)：将字符读入字符数组 `cbuf`。
* readLine()：读取一行文本并返回它。
* skip(long n)：跳过给定数量的字符。
* close()：关闭底层字符流。
示例：
Reader reader = ...;
BufferedReader bufferedReader = new BufferedReader(reader);
String line = bufferedReader.readLine();
注意：
* `BufferedReader` 缓冲字符流，以提高读取性能。
* 它不执行任何字符编码转换。
* 它是一个包装类，在底层字符流之上提供更方便的读取操作。

import java.io.*;

public class EncodingExample {
    public static void main(String[] args) {
        try {
            // 创建 FileInputStream 以读取文件
            FileInputStream fileInputStream = new FileInputStream("input.txt");
            
            // 创建 InputStreamReader，并指定字符集为 UTF-8/ new InputStreamReader(fileInputStream, "UTF-8");
            // 如果 InputStreamReader 是用默认字符集创建的，那么 getEncoding() 方法可能会返回系统默认的字符集名称。
            InputStreamReader inputStreamReader = new InputStreamReader(fileInputStream);
            
            // 获取当前字符流使用的字符集
            String encoding = inputStreamReader.getEncoding();
            System.out.println("当前字符流使用的字符集为：" + encoding+'\n');
            
            // 读取字符流中的内容
            int data;
            while ((data = inputStreamReader.read()) != -1) {
                // 在控制台打印读取的字符
                System.out.print((char) data);
            }
            
            // 关闭字符流
            inputStreamReader.close();
            
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

import java.io.*;

public class FileInputOutputExample {
    public static void main(String[] args) {
        // 文件输入流示例,InputStreamReader 来将字节流转换为字符流，并指定了输入流的编码格式为 UTF-8
        try (BufferedReader br = new BufferedReader(new InputStreamReader(new FileInputStream("input.txt"), "UTF-8"))) {
            String line;
            while ((line = br.readLine()) != null) {
                System.out.println(line);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }

        // 文件输出流示例
        try (BufferedWriter bw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("output.txt"), "UTF-8"))) {
            String content = "Hello, Java!";
            bw.write(content);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

// InputStreamReader 提供了以下常用的方法：
// read()：读取单个字符，返回读取的字符的 Unicode 编码值。如果已到达流的末尾，则返回 -1。
// read(char[] cbuf, int offset, int length)：将字符读入数组中，从指定的偏移量开始存储，最多读取指定数量的字符。
// skip(long n)：跳过并丢弃输入流中的 n 个字符。
// ready()：判断此流是否已准备好被读取。
// close()：关闭此流并释放与该流关联的所有系统资源。
// 除了以上方法，还有一些支持字符集编码转换的方法，例如：
// getEncoding()：获取此流使用的字符集的名称。
// getDecoder()：获取用于将字节转换为字符的解码器。
// getInputStream()：获取用于读取字节的输入流。
// 等等。

// InputStreamReader 类有多个构造函数，用于创建从字节流到字符流的转换。
以下是其中一些常用的构造函数：
// InputStreamReader(InputStream in)
// 使用系统默认字符集将指定的输入流转换为字符输入流。
// InputStreamReader(InputStream in, String charsetName)
// 使用指定的字符集将指定的输入流转换为字符输入流。
// 例如：new InputStreamReader(new FileInputStream("input.txt"), "UTF-8") 将指定使用 UTF-8 编码读取文件。
// InputStreamReader(InputStream in, Charset cs)
// 使用指定的字符集将指定的输入流转换为字符输入流。
// 这些构造函数可以满足不同的需求，你可以根据具体的场景来选择合适的构造函数来创建 InputStreamReader 对象。

 ----------------

InputStreamReader分类目总结：

1. 类名：InputStreamReader
2. 继承关系：
   - 继承自：Reader类
   - 实现的接口：Closeable, AutoCloseable, Readable
3. 直接子类：FileReader
4. 功能概述：
   - 作用：将字节流转换为字符流的桥接器
   - 字符集：可以使用指定的字符集或默认字符集进行解码
   - 读取操作：每次调用read()方法可能导致从底层字节输入流中读取一个或多个字节
   - 提高效率：建议在BufferedReader中包装InputStreamReader以提高效率
5. 构造方法：
   - InputStreamReader(InputStream in)
   - InputStreamReader(InputStream in, String charsetName)
   - InputStreamReader(InputStream in, Charset cs)
   - InputStreamReader(InputStream in, CharsetDecoder dec)
6. 方法摘要：
   - getEncoding(): 返回字符编码名称
   - read(): 读取一个字符
   - read(char[] cbuf, int offset, int length): 将字符读入数组的一部分
   - ready(): 判断流是否可读取
7. 版本信息：
   - 开始版本：1.1
8. 异常：
   - UnsupportedEncodingException: 不支持指定的字符集
   - IOException: I/O错误异常
   - IndexOutOfBoundsException: 索引越界异常
9. 其他：
   - 可以通过构造方法指定字符集或使用默认字符集
   - 可以获取字符编码名称
   - 提供了读取字符和判断流是否就绪的方法
10. 适用范围：用于字节流到字符流的转换，是Java IO操作中的重要工具。

---------------

Java中的输入输出流类用于实现数据的输入和输出操作。
以下是一些常见的输入输出流类及其主要功能：

1. 字节流：
   - FileInputStream：从文件中读取字节流数据。
   - FileOutputStream：向文件中写入字节流数据。
   - BufferedInputStream：高效地读取字节流，通常与FileInputStream一起使用。
   - BufferedOutputStream：高效地写入字节流，通常与FileOutputStream一起使用。
   - ByteArrayInputStream：将字节数组包装成字节流。
   - ByteArrayOutputStream：将字节流数据写入到字节数组中。

2. 字符流：
   - FileReader：从文件中读取字符流数据。
   - FileWriter：向文件中写入字符流数据。
   - BufferedReader：高效地读取字符流，通常与FileReader一起使用。
   - BufferedWriter：高效地写入字符流，通常与FileWriter一起使用。
   - InputStreamReader：将字节流转换为字符流。
   - OutputStreamWriter：将字符流转换为字节流。

3. 对象流：
   - ObjectInputStream：读取对象的序列化数据。
   - ObjectOutputStream：将对象序列化为字节流。

4. 数据流：
   - DataInputStream：从输入流中读取基本数据类型。
   - DataOutputStream：将基本数据类型写入到输出流中。

5. 缓冲流：
   - BufferedInputStream：提供缓冲功能的字节输入流。
   - BufferedOutputStream：提供缓冲功能的字节输出流。
   - BufferedReader：提供缓冲功能的字符输入流。
   - BufferedWriter：提供缓冲功能的字符输出流。

这些输入输出流类提供了不同的功能和特性，可以根据具体需求选择合适的类来进行数据的输入和输出操作。在使用这些类时，需要注意异常处理和及时关闭流，以确保程序的稳定性和资源的正确释放。

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
import java.io.File;

public class FileProcessor {
    public static void main(String[] args) {
        String sourceFilePath = "txttestA.txt";
        String destinationFilePath = "txttestB.txt";
        int bufferSize = 98192; //1118192Byte=1.066391MB 缓冲区大小，可以根据需要进行调整

        File file = new File(sourceFilePath);
        long fileSizeBytes = file.length();
        double fileSizeMB = (double) fileSizeBytes / (1024 * 1024); // 转换为MB
        System.out.println("文件txttestA.txt大小: " + fileSizeMB + " MB");
        long startTime = System.currentTimeMillis();

        try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream(sourceFilePath), bufferSize);
             BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destinationFilePath), bufferSize)) {

            byte[] buffer = new byte[bufferSize];
            int bytesRead;
            while ((bytesRead = bis.read(buffer)) != -1) {
                bos.write(buffer, 0, bytesRead);
            }
            //BufferedOutputStream的write(byte[] buffer, int offset, int length)
            // 刷新缓冲区，确保所有数据都被写入到输出流中
            bos.flush();
        } catch (IOException e) {
            e.printStackTrace();
        }

        long endTime = System.currentTimeMillis();
        long elapsedTime = endTime - startTime;

        System.out.println("读写过程所用的时间：" + elapsedTime + "毫秒");
    }
}