Java中的Buffered流

# 1. 介绍Buffered流

## 1.1 什么是Buffered流

Buffered流是在基本的输入/输出流的基础上进行的一种封装和增强。它通过在内存中创建缓冲区，提供了更高效的读写操作。Buffered流分为输入和输出两种类型，分别为`BufferedInputStream`和`BufferedOutputStream`。

## 1.2 Buffered流的优点

相比于非Buffered流，Buffered流具有以下优点：
- 提高了读写效率：Buffered流通过将数据先读取到内存缓冲区或写入到内存缓冲区中，减少了对磁盘的直接读写操作，从而提高了读写效率。
- 减少系统调用次数：Buffered流每次读取和写入的数据块大小通常大于等于底层流的缓冲区大小，从而减少了系统调用的次数，提高了性能。
- 提供了批处理功能：Buffered流可以一次读取或写入多个字节，减少了操作系统和底层流的调用次数。

## 1.3 Buffered流与非Buffered流的区别

Buffered流与非Buffered流的区别主要在于数据的读写方式和性能表现。非Buffered流每次进行读写操作时都需要依次读取或写入一个字节或一个字符，这样的操作效率较低。而Buffered流则将数据读取到内存缓冲区中，在内存中进行读写操作，从而提高了效率。

另外，Buffered流还具有一个缺点，即对数据的实时性要求较高的场景可能会因为数据在缓冲区中而延迟。

接下来，我们将详细介绍BufferedInputStream类的相关内容。

# 2. BufferedInputStream类详解

BufferedInputStream类是Java IO库中的一个类，用于提供带有缓冲功能的输入流。它可以在读取数据时使用内部缓冲区，从而提高读取的效率。

### 2.1 BufferedInputStream类的作用

BufferedInputStream类的作用是在读取数据时加入缓冲区，从而减少对底层IO的直接访问，从而提高读取数据的性能。

### 2.2 BufferedInputStream类的构造方法

BufferedInputStream类提供了以下几种构造方法：

- `BufferedInputStream(InputStream in)`
创建一个带有默认缓冲区大小的BufferedInputStream对象。

- `BufferedInputStream(InputStream in, int size)`
创建一个带有指定缓冲区大小的BufferedInputStream对象。

### 2.3 BufferedInputStream类的常用方法

BufferedInputStream类提供了多个常用方法，以下是其中一些常见的方法：

- `int read()`
从输入流中读取一个字节数据，并返回读取到的字节数据的整数表示。如果已到达流的末尾，则返回-1。

- `int read(byte[] b, int off, int len)`
从输入流中最多读取len个字节的数据，并将其存储在数组b中。从数组的off位置开始存储。返回实际读取字节数，如果已到达流的末尾，则返回-1。

- `void close()`
关闭输入流。

下面是一个示例代码，演示了如何使用BufferedInputStream类从文件中读取数据：

import java.io.BufferedInputStream;
import java.io.FileInputStream;
import java.io.IOException;

public class BufferedInputStreamExample {
    public static void main(String[] args) {
        try (BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream("example.txt"))) {
            int data;
            while ((data = bufferedInputStream.read()) != -1) {
                System.out.print((char) data);
            }
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

代码说明：
- 首先，我们创建了一个`BufferedInputStream`对象，并使用`FileInputStream`作为其输入流对象，并传入要读取的文件名作为参数。
- 然后，我们使用`read()`方法读取字节数据，并将其转换为字符进行输出，直到读到文件末尾为止。
- 最后，我们在使用完`BufferedInputStream`后，使用`try-with-resources`语句自动关闭输入流。

上述代码使用了`BufferedInputStream`类从文件中读取数据，并输出到控制台上。通过使用`BufferedInputStream`类，我们可以提高数据读取的性能效率。

这就是`BufferedInputStream`类的简单介绍和使用示例。使用`BufferedInputStream`类可以大大提高数据读取的效率，特别是在读取大文件时。

# 3. BufferedOutputStream类详解

BufferedOutputStream类是Java中用于写入数据到输出流的缓冲流之一。它继承自OutputStream类，并实现了一系列的写入方法，如字节写入、字节数组写入等。通过使用BufferedOutputStream，我们可以提高写入数据的效率。

#### 3.1 BufferedOutputStream类的作用

BufferedOutputStream类的主要作用是将输出数据写入到缓冲区，并在缓冲区满或手动刷新时将数据一次性写入到底层输出流中。通过使用缓冲区，可以减少对底层输出流的实际写入次数，从而提高写入的效率。

#### 3.2 BufferedOutputStream类的构造方法

BufferedOutputStream类提供了多个构造方法，可以根据需要选择合适的构造方法来创建对象。

- `BufferedOutputStream(OutputStream out)`：创建一个具有默认缓冲区大小的BufferedOutputStream对象，并将数据写入指定的输出流。

- `BufferedOutputStream(OutputStream out, int size)`：创建一个具有指定缓冲区大小的BufferedOutputStream对象，并将数据写入指定的输出流。

#### 3.3 BufferedOutputStream类的常用方法

BufferedOutputStream类提供了一系列常用的方法，以下是其中一些常用方法的介绍：

- `void write(int b)`：将指定的字节写入缓冲区。

- `void write(byte[] b)`：将指定的字节数组写入缓冲区。

- `void write(byte[] b, int off, int len)`：将指定字节数组的一部分写入缓冲区。

- `void flush()`：刷新缓冲区，将缓冲区中的数据写入到底层输出流。

- `void close()`：关闭流，释放相关资源。

下面是使用BufferedOutputStream类进行数据写入的示例代码：

import java.io.*;

public class BufferedOutputStreamExample {
    public static void main(String[] args) {
        String data = "Hello, BufferedOutputStream!";
        try {
            OutputStream outputStream = new FileOutputStream("output.txt");
            BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(outputStream);

            byte[] byteArray = data.getBytes();
            bufferedOutputStream.write(byteArray);
            bufferedOutputStream.flush();
            bufferedOutputStream.close();
            System.out.println("Data has been written to the file.");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

在这个例子中，我们创建了一个BufferedOutputStream对象，并使用它将字符串数据写入到output.txt文件中。注意在写入完成后，我们需要手动调用`flush()`方法将缓冲区中的数据写入到文件中，并调用`close()`方法关闭流。

这样，我们就成功地利用BufferedOutputStream类将数据写入到指定的输出流中，并通过缓冲区提高了写入效率。

# 4. BufferedReader类详解

#### 4.1 BufferedReader类的作用
BufferedReader类是Java IO包中的一个字符输入流类，它提供了高效的读取字符数据的方法。它可以用来读取文本文件、输入流等。

#### 4.2 BufferedReader类的构造方法
BufferedReader类的构造方法如下：

public BufferedReader(Reader reader, int size)
public BufferedReader(Reader reader)

- 第一个构造方法接受两个参数：一个用于提供输入流的Reader对象和一个用于指定缓冲区大小的整数。
- 第二个构造方法只接受一个参数：用于提供输入流的Reader对象。在使用这个构造方法时，默认使用默认缓冲区大小。

#### 4.3 BufferedReader类的常用方法
BufferedReader类提供了多个方法用于读取字符数据，下面列出了其中一些常用的方法：
- `int read()`: 读取一个字符并返回其ASCII码值，如果达到流的末尾返回-1。
- `int read(char[] cbuf, int offset, int length)`: 从输入流中读取字符到字符数组中，从给定的偏移量开始，最多读取指定的字符数。
- `String readLine()`: 读取一行文本并返回一个字符串，不包括行终止符，如果已到达流的末尾，则返回null。
- `void close()`: 关闭输入流释放系统资源。

下面是一个使用BufferedReader类读取文本文件的示例：

import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;

public class BufferedReaderExample {

    public static void main(String[] args) throws IOException {
        BufferedReader reader = null;
        try {
            // 创建BufferedReader对象
            reader = new BufferedReader(new FileReader("input.txt"));

            String line;
            // 逐行读取并输出文本内容
            while ((line = reader.readLine()) != null) {
                System.out.println(line);
            }
        } finally {
            if (reader != null) {
                reader.close();
            }
        }
    }
}

在上述示例中，我们创建了一个BufferedReader对象来读取名为"input.txt"的文本文件。然后使用`readLine()`方法逐行读取文件内容，并将每一行打印到控制台。最后，通过`close()`方法关闭输入流，释放资源。

通过使用BufferedReader类，我们可以高效地读取字符数据，提高读取效率，并方便地进行文本处理和分析。

# 5. BufferedWriter类详解

BufferedWriter是用来包装Writer的类，它可以提供字符缓冲输出功能，能够减少对硬盘的读写次数，提高IO操作效率。

#### 5.1 BufferedWriter类的作用

BufferedWriter类主要用于提供缓冲字符输出流，可以提高文件写入的效率。

#### 5.2 BufferedWriter类的构造方法

BufferedWriter类的构造方法有以下常用形式：

- `BufferedWriter(Writer out)`: 创建一个新的缓冲字符输出流，以将数据写入指定的底层输出流。
- `BufferedWriter(Writer out, int sz)`: 创建一个新的缓冲字符输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流。

#### 5.3 BufferedWriter类的常用方法

BufferedWriter类常用的方法包括：

- `write(String str)`: 写入一个字符串。
- `newLine()`: 写入一个行分隔符。
- `flush()`: 刷新该流的缓冲。
- `close()`: 关闭该流并释放与之关联的所有资源。

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedWriterExample {
    public static void main(String[] args) {
        try {
            BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"));
            writer.write("Hello, BufferedWriter!");
            writer.newLine();
            writer.write("This is a new line.");
            writer.flush();
            writer.close();
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

**代码说明：**
- 通过BufferedWriter类写入文件，可以使用`write`方法写入字符串，并使用`newLine`方法换行。
- 最后需要调用`flush`方法刷新缓冲区，并调用`close`方法关闭流。

**结果说明：**
以上代码会创建一个名为`output.txt`的文件，并写入两行字符串内容，每行内容之间会有一个换行符。

通过上述详细介绍，读者可以了解BufferedWriter类的作用、构造方法以及常用方法，以及在实际应用中的示例代码和结果后，更加全面地掌握Buffered流的用法和功能。

# 6. 实际应用案例

### 6.1 使用Buffered流进行文件复制

文件复制是使用Buffered流的一种常见应用场景。通过使用BufferedReader读取源文件的数据，然后使用BufferedWriter将数据写入目标文件，可以实现高效的文件复制操作。

import java.io.*;

public class FileCopyDemo {
    public static void main(String[] args) {
        String sourceFile = "source.txt"; // 源文件路径
        String targetFile = "target.txt"; // 目标文件路径

        try {
            FileReader fileReader = new FileReader(sourceFile);
            FileWriter fileWriter = new FileWriter(targetFile);

            // 创建BufferedReader对象以读取源文件
            BufferedReader bufferedReader = new BufferedReader(fileReader);

            // 创建BufferedWriter对象以写入目标文件
            BufferedWriter bufferedWriter = new BufferedWriter(fileWriter);

            String line;

            // 从源文件逐行读取数据并写入目标文件
            while ((line = bufferedReader.readLine()) != null) {
                bufferedWriter.write(line);
                bufferedWriter.newLine(); // 写入换行符
            }

            // 关闭BufferedReader和BufferedWriter对象
            bufferedReader.close();
            bufferedWriter.close();

            System.out.println("文件复制完成！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

代码解析：
- 首先定义源文件路径和目标文件路径。
- 创建FileReader和FileWriter对象，用于读取源文件和写入目标文件。
- 使用BufferedReader包装FileReader对象，以便逐行读取源文件的数据。
- 使用BufferedWriter包装FileWriter对象，以便写入目标文件的数据。
- 使用while循环逐行读取源文件的数据，并将每行数据写入目标文件。
- 在每行数据后面写入换行符，保持目标文件与源文件格式一致。
- 关闭BufferedReader和BufferedWriter对象，并输出复制完成的提示信息。

### 6.2 使用Buffered流进行网络通信

Buffered流也适用于网络通信。下面通过一个简单的示例演示如何使用BufferedInputStream和BufferedOutputStream进行网络文件传输。

import java.io.*;
import java.net.Socket;

public class FileTransferDemo {
    public static void main(String[] args) {
        String serverName = "localhost"; // 服务器主机名
        String filePath = "source.jpg"; // 文件路径

        try {
            Socket socket = new Socket(serverName, 9000);

            // 创建BufferedInputStream对象以读取文件
            BufferedInputStream bufferedInputStream = new BufferedInputStream(new FileInputStream(filePath));

            // 创建BufferedOutputStream对象以写入文件
            BufferedOutputStream bufferedOutputStream = new BufferedOutputStream(socket.getOutputStream());

            byte[] buffer = new byte[1024];
            int bytesRead;

            // 从输入流中读取数据并写入输出流
            while ((bytesRead = bufferedInputStream.read(buffer)) != -1) {
                bufferedOutputStream.write(buffer, 0, bytesRead);
            }

            // 刷新输出流并关闭Socket
            bufferedOutputStream.flush();
            socket.close();

            System.out.println("文件传输完成！");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

代码解析：
- 首先定义服务器主机名和文件路径。
- 创建Socket对象，与服务器建立连接。
- 创建BufferedInputStream对象，用于读取文件的数据。
- 创建BufferedOutputStream对象，用于将数据写入Socket的输出流。
- 创建一个字节数组作为缓冲区，用于存储每次读取的数据。
- 使用while循环从输入流中读取数据，并将数据写入输出流。
- 刷新输出流，并关闭Socket连接。
- 输出文件传输完成的提示信息。

以上是使用Buffered流进行网络通信的简单示例，通过使用BufferedInputStream和BufferedOutputStream，可以实现高效的文件传输操作。