缓冲流

最新推荐文章于 2025-06-05 23:53:49 发布
原创 最新推荐文章于 2025-06-05 23:53:49 发布 · 3.8k 阅读 · 4 ·
CC 4.0 BY-SA版权
版权声明：本文为博主原创文章，遵循 CC 4.0 BY-SA 版权协议，转载请附上原文出处链接和本声明。

缓冲流的原理

在这里插入图片描述
java.io.BufferedOutputStream extends OutputStream

BufferedOutputStream ————字节缓冲输出流

继承自父类的共性方法

  • public void close（）——关闭此输出流并释放与此流相关联的任何系统资源。
  • public void flush（）——刷新此输出流并强制任何缓冲的输出字节被写出。
  • public void write（byte[ ] b）——将b.length字节从指定的字节数组写入到此输出流。
  • public void write（byte[ ] b,int off,int len）——从指定的字节数组写入len字节，从偏移量off开始输出到此输出流。
  • public abstract void write（int b）——将指定的字节输出流。
    构造方法
  • BufferedOutputStream （OutputStream out）——创建一个新的缓冲输出流，以将数据写入指定的底层输出流。
  • BufferedOutputStream （OutputStream out，int
    size）——创建一个新的缓冲输出流，以将具有指定缓冲区大小的数据写入指定的底层输出流。
    参数
  • OutputStream out————字节输出流
    我们可以传递FileOutPutStream,缓冲流会给FileOutPutStream增加一个缓冲区，提高FileOutPutStream的写入效率。
  • int size—————————指定缓冲流内部缓冲区的大小，不指定默认。
    使用步骤（重点）
    1.创建FileOutPutStream对象，构造方法中绑定要输出的目的地。
    2.创建BufferedOutputStream对象，构造方法中传递FileOutPutStream对象，提高FileOutPutStream对象效率。
    3.使用BufferedOutputStream对象中的方法write，把数
    据写入到内部缓冲区中。
    4.使用BufferedOutputStream对象中的方法flush，把内部缓冲区中的数据，刷新到文件中。
    5.释放资源（会先调用flush方法刷新数据，第四步可以省略）。

java.io.BufferedIutputStream extends IutputStream

BufferedIntputStream ————字节缓冲输入流

继承自父类的共性方法

  • int read（）——从输入流中读取数据的下一个字节。
  • int read（char[ ] cbuf）——从输入流中读取一定数量的字节，并将其存储在缓冲区数组b中。
  • void close（）——关闭此输入流并释放与此流相关联的任何系统资源。
  • 构造方法
  • BufferedIntputStream （IutputStream in）——创建一个BufferedIntputStream 并保存其参数，即输入流in，以便将来使用。
  • BufferedIntputStream （IntputStream in，int
    size）——创建具有指定缓冲区大小的BufferedIntputStream 保存其参数，即输入流in。
    参数
  • IntputStream in————字节输入流
    我们可以传递FileIntPutStream,缓冲流会给FileIntPutStream增加一个缓冲区，提高FileIntPutStream的读取效率。
  • int size—————————指定缓冲流内部缓冲区的大小，不指定默认。
    使用步骤（重点）
    1.创建FileIntPutStream对象，构造方法中绑定要读取的数据。
    2.创建BufferedIntputStream 对象，构造方法中传递FileIntPutStream对象，提高FileIntPutStream对象读取效率。
    3.使用BufferedIntputStream 对象中的方法read，读取文件
    4.释放资源。

java.io.BufferedWriter extends Writer

字符缓冲输出流——BufferedWriter类

继承自父类的共性成员方法

  • public void write（int c）—————写入单个字符。

  • public void write（char[ ] cbuf）——写入字符数组。

  • abstract void write（char[ ] cbuf，int off,int len）——写入字符数组的某一部分，off数组的开始索引，len写的字符个数。

  • void write（String str）——写入字符串。

  • void write（char[ ] cbuf，int off,int len）——写入字符数组的某一部分，off字符串的开始索引，len写的字符个数。

  • void flush（）——刷新该流的缓冲。

  • public void close（）————————关闭此流，但要先刷新它。
    构造方法

  • BufferedWriter （Writer out）————创建一个使用默认大小输出缓冲区的缓冲字符输出流。

  • BufferedWriter （Writer out,int sz）——创建一个使用给定大小输出缓冲区的缓冲字符输出流。
    参数
    Writer out————字符输出流
    我们可以传递FileWtite,缓冲流会给FileWtite增加一个缓冲区，提高FileWtite的写入效率。
    int sz—————指定缓冲区的大小，不写默认大小。
    特有的成员方法

  • void newLine()————写入一个行分隔符。会根据不同的操作系统，获取不同的行分隔符。

使用步骤
1.创建字符缓冲输出流对象，构造方法中传递字符输出流。
2.调用字符缓冲输出流对象的方法write，把数据写入到缓冲区中。
3.调用字符缓冲输出流对象的方法flush，把内存缓冲区中的数据，刷新到文件中。
4.释放资源。
java.io.BufferedReader extends Reader

字符输入流——BufferedReader 类

继承自父类的共性成员方法

  • int read（）——读取单个字符并返回。
  • int read（char[ ] cbuf）——一次读取多个字符，将字符读入数组。
  • void close（）——关闭该流并释放与之关联的所有资源。
    构造方法
  • BufferedReader （Reader in）————创建一个使用默认大小的输入缓冲区的缓冲字符输入流。
  • BufferedReader （Reader in）————创建一个使用是定大小输入缓冲区的缓冲字符输入流。
    参数——————读取文件的数据源
    Reader in——字符输入流
    我们可以传递FileReader,缓冲流会给FileReader增加一个缓冲区，提高FileReader的读取效率。
    特有的成员方法
  • String readLine( )——————读取一个文本行。读取一行数据。
    行的终止符号—————————通过下列字符即可认为某行已终止————换行（‘\n’）、回车（‘\r’）或者回车后直接跟着换行（\n\r）。
    返回值
    包含改行内容的字符串，不包含任何终止符，如果已达流末尾，则放回null。
    使用步骤
    1.创建一个字符缓冲输入流对象，构造方法中传递符缓冲输入流。
    2.使用符缓冲输入流对象中的方法read/readLine读取文本。
    3.释放资源。

练习——对文本的内容进行排序

package cn.lrf.IODemo;

import java.io.*;
import java.util.HashMap;

/*练习
 * 对文本的内容进行排序
 * 按照（1，2，3...顺序进行排序）
 * 分析
 * 1.创建一个HashMap集合对象，可以存储每行文本的序号1，2，3...);value:存储每行的文本
 * 2.创建字符缓冲输入流对象，构造方法中绑定字符输入流。
 * 3.创建字符缓冲输出流对象，构造方法中绑定字符输入流。
 * 4.使用字符缓冲输入流中的方法readLine，逐行读取文本。
 * 5.对读取到的文本进行切割，获取行中的序号和文本内容。
 * 6.把切割好的序号和文本的内容存储到HashMap集合中（key序号是有序的，会自动排序1，2，3，4...）
 * 7.遍历HashMap集合，获取每一个键值对。
 * 8.把每一个键值对，拼接为一个文本行
 * 9.把拼接好的文本，使用字符缓冲输出流的方法write，写入到文件中。
 * 10.释放资源。
 * */
public class Demo05Test {
    public static void main(String[] args) throws IOException {
        // 1.创建一个HashMap集合对象，可以存储每行文本的序号1，2，3...);value:存储每行的文本
        HashMap<String, String> map = new HashMap<>();
        // 2.创建字符缓冲输入流对象，构造方法中绑定字符输入流。
        BufferedReader br = new BufferedReader(new FileReader("day08-code\\src\\cn\\lrf\\IODemo\\c.txt"));
        //3.创建字符缓冲输出流对象，构造方法中绑定字符输入流。
        BufferedWriter bw = new BufferedWriter(new FileWriter("day08-code\\src\\cn\\lrf\\IODemo\\d.txt"));
        // 4.使用字符缓冲输入流中的方法readLine，逐行读取文本。
        String line;
        while ((line = br.readLine()) != null) {
            // 5.对读取到的文本进行切割，获取行中的序号和文本内容。
            String[] arr = line.split("\\.");
            //6.把切割好的序号和文本的内容存储到HashMap集合中（key序号是有序的，会自动排序1，2，3，4...）
            map.put(arr[0], arr[1]);
        }
        // 7.遍历HashMap集合，获取每一个键值对。
        for (String key : map.keySet()) {
            String value = map.get(key);
            // 8.把每一个键值对，拼接为一个文本行
            line = key + "." + value;
            // 9.把拼接好的文本，使用字符缓冲输出流的方法write，写入到文件中。
            bw.write(line);
            bw.newLine();//写换行
        }
        // 10.释放资源。

        bw.close();

        br.close();
    }
}
Java中的缓冲流——学习小结
01-20
1.什么是缓冲流，有什么作用？ 这里需要说明一点小知识，在对硬盘进行读写操作时，一个完整的文件的读写速率要远远高于同样大小的散文件的读写速率。这是因为散文件需要不断地访问、关闭硬盘，极大地浪费了时间，...
缓冲流——字节缓冲流
01-20
1. 缓冲流 1.1 缓冲流的作用 使用缓冲数组以后，整体的读取，写入效率提升很大！！！ 降低了CPU通过内存访问硬盘的次数。提高效率，降低磁盘损耗。 字节输入缓冲 BufferedInputStream 字节输出缓冲 ...
Java-IO流之缓冲流详解
aa_hdkf_vg的博客
06-05 828
Java 中常见的输入输出(IO)操作，直接操作原始的字节流或字符流往往效率低下，Java IO体系中的缓冲流(Buffered Stream)通过引入缓冲区机制，显著提高了IO操作的性能。本文我将深入探讨Java缓冲流的原理、使用方法及性能优化技巧，帮你全面掌握这一重要技术
Visual C++源代码 55 如何使用缓冲流复制文件
06-18
Visual C++源代码 55 如何使用缓冲流复制文件Visual C++源代码 55 如何使用缓冲流复制文件Visual C++源代码 55 如何使用缓冲流复制文件Visual C++源代码 55 如何使用缓冲流复制文件Visual C++源代码 55 如何使用缓冲...
Java IO流之字符缓冲流实例详解
08-26
Java IO流中的字符缓冲流（Character Buffer Stream）是提高数据读写效率的重要工具，它针对字符流进行优化，尤其在处理大量文本数据时效果显著。本文将深入解析字符缓冲流的使用及其作用。 字符流主要分为两个核心...
Java字节缓冲流原理与用法详解
08-25
Java字节缓冲流原理与用法详解 Java字节缓冲流是Java IO系统中的一种重要组成部分，用于提高IO操作的性能。下面将详细介绍Java字节缓冲流的原理和用法。 一、Java字节缓冲流原理 Java字节缓冲流是一种基于缓冲区...
Java缓冲流
最新发布
06-14
<think>我们正在讨论Java中的缓冲流。根据引用[1]和[3]，缓冲流是JavaI/O流中的一种，用于提高I/O操作的效率。缓冲流通过在内存中设置一个缓冲区，减少实际读写磁盘的次数，从而提升性能。缓冲流属于高级IO操作，通常包装在字节流或字符流之上。例如，BufferedInputStream和BufferedOutputStream是字节缓冲流，而BufferedReader和BufferedWriter是字符缓冲流。使用缓冲流的一般步骤：1.创建基本的节点流（如FileInputStream、FileOutputStream、FileReader、FileWriter）。2.将节点流传递给缓冲流的构造器，创建缓冲流。3.通过缓冲流进行读写操作。4.关闭流（只需关闭最外层的缓冲流，它会自动关闭内部的节点流）。下面我们分别给出字节缓冲流和字符缓冲流的示例。示例1：使用字节缓冲流复制文件（BufferedInputStream和BufferedOutputStream）```javaimportjava.io.*;publicclassBufferedStreamExample{publicstaticvoidmain(String[]args){StringsourceFile="source.jpg";StringdestFile="destination.jpg";try(InputStreamin=newBufferedInputStream(newFileInputStream(sourceFile));OutputStreamout=newBufferedOutputStream(newFileOutputStream(destFile))){byte[]buffer=newbyte[4096];//4KB缓冲区intbytesRead;while((bytesRead=in.read(buffer))!=-1){out.write(buffer,0,bytesRead);}}catch(IOExceptione){e.printStackTrace();}}}```示例2：使用字符缓冲流读写文本文件（BufferedReader和BufferedWriter）```javaimportjava.io.*;publicclassBufferedCharacterStreamExample{publicstaticvoidmain(String[]args){StringinputFile="input.txt";StringoutputFile="output.txt";try(BufferedReaderreader=newBufferedReader(newFileReader(inputFile));BufferedWriterwriter=newBufferedWriter(newFileWriter(outputFile))){Stringline;while((line=reader.readLine())!=null){writer.write(line);writer.newLine();//写入换行符，因为readLine()会去掉换行符}}catch(IOExceptione){e.printStackTrace();}}}```注意事项：1.缓冲流默认的缓冲区大小是8KB，但我们可以通过构造器指定缓冲区大小，例如：`newBufferedInputStream(in,16384)`设置16KB缓冲区。2.使用缓冲流时，写入操作可能需要手动刷新缓冲区（调用`flush()`方法）以确保数据被立即写入。但关闭流时会自动刷新。3.对于字符缓冲流，BufferedReader提供了`readLine()`方法，可以方便地按行读取文本；BufferedWriter提供了`newLine()`方法，可以写入平台相关的换行符。引用[3]中提到了最佳实践：使用缓冲流提高性能。因为每次访问磁盘或网络的开销很大，缓冲流通过减少访问次数来提高效率。因此，在大多数情况下，对于文件操作，我们都应该使用缓冲流。但要注意，如果数据量很小，可能效果不明显。如果用户的问题是关于缓冲流的使用，以上内容应该可以满足。下面生成相关问题。</think>### Java 缓冲流使用指南 在 Java I/O 系统中，缓冲流是提高读写效率的重要工具。它们通过在内存中创建缓冲区，减少实际物理读写的次数，显著提升 I/O 性能。主要缓冲流类包括 `BufferedInputStream`、`BufferedOutputStream`、`BufferedReader` 和 `BufferedWriter`[^1][^3]。 #### 一、核心缓冲流类型 1. **字节缓冲流**（处理二进制数据）： - `BufferedInputStream`：包装字节输入流 - `BufferedOutputStream`：包装字节输出流 - 默认缓冲区大小：8KB（可自定义） 2. **字符缓冲流**（处理文本数据）： - `BufferedReader`：提供 `readLine()` 方法 - `BufferedWriter`：提供 `newLine()` 方法 - 默认缓冲区大小：16KB（可自定义） #### 二、使用步骤 1. **创建基础流**：先建立节点流（如 `FileInputStream`） 2. **包装缓冲流**：用缓冲流包装基础流 3. **读写操作**：通过缓冲流进行 I/O 4. **关闭资源**：只需关闭最外层缓冲流（自动关闭内层流） #### 三、代码示例 ```java // 1. 字节缓冲流复制文件 try (BufferedInputStream bis = new BufferedInputStream(new FileInputStream("source.jpg")); BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream("copy.jpg"))) { byte[] buffer = new byte[4096]; // 4KB 临时缓冲区 int bytesRead; while ((bytesRead = bis.read(buffer)) != -1) { bos.write(buffer, 0, bytesRead); } } // 2. 字符缓冲流读写文本 try (BufferedReader br = new BufferedReader(new FileReader("input.txt")); BufferedWriter bw = new BufferedWriter(new FileWriter("output.txt"))) { String line; while ((line = br.readLine()) != null) { bw.write(line.toUpperCase()); // 转为大写写入 bw.newLine(); // 写入换行符 } bw.flush(); // 手动刷新缓冲区 } ``` #### 四、性能优化技巧 1. **缓冲区大小调整**：根据文件大小调整缓冲区（大文件用更大缓冲区） ```java new BufferedInputStream(new FileInputStream("large.dat"), 65536); // 64KB ``` 2. **及时关闭资源**：使用 try-with-resources 确保自动关闭 3. **手动刷新**：关键数据后调用 `flush()` 强制写入 4. **避免嵌套多层**：缓冲流包装基础流即可，无需多层包装 #### 五、注意事项 1. **字符编码**：字符流需注意文件编码，建议明确指定 ```java new BufferedReader(new InputStreamReader(new FileInputStream("data.txt"), StandardCharsets.UTF_8)); ``` 2. **缓冲区生命周期**：流关闭后缓冲区失效 3. **异常处理**：捕获 `IOException` 处理磁盘错误 4. **内存管理**：超大文件需分块处理，避免内存溢出[^3] > **适用场景**：文件复制、日志处理、网络数据传输等高频 I/O 操作。测试表明，使用缓冲流可使文件读写速度提升 5-10 倍[^3]。
评论
添加红包

请填写红包祝福语或标题

个

红包个数最小为10个

元

红包金额最低5元

当前余额3.43元 前往充值 >
需支付：10.00元
成就一亿技术人!
领取后你会自动成为博主和红包主的粉丝 规则
hope_wisdom
发出的红包
实付元
使用余额支付
点击重新获取
扫码支付
钱包余额 0

抵扣说明：

1.余额是钱包充值的虚拟货币，按照1:1的比例进行支付金额的抵扣。
2.余额无法直接购买下载，可以购买VIP、付费专栏及课程。

余额充值