Java IO部分的字节流-字符流及文件输入-输出

Java IO 部分提供了用于输入和输出数据的类和接口。它允许您在 Java 应用程序中读取和写入数据，并与文件、网络套接字、数据库等各种数据源交互。
Java IO 可以分为两个主要部分：
- 流（Streams）：流是用于处理输入和输出数据的基本单元。它们提供一种连续的数据传输机制。 Java 提供两种类型的流：字节流和字符流。字节流以字节为单位处理数据，通常用于处理二进制数据，如图像、音频等。字符流以字符为单位处理数据，通常用于处理文本数据。
- 文件 I/O：Java 提供了一套用于处理文件 I/O 的类和接口。您可以使用这些类创建、读取、写入和管理文件。 Java 还提供对 ZIP 和 JAR 文件格式的支持。

## 流（Streams）Java 中的流分为两种主要类型：

- 字节流：用于处理原始字节数据。它包括输入字节流（InputStream）和输出字节流（OutputStream）。例如，FileInputStream 和 FileOutputStream 类用于处理文件中的字节数据。
InputStream is = new FileInputStream("file.txt");
OutputStream os = new FileOutputStream("file.txt");
- 字符流：用于处理字符数据。它包括输入字符流（Reader）和输出字符流（Writer）。例如，FileReader 和 FileWriter 类用于处理文本文件中的字符数据。
Reader reader = new FileReader("file.txt");
Writer writer = new FileWriter("file.txt");

一些常见的流类包括：
- InputStream 和 OutputStream：这是所有字节流的超类。它们定义了基本的方法来读取和写入字节数据。
- FileInputStream 和 FileOutputStream：用于处理文件中的字节数据。
- ByteArrayInputStream 和 ByteArrayOutputStream：用于处理内存中的字节数组。
- DataInputStream 和 DataOutputStream：提供对基本数据类型（如 int、float 等）的读写支持。
- BufferedReader 和 BufferedWriter：提供缓冲功能，可以提高字符流的性能。
  InputStream is = new FileInputStream("file.txt");
  BufferedInputStream bis = new BufferedInputStream(is);
- PrintWriter：用于格式化输出，通常用于打印到控制台或文件。

## 文件 I/O： Java 提供了一套用于处理文件 I/O 的类，包括：

- File：表示文件和目录路径。它提供方法来创建、删除、重命名和获取文件信息。
- RandomAccessFile：提供对文件的随机访问，允许您在文件中向前或向后读取和写入数据。
- FileReader 和 FileWriter：用于处理文本文件中的字符数据。
- FileInputStream 和 FileOutputStream：用于处理文件中的字节数据。
- FileUtils（Apache Commons IO）：Apache Commons IO 库提供了一个方便的 FileUtils 类，包含许多实用程序方法来处理文件和目录。

--

Java IO 包括字符集编码功能：

## 字符集编码：

Java 提供了一套用于处理不同字符集编码的类，确保正确地处理和解释文本数据：

- `Charset`：表示字符集编码。它定义了将字节转换为字符（解码）或将字符转换为字节（编码）的规则。 Java 支持各种字符集，例如 UTF-8、UTF-16、ISO-8859-1 等。
- `CharsetEncoder` 和 `CharsetDecoder`：这些类用于在字节和字符之间进行转换。 `CharsetEncoder` 将字符转换为字节，而 `CharsetDecoder` 将字节转换为字符。它们确保文本在不同系统和应用程序之间正确地传输和解释。
- `String` 类：Java 的 `String` 类支持 Unicode 编码，允许您处理多种语言和符号。您可以使用 `String` 类的构造函数或方法指定字符集编码，以确保正确地解释和处理文本数据。

import java.io.*;

public class FileCopyExample1_Large {
    public static void main(String[] args) {
        // 获取起始时间，用于计算复制文件耗时
        long startTime = System.currentTimeMillis();

        // 指定输入文件和输出文件的路径
        String sourceFilePath = "txttestAdestination.txt";
        String destinationFilePath = "outputtxttestAdestination.txt";

        try {
            // 使用缓冲输入输出流来提高复制效率
            BufferedInputStream bis = new BufferedInputStream(new FileInputStream(sourceFilePath));
            BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(destinationFilePath));

            // 创建一个8KB大小的缓冲区
            byte[] buffer = new byte[8192]; 

            int bytesRead;
            // 读取输入文件，并将内容写入输出文件
            while ((bytesRead = bis.read(buffer)) != -1) {
                bos.write(buffer, 0, bytesRead);
            }

            // 关闭输入输出流
            bis.close();
            bos.close();

        } catch (IOException e) {
            // 处理可能的IO异常
            e.printStackTrace();
        }

        // 获取结束时间并计算复制耗时
        long endTime = System.currentTimeMillis();
        long elapsedTime = endTime - startTime;
        System.out.println("文件复制完成，总共耗时：" + elapsedTime + " 毫秒");
    }
}

---------

在 Java 中，有两种类型的流：字节流和字符流。这些流是 java.io 包的一部分，用于 I/O 操作。
字节流    InputStream    抽象类，表示输入字节流
字节流    OutputStream    抽象类，表示输出字节流
字节流    FileInputStream    从文件中读取字节
字节流    FileOutputStream    向文件写入字节
字符流    Reader    抽象类，表示字符输入流
字符流    Writer    抽象类，表示字符输出流
字符流    FileReader    从文件中读取字符
字符流    FileWriter    向文件写入字符
字节缓冲区流    BufferedInputStream    字节输入缓冲区流，读取数据时使用内部缓冲区
字节缓冲区流    BufferedOutputStream    字节输出缓冲区流，写入数据时使用内部缓冲区
字符缓冲区流    BufferedReader    字符输入缓冲区流，读取文本数据时使用内部缓冲区
字符缓冲区流    BufferedWriter    字符输出缓冲区流，写入文本数据时使用内部缓冲区

字节流
字节流用于读取和写入二进制数据，例如图像、音频和视频文件。它们操作于字节，即数字信息的基本单位。字节流用于读取和写入原始二进制数据，不进行任何解释或编码。
Java 中的主要字节流类是：
InputStream（抽象）：所有输入流的基类，读取字节
OutputStream（抽象）：所有输出流的基类，写入字节
ByteArrayInputStream 和 ByteArrayOutputStream：流操作于字节数组
FileInputStream 和 FileOutputStream：流读取和写入文件
BufferedInputStream 和 BufferedOutputStream：流缓存数据以改善 I/O 性能

InputStream is = new FileInputStream("input.txt");
byte[] bytes = new byte[1024];
int length;
while ((length = is.read(bytes)) != -1) {
    System.out.println(new String(bytes, 0, length));  //在这个构造函数中，"0" 指定了字节数组中要转换为字符串的数据的起始位置。
}
is.close();

字符流
字符流用于读取和写入文本数据，例如文本文件和字符串。它们操作于字符，这些字符使用字符编码方案（例如 UTF-8、ISO-8859-1）进行编码。字符流用于读取和写入文本数据，自动进行编码和解码。
Java 中的主要字符流类是：
Reader（抽象）：所有输入流的基类，读取字符
Writer（抽象）：所有输出流的基类，写入字符
StringReader 和 StringWriter：流操作于字符串
FileReader 和 FileWriter：流读取和写入文本文件
BufferedReader 和 BufferedWriter：流缓存数据以改善 I/O 性能
Writer writer = new FileWriter("output.txt");
writer.write("This is a test");
writer.close();

关键差异
以下是字节流和字符流之间的主要差异：
字节流操作于原始二进制数据（字节），而字符流操作于编码字符（文本数据）。

• 字节流直接处理原始字节，不涉及编码或解码，而字符流进行编码和解码。

字节流用于二进制数据，例如图像和音频文件，而字符流用于文本数据，例如文本文件和字符串。
总之，字节流用于二进制数据，而字符流用于文本数据。理解这两种类型流之间的差异对于 Java 中的 I/O 操作非常重要。

内部缓冲区是缓冲区流（Buffered Streams）中使用的一个关键概念。当创建一个缓冲区流对象（例如 BufferedInputStream 或 BufferedReader）时，它会创建并维护一个内部缓冲区，通常是字节数组或字符数组。
在输入操作中（例如读取文件），缓冲区流从底层流（例如 FileInputStream）中读取一定数量的数据并填充
字节缓冲区流    BufferedInputStream    字节输入缓冲区流，读取数据时使用内部缓冲区
字节缓冲区流    BufferedOutputStream    字节输出缓冲区流，写入数据时使用内部缓冲区
字符缓冲区流    BufferedReader    字符输入缓冲区流，读取文本数据时使用内部缓冲区
字符缓冲区流    BufferedWriter    字符输出缓冲区流，写入文本数据时使用内部缓冲区
 

-----------

Java I/O 是一个强大的框架，用于处理 Java 应用程序中的输入和输出操作。它提供了一套丰富的功能和类，用于管理数据的读取、写入、操作和存储。Java I/O 可以分为两个主要部分：

- 流（Streams）：流是数据传输的基本单元。它们提供一种连续的数据流，可以从源读取数据或向目标写入数据。流可以来自各种来源，例如文件、网络连接、内存缓冲区等。
- 文件 I/O：Java 提供了一套全面的类和接口来处理文件 I/O 操作。这包括创建、读取、写入、复制、移动和删除文件和目录。

## 流（Streams）：

流是 Java I/O 的基础。它们可以将数据源（例如文件、网络套接字）与数据目标（另一个文件、网络连接等）连接起来。流可以处理各种数据类型，包括原始字节、字符、对象等。

Java 中的流分为两种主要类型：

- 字节流（Byte Streams）：用于处理原始字节数据。例如，FileInputStream 和 FileOutputStream 类用于处理字节流。
- 字符流（Character Streams）：用于处理字符数据。例如，FileReader 和 FileWriter 类用于处理字符流。

### 一些常见的流类：

- InputStream 和 OutputStream：这是所有字节流类的基类。它们定义了字节流的通用行为。
- FileInputStream 和 FileOutputStream：用于从文件读取字节或向文件写入字节。
- ByteArrayInputStream 和 ByteArrayOutputStream：用于处理内存中的字节数组。
- PipedInputStream 和 PipedOutputStream：用于在两个线程之间通过管道传输数据。
- DataInputStream 和 DataOutputStream：允许以特定格式读写基本数据类型，如 int、float、boolean 等。

## 字符流：

字符流用于处理字符数据，它们基于字节流构建，提供对字符的操作。

- Reader 和 Writer：这是所有字符流类的基类。它们类似于 InputStream 和 OutputStream，但用于字符数据。
- FileReader 和 FileWriter：用于从文件读取字符或向文件写入字符。
- BufferedReader 和 BufferedWriter：提供缓冲功能，可以提高字符流的读写性能。
- StringReader 和 StringWriter：用于从字符串读取或写入字符串。
- PrintWriter：提供格式化输出功能，通常用于向控制台输出数据。

## 文件 I/O：

Java 提供了一套全面的类和接口来处理文件 I/O 操作。

- File：File 类用于表示文件和目录路径。它提供各种方法来创建、删除、重命名、获取文件信息等。
- RandomAccessFile：RandomAccessFile 类允许以随机访问的方式读写文件。它可以直接访问文件中的任何位置，而不必从头开始读取。
- FileFilter：FileFilter 接口用于过滤文件列表，可以根据指定的条件选择文件。
- FilenameFilter：FilenameFilter 接口用于过滤文件名列表，可以根据文件名进行过滤。
- FileSystemView：FileSystemView 类提供了一种查看和操作文件系统的方法，包括获取根目录、获取默认文件类型等。

## 其他 I/O 类和接口：

Java I/O 框架还包括其他一些重要的类和接口：

- InputStreamReader 和 OutputStreamWriter：用于在字节流和字符流之间进行转换。
- SequenceInputStream：允许将多个输入流连接起来，形成一个连续的输入流。
- Console：Console 类提供了一种与系统控制台进行交互的方法，包括读取输入和写入输出。
- Formatter：Formatter 类提供了一种格式化输出数据的方法，可以指定输出格式、语言等。
- ObjectInputStream 和 ObjectOutputStream：用于序列化和反序列化对象，可以将对象转换为字节流并存储或传输，然后再转换回来。

## 缓冲（Buffering）：

缓冲是 Java I/O 中的重要概念。它涉及使用内存缓冲区来提高 I/O 操作的性能。缓冲区可以减少磁盘或网络操作的次数，从而提高效率。

- BufferedInputStream 和 BufferedOutputStream：为字节流提供缓冲功能。
- BufferedReader 和 BufferedWriter：为字符流提供缓冲功能。

## 总结：

Java I/O 提供了一套全面的类和接口来处理各种输入输出操作。它包括流、文件 I/O、缓冲等功能，可以满足大多数应用程序的需求。了解 Java I/O 的概念和类结构对于构建高效、可靠的 Java 应用程序至关重要。

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

详细介绍一下 BufferedReader 和 BufferedWriter 这两个在 Java 中常用于 I/O 操作的类。

BufferedReader

BufferedReader 是 Java 中的一个类，用于从输入流中读取字符数据。它继承自 Reader 抽象类，可以提高读取字符的效率。以下是关于 BufferedReader 的一些重要信息：

1. 内部缓冲区：BufferedReader 维护一个内部缓冲区，通常大小为 8192 个字符。在读取操作中，一次性从磁盘读取一块字符数据并存储在内部缓冲区中，然后逐个字符从缓冲区中读取。这样可以减少与磁盘的通信次数，提高读取速度。

2. 创建 BufferedReader：

   // 创建一个 FileReader
   FileReader fileReader = new FileReader("example.txt");
   
   // 创建一个 BufferedReader
   BufferedReader bufferedReader = new BufferedReader(fileReader);

   在上面的示例中，我们创建了一个名为 bufferedReader 的 BufferedReader，它与名为 fileReader 的 FileReader 关联。BufferedReader 的内部缓冲区默认大小为 8192 个字符，但我们也可以指定自定义的缓冲区大小。

3. 常用方法：

   • read()：从内部缓冲区中读取下一个字符。
   • read(char[] array)：从输入流中读取字符到指定的字符数组 array。
   • read(char[] array, int start, int length)：从输入流中读取指定长度的字符到数组 array，从位置 start 开始。

4. 示例代码：

   try {
       FileReader fileReader = new FileReader("input.txt");
       BufferedReader bufferedReader = new BufferedReader(fileReader);
       char[] array = new char[100];
       bufferedReader.read(array);
       System.out.println("文件内容：");
       System.out.println(array);
       bufferedReader.close();
   } catch (IOException e) {
       e.printStackTrace();
   }

   在上面的示例中，我们使用 read() 方法从内部缓冲区读取字符到字符数组中，并打印文件内容。

BufferedWriter

BufferedWriter 是用于写入字符数据的类，它继承自 Writer 抽象类。与 BufferedReader 类似，BufferedWriter 也使用内部缓冲区来提高写入效率。以下是关于 BufferedWriter 的一些重要信息：

1. 创建 BufferedWriter：

   // 创建一个 FileWriter
   FileWriter fileWriter = new FileWriter("output.txt");
   
   // 创建一个 BufferedWriter
   BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);

   在上面的示例中，我们创建了一个名为 bufferedWriter 的 BufferedWriter，它与名为 fileWriter 的 FileWriter 关联。

2. 常用方法：

   • write(char[] cbuf)：将字符数组 cbuf 写入输出流。
   • flush()：刷新输出流，将缓冲区中的数据写入目标。
   • close()：关闭输出流。

3. 示例代码：

   try {
       FileWriter fileWriter = new FileWriter("output.txt");
       BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);
       String data = "这是一个示例文本。";
       bufferedWriter.write(data);
       bufferedWriter.flush();
       bufferedWriter.close();
       System.out.println("写入成功！");
   } catch (IOException e) {
       e.printStackTrace();
   }

   在上面的示例中，我们使用 write() 方法将文本数据写入输出流，并通过 flush() 刷新缓冲区，最后关闭输出流。