理解缓冲流及其在Java中的应用

比眉伴天荒 2023-10-13 18:00 54阅读 0赞

## 理解缓冲流及其在Java中的应用 ##

### 简介 ###

在Java中进行输入输出操作时，通常会使用数据流（Stream）来进行读写操作。对于大文件或需要频繁读写操作的文件，使用普通的数据流会导致性能问题，因为每次读写操作都会直接访问磁盘，而磁盘读写速度较慢。为了提高读写效率，Java提供了缓冲流（Buffered Stream）来替代普通数据流，从而实现读写操作的缓存处理。

本文将介绍缓冲流的概念、工作原理和在Java中的应用，并提供代码示例。

![在这里插入图片描述][f5048813b1bf47fe845a8fccd92aba7d.png]

### 缓冲流的概念 ###

缓冲流是一种数据流，它封装了普通数据流，提供了缓存区（Buffer）来暂存输入输出数据。当需要读写数据时，缓冲流会先将数据读入缓存区，然后在缓存区中进行读写操作。当缓存区满时，缓冲流会将缓存区中的数据一次性地写入磁盘，从而避免了频繁的磁盘读写操作，提高了读写效率。

### 缓冲流的工作原理 ###

缓冲流的工作原理可以分为缓存和刷新两个过程。

#### 缓存过程 ####

当使用缓冲流进行读写操作时，数据会首先被读入缓存区。缓存区是一个字节数组，它的大小由缓冲流的构造函数参数指定。

在读取数据时，缓冲流会将磁盘上的数据分块读取到缓存区中，然后逐个字节地读取缓存区中的数据。当缓存区中的数据被读取完毕后，缓冲流会再次读取磁盘上的数据到缓存区中，直到读取到所需的数据。

在写入数据时，缓冲流会将数据写入缓存区中，然后再将缓存区中的数据一次性地写入磁盘。当缓存区被写满时，缓冲流也会将缓存区中的数据一次性地写入磁盘。

#### 刷新过程 ####

当缓存区被写满时，缓冲流会自动将缓存区中的数据写入磁盘。此外，缓冲流还提供了手动刷新缓存区的方法`flush()`，调用该方法会强制缓冲流将缓存区中的数据写入磁盘。在正常情况下，缓冲流会在关闭时自动刷新缓存区，将缓存区中的数据写入磁盘。

### Java中的缓冲流 ###

Java中提供了四种缓冲流：

*  BufferedInputStream：缓存输入流
 *  BufferedOutputStream：缓存输出流
 *  BufferedReader：缓存字符输入流
 *  BufferedWriter：缓存字符输出流

#### BufferedInputStream和BufferedOutputStream ####

BufferedInputStream和BufferedOutputStream是针对字节流的缓冲流。它们封装了InputStream和OutputStream，提供了缓存区来暂存输入输出数据。

下面是一个使用`BufferedInputStream`和`BufferedOutputStream`读写文件的示例：

public static void copyFileUsingBufferedStream(File source, File dest) throws IOException {
        
        InputStream input = null;
        OutputStream output = null;
        try {
        
            input = new BufferedInputStream(new FileInputStream(source));
            output = new BufferedOutputStream(new FileOutputStream(dest));
            byte[] buffer = new byte[1024];
            int length;
            while ((length = input.read(buffer)) > 0) {
        
                output.write(buffer, 0, length);
            }
        } finally {
        
            if (input != null) {
        
                input.close();
            }
            if (output != null) {
        
                output.close();
            }
        }
    }

在上面的示例中，我们使用`BufferedInputStream`和`BufferedOutputStream`来读写文件。首先，我们创建了一个`BufferedInputStream`对象和一个`BufferedOutputStream`对象，并将它们分别封装了一个`FileInputStream`对象和一个`FileOutputStream`对象。接着，我们创建了一个1024字节大小的字节数组，用来缓存读取到的数据。然后，我们使用`input.read(buffer)`方法从缓存中读取数据，并使用`output.write(buffer, 0, length)`方法将数据写入缓存中。最后，在关闭文件输入输出流之前，我们必须关闭`BufferedInputStream`和`BufferedOutputStream`对象。

#### BufferedReader和BufferedWriter ####

BufferedReader和BufferedWriter是针对字符流的缓冲流。它们封装了Reader和Writer，提供了缓存区来暂存输入输出数据。

下面是一个使用`BufferedReader`和`BufferedWriter`读写文件的示例：

public static void copyFileUsingBufferedWriter(File source, File dest) throws IOException {
        
        BufferedReader reader = null;
        BufferedWriter writer = null;
        try {
        
            reader = new BufferedReader(new FileReader(source));
            writer = new BufferedWriter(new FileWriter(dest));
            char[] buffer = new char[1024];
            int length;
            while ((length = reader.read(buffer)) > 0) {
        
                writer.write(buffer, 0, length);
            }
        } finally {
        
            if (reader != null) {
        
                reader.close();
            }
            if (writer != null) {
        
                writer.close();
            }
        }
    }

在上面的示例中，我们使用`BufferedReader`和`BufferedWriter`来读写文件。我们首先创建了一个`BufferedReader`对象和一个`BufferedWriter`对象，并将它们分别封装了一个`FileReader`对象和一个`FileWriter`对象。然后，我们创建了一个1024字符大小的字符数组，用来缓存读取到的数据。接着，我们使用`reader.read(buffer)`方法从缓存中读取数据，并使用`writer.write(buffer, 0, length)`方法将数据写入缓存中。最后，在关闭文件输入输出流之前，我们必须关闭`BufferedReader`和`BufferedWriter`对象。

### 总结 ###

缓冲流是一种数据流，它封装了普通数据流，提供了缓存区来暂存输入输出数据。它可以避免频繁的磁盘读写操作，提高了读写效率。在Java中，提供了四种缓冲流：`BufferedInputStream`、`BufferedOutputStream`、`BufferedReader`和`BufferedWriter`。我们可以根据需要选择不同的缓冲流，在读写文件时提高效率。

附：完整代码

import java.io.*;
    
    public class BufferedStreamDemo {
        
    
        public static void main(String[] args) throws IOException {
        
            File sourceFile = new File("source.txt");
            File destFile = new File("dest.txt");
    
            // 使用BufferedInputStream和BufferedOutputStream读写文件
            copyFileUsingBufferedStream(sourceFile, destFile);
    
            // 使用BufferedReader和BufferedWriter读写文件
            copyFileUsingBufferedWriter(sourceFile, destFile);
        }
    
        public static void copyFileUsingBufferedStream(File source, File dest) throws IOException {
        
            InputStream input = null;
            OutputStream output = null;
            try {
        
                input = new BufferedInputStream(new FileInputStream(source));
                output = new BufferedOutputStream(new FileOutputStream(dest));
                byte[] buffer = new byte[1024];
                int length;
                while ((length = input.read(buffer)) > 0) {
        
                    output.write(buffer, 0, length);
                }
            } finally {
        
                if (input != null) {
        
                    input.close();
                }
                if (output != null) {
        
                    output.close();
                }
            }
        }
    
        public static void copyFileUsingBufferedWriter(File source, File dest) throws IOException {
        
            BufferedReader reader = null;
            BufferedWriter writer = null;
            try {
        
                reader = new BufferedReader(new FileReader(source));
                writer = new BufferedWriter(new FileWriter(dest));
                char[] buffer = new char[1024];
                int length;
                while ((length = reader.read(buffer)) > 0) {

[f5048813b1bf47fe845a8fccd92aba7d.png]: https://img-blog.csdnimg.cn/f5048813b1bf47fe845a8fccd92aba7d.png