新星计划day4【Java语言IO流】缓冲流的详解

博客首页：痛而不言笑而不语的浅伤

欢迎关注点赞收藏留言

❤：热爱Java学习，期待一起交流！

作者水平很有限，如果发现错误，求告知，多谢！

有问题可以私信交流！！！

---

目录

☆引言☆

一、缓冲流的概述和原理

概述：

原理：

二、缓冲流的分类

三、缓冲流的作用

作用：

注意：

四、缓冲流的使用

4.1字节缓冲输入流【BufferedInputStream】

4.2字节缓冲输出流【BufferedOutputStream】

小练习

4.3字符缓冲输入流【BufferedReader】

4.4字符缓冲输出流【BufferedWriter】

小练习

总结：

---

☆引言☆

        大家好，我是痛而不言笑而不语的浅伤。上一章我们学习了Java语言IO流中的序列化流，本章我们一起来学习Java语言IO流中的缓冲流。这篇文章主要带大家从缓冲流的概述和原理，分类，作用以及使用步骤等几个方面学习JavaIO流中的缓冲流。文章来自我的专栏《JavaSE系列详解》中，想要学习更多JavaSE的其他内容，订阅专栏《JavaSE系列详解》。对文章中描述错误的希望大家积极指出，我会加以改正。

一、缓冲流的概述和原理

概述：

        缓冲流也叫高效流，它可以对四个基本的字节流和字符流进行增强效果，达到提高数据的读写能力。就像是勇士穿上了一层铠甲一样。为了提高数据读写的速度，Java API提供了带缓冲功能的流类，在使用这些流类时，会创建一个内部缓冲区数组，减少系统IO次数，从而提高读写的效率。

图解：

原理：

        这个就好像是一个家庭饮水要从自来水厂输送。内存就好比一个家庭，磁盘就是自来水厂，而要输送水的管道就是IO流，如果我们只要用水，每次直接从自来水厂输送水，时间长，效率低。而缓冲区就是在家里放一个水桶，我们先把水存放进水桶，我们需要的时候直接从水桶取水，这样就提高了取水的效率。缓冲流也一样，先把数据读取到缓冲区，我们再从缓冲区刷新读写，这样就提高了读取的效率。

图解：

二、缓冲流的分类

        因为是对四个基本的字节流和字符流做增强作用，缓冲流要“套接”在相应的节点流之上，所以按照数据类型分类也是四个：

字符缓冲输入流：BufferedInputStream

字节缓冲输出流：BufferedOutputStream

字符缓冲输入流：BufferedReader

字符缓冲输出流：BufferedWriter

三、缓冲流的作用

作用：

        作用前面说了就是对四个基本的字节流和字符流做增强作用，从而提高对数据读写的效率。

当读取数据时，数据按块读入缓冲区，其后的读操作则直接访问缓冲区。

        当写入时，不会直接写到文件，先写到缓冲区中直到缓冲区写满，才会把缓冲区中的数据一次性写到文件里。使用方法flush()可以强制将缓冲区的内容全部写入输出流。

注意：

1.缓冲区不是越大越好，因为缓冲区占用的是内存，过大会严重占用内存。

2.一般默认的缓冲区为8M。

四、缓冲流的使用

        既然我们说了，缓冲流分为四个：字节缓冲输入流、字符缓冲输出流、字符缓冲输入流、字符缓冲输出流。依次对它们做一个详细的使用。

4.1字节缓冲输入流【BufferedInputStream】

继承关系：

        java.io.BufferedInputStream extends InputStream

构造方法：

BufferedInputStream(InputStream in) 创建一个 BufferedInputStream 并保存其参数，即输入流 in，以便将来使用。

BufferedInputStream(InputStream in, int size) 创建具有指定缓冲区大小的 BufferedInputStream 并保存其参数，即 输入流 in，以便将来使用。

参数：

InputStream in：字节输入流

int size：指定缓冲流内部缓冲区的大小，不指定默认

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

int read() 从输入流中读取数据的下一个字节。

int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。

void close() 关闭此输入流并释放与该流关联的所有系统资源。

使用步骤(重点)

1.创建FileInputStream对象，构造方法中绑定要读取的数据源

2.创建BufferedInputStream对象，构造方法中传递FileInputStream对象，提高FileInputStream对象的效率

3.使用BufferedInputStream对象中的read方法，把读取文件中的数据

4.释放资源

代码演示：

public static void main(String[] args) throws IOException {
//1.创建FileInputStream对象，构造方法中绑定要写入的目的地
FileInputStream fis=new FileInputStream("F:\\workspace\\新建文件夹\\b.txt");
//2.创建BufferedInputStream对象，构造方法中传递FileInputStream对象，提高FileInputStream对象的效率
BufferedInputStream bis=new BufferedInputStream(fis);
//3.使用BufferedInputStream对象中的read方法，把文件中的数据写入
/*int len=0;//记录每次读取到的字节
while((len=bis.read())!=-1){
System.out.println(len);
}*/
//int read(byte[] b) 从输入流中读取一定数量的字节，并将其存储在缓冲区数组 b 中。
byte[] bytes=new byte[1024];
int len=0;
while((len=bis.read(bytes))!=-1){
System.out.println(new String (bytes,0,len));
}
//4.释放资源
bis.close();
}

输出结果 ：

 

4.2字节缓冲输出流【BufferedOutputStream】

继承关系：

java.io.BufferedOutputStream extends OutputStream

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

void close() 关闭此输出流并释放与此流有关的所有系统资源。

void flush() 刷新此输出流并强制写出所有缓冲的输出字节。

void write(byte[] b) 将 b.length 个字节从指定的 byte 数组写入此输出流。

void write(byte[] b, int off, int len) 将指定 byte 数组中从偏移量 off 开始的 len 个字节写入此输出流。

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方法刷新数据）

代码演示：

public class Demo01BufferedOutputStream {
public static void main(String[] args) throws IOException {
//1.创建FileOutputStream对象，构造方法中绑定要输出的目的地
FileOutputStream fos=new FileOutputStream("F:\\workspace\\新建文件夹\\b.txt");
//2.创建BufferedOutputStream对象，构造方法中传递FileOutputStream对象，提高FileOutputStream对象的效率
BufferedOutputStream bos=new BufferedOutputStream(fos);
//3.使用BufferedOutputStream对象中的方法write，把数据写入到内部缓冲区中
bos.write("我是用缓冲流写进来的数据".getBytes());
//5.释放资源（会先调用flush方法刷新数据）
bos.close();
}
}

输出结果：

小练习

文件的复制练习：一读一写

明确:

数据源：F:\\workspace\\新建文件夹\\集合框架图.jpg

数据的目的地：F:\\workspace\\新建文件夹\\集合\\集合框架图.jpg

步骤分析：

1.创建字节缓冲输入流对象，构造方法中传递字节输入流

2.创建字节缓冲输出流对象，构造方法中传递字节输出流

3.使用字节缓冲输入流对象中的read方法读取文件中的数据

4.使用字节缓冲输出流对象中的write方法把读取的数据写入到内部缓冲区中

5.释放资源

代码演示：

public class Demo03CopyFile {
public static void main(String[] args) throws IOException {
//测试效率
long s =System.currentTimeMillis();
//1.创建字节缓冲输入流对象，构造方法中传递字节输入流
BufferedInputStream bis=new BufferedInputStream(new FileInputStream("F:\\workspace\\新建文件夹\\集合框架图.jpg"));
//2.创建字节缓冲输出流对象，构造方法中传递字节输出流
BufferedOutputStream bos=new BufferedOutputStream(new FileOutputStream("F:\\workspace\\新建文件夹\\集合\\集合框架图.jpg"));
//3.使用字节缓冲输入流对象中的read方法读取文件中的数据
//一次一个字节
/*int len =0;
while((len=bis.read())!=-1){
bos.write(len );
}*/
//一次读取多个字节
int len =0;
byte[]bs=new byte[1024];
while((len=bis.read(bs))!=-1){
bos.write(bs,0,len);
}
//5.释放资源
bis.close();
bos.close();
long e=System.currentTimeMillis();
System.out.println("复制文件共耗时："+(e-s)+"毫秒。");
}
}

复制文件时我们计算复制所用时间，一秒=1000毫秒。

输出结果：

4.3字符缓冲输入流【BufferedReader】

继承关系:

java.io.BufferedReader extends Read

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

int read() 读取单个字符。

int read(char[] cbuf) 将字符读入数组。

void close() 关闭该流并释放与之关联的所有资源

参数：

Reader in:字符输入流

我们可以传递FileReader,缓冲流会给FileReader增加一个缓冲区，提高FileReader的读取效率

特有的成员方法：

String readLine（） 读取一个文本行

通过下列字符之一即可认为某行已终止：换行 ('\n')、回车 ('\r') 或回车后直接跟着换行。

使用步骤：

1.创建字符缓冲输入流对象，构造方法中传递一个字符输入流

2.使用字符缓冲输入流中的read/readLine方法，把文件中的数据读取到缓冲区中

3.释放资源

代码演示：

public class Demo05BufferedReader {
public static void main(String[] args) throws IOException {
//1.创建字符缓冲输入流对象，构造方法中传递一个字符输入流
BufferedReader br=new BufferedReader(new FileReader("F:\\workspace\\新建文件夹\\a.txt"));
//2.使用字符缓冲输入流中的read方法，把文件中的数据读取到缓冲区中
String len;
while((len=br.readLine())!=null){
System.out.println(len);
}
//3.释放资源
br.close();
}
}

打印结果：

4.4字符缓冲输出流【BufferedWriter】

继承关系：

iava.io.BufferedWriter extends Writer

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

*void write(int c) 写入单个字符。

* void write(char[] cbuf) 写入字符数组。

* abstract void write(char[] cbuf, int off, int len) 写入字符数组的某一部分。

* void write(String str) 写入字符串。

* void write(String str, int off, int len) 写入字符串的某一部分。

* void flush() 刷新该流的缓冲。

* void close() 刷新该流的缓冲。

构造方法：

BufferedWriter(Writer out) 创建一个使用默认大小输出缓冲区的缓冲字符输出流。

BufferedWriter(Writer out, int sz) 创建一个使用给定大小输出缓冲区的新缓冲字符输出流。

参数：

writer out：字符输出流

我们可以传递FileWriter，缓冲流会给FileWriter增加一个缓冲区，提高FileWriter的写入效率

int sz：指定缓冲区的大小，不写默认大小

特有的成员方法：

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

换行：换行符号

window：\r\n

linux:/n

mac:/r

字符缓冲输出流的使用步骤：

1.创建字符缓冲输出流对象，构造方法中传递字符输出流

2.调用字符缓冲输出流中的write方法，把数据写入到内存缓冲区中

3.调用字符缓冲输出流中的flush方法，把内存缓冲区中的数据，刷新到文件中

4.释放资源

代码演示：

public class Demo04BufferedWriter {
public static void main(String[] args) throws IOException {
//1.创建字符缓冲输出流对象，构造方法中传递字符输出流
BufferedWriter bw=new BufferedWriter(new FileWriter("F:\\workspace\\新建文件夹\\a.txt"));
//2.调用字符缓冲输出流中的write方法，把数据写入到内存缓冲区中
bw.write("今天我学会了字符缓冲输出流，非常高兴！");
//3.调用字符缓冲输出流中的flush方法，把内存缓冲区中的数据，刷新到文件中
bw.flush();
//4.释放资源
bw.close();
}
}

输出结果:

 

小练习

对文本的内容进行排序

按照（1.2.3...）顺序排序

分析：

1.创建一个HashMap集合对象，key存储每行文本的序号（1.2.3...）,value存储每行的文本

2.创建字符缓冲输入流对象，构造方法中绑定字符输入流

3.创建字符缓冲输出流对象，构造方法中绑定字符输出流

4.使用字符缓冲输入流中的方法ReadLine，逐行读取文本

5.对读取到的文本进行切割，获取行中的序号和文本内容

6.把切割好的序号和文本内容存储到HashMap集合中（key序号是有序的，会自动排序）

7.遍历HasMap集合，获取每一个值对

8.把每一个键值对，拼接为一个文本行

9.把拼接好的文本，使用字符缓冲输出流中的方法write，写到文件中

10.释放资源

代码演示：

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

结果：

总结：

        好了以上就是缓冲流的一些学习，你是否学会了呢？今日的分享到此结束，由于笔者还在学习的路上辗转徘徊，水平有限，文章中可能有一些不对之处，还请各位大佬指正，最后祝愿每一个热爱编程的小伙伴，学习的路上不迷路，实现自己的追求。如果大家觉得还不错，希望多多支持一下。

        你的点赞是对我最大的鼓励。

        你的收藏是对我文章的认可。

        你的关注是对我前进的动力。

        【完】