文章目录
- 前言
- 一、带缓冲的输入输出流是什么？
- 二、使用方法
- 1.BufferedInputStream与BufferedOutputStream类
- 2.BufferedReader与BufferedWriter类
- 总结
前言
输入输出流可以视为，从A点把货物搬运至B点。那么带缓冲的意思可以视为用货车把A点的货物搬运至B点。顾名思义，带有缓存的输入输出流运行效率更高。本篇文章讲述输入输出流更深一步的使用。
一、带缓存的输入输出流是什么？
缓存是I/O的一种性能优化。缓存流为I/O流增加了内存缓存区，相当于运输货物过程中的货箱。有了缓存区（比喻，货箱），使得在流上执行skip()、mark()与reset()方法都可以使用。总而言之，这篇文章讲述，在输入输出流外部进行包装，带有缓存功能，提高IO流效率。（需要导入java.io包）
二、使用方法
1.BufferedInputStream与BufferedOutputStream类
构造方法：
new BufferedInputStream(InputStream in);
//将字节输入流包装成一个带有32个字节的缓存字节输入流
new BufferedInputStream(InputStream in,int size);
//将字节输入流包装成一个带有指定个数字节的缓存字节输入流
new BufferedOutputStream(OutputStream out);
//将字节输出流包装成一个带有32个字节的缓存字节输出流
new BufferedOutputStream(OutputStream out,int size);
//将字节输出流包装成一个带有指定个数字节的缓存字节输出流实操展示：
项目：通过缓存字节输出流输入数据至文件中，再由缓存字节输入流读取出来。计时运行时间，比较一下带缓存和不带缓存的区别。
import java.io.*;
public class Demo {
public static void main(String[] args) {
File file = new File("show.txt");
BufferedOutputStream outputStream2 = null;
FileOutputStream outputStream = null;
BufferedInputStream inputStream2 = null;
FileInputStream inputStream = null;
long startime = System.currentTimeMillis();
try{
outputStream = new FileOutputStream(file);
outputStream2 = new BufferedOutputStream(outputStream);
String str = "安得广厦千万间";
byte b[] = str.getBytes();
outputStream2.write(b);
outputStream2.flush();
//包装后需要每次写入都刷新一下，保证写入内容完整，装不满字节数是不会写入的，刷新直接将其写入
byte b2[] = new byte[1024];
inputStream = new FileInputStream(file);
inputStream2 = new BufferedInputStream(inputStream);
int len = inputStream2.read(b2);
System.out.println("文件内容："+new String(b2,0,len));
while (inputStream.read(b2)!=-1);
long endtime2 = System.currentTimeMillis();
System.out.println("带缓存的字节输入流所耗时间为："+(endtime2-startime));
while (inputStream.read(b)!=-1);
long endtime = System.currentTimeMillis();
System.out.println("字节输入流所耗时间为："+(endtime-startime));
}catch(IOException e){
e.printStackTrace();
}finally{
try {
//先开启的流最后关闭，开关顺序为 123，321
outputStream2.close();
outputStream.close();
inputStream2.close();
inputStream.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}BufferedOutputStream类缓冲输出字节流使用注意：
（1）在try代码块中实例化，括号引入FileOutputStream对象，进行包装，带入缓冲。
（2）在调用write()方法写入信息时，同时要调用flush()方法刷新，保证字符数据完整存入。
（3）最先开启的流，最后关闭。流的开关顺序为 123，321
BufferedInputStream类缓冲输入字节流使用注意：
（1）在try代码块中实例化，括号引入FileInputStream对象，进行包装，带入缓冲。
（2）最先开启的流，最后关闭。流的开关顺序为 123，321
运行结果：
如图所示，带有缓存的字节输入流读取信息的速度更快。无论是输入流还是输出流，带上缓存的目的都是为了提高运行效率。
2.BufferedReader与BufferedWriter类
BufferedReader类和BufferedWriter类分别继承了Reader类和Writer类，可以使用其基本方法的同时本施也增加了些方法。
构造方法：
new BufferedWriter(FileWriter writer);
//将字符输入流包装成一个带有32个字节的缓存字符输入流
new BufferedReader(FileReader reader);
//将字符输出流包装成一个带有32个字节的缓存字符输出流
| 方法 | 功能描述 |
| write(String s,int off,int len) | 写入字符串s的某一部分（从off到len） |
| flush() | 刷新该流的缓存，缓存字符保存进文件中 |
| newLine() | 写入一个行分隔符，换行 |
| 方法 | 功能描述 |
| read() | 读取单个字符 |
| readLine() | 读取一个文本行，并将其返回为字符串。若无数据返回null值。不断读取下一行，直到遇到文件末尾。 |
实操展示：
import java.io.*;
public class Demo {
public static void main(String[] args) {
File file = new File("show.txt");
BufferedWriter writer = null;
FileWriter writer2 = null;
BufferedReader reader = null;
FileReader reader2 = null;
try{
writer2 = new FileWriter(file);
writer = new BufferedWriter(writer2);
String str1 = "长亭外，古道边，芳草碧连天。";
String str2 = "晚风拂柳笛声残，夕阳山外山。";
writer.write(str1);
writer.newLine(); //换行输入内容
writer.write(str2);
writer.flush(); //刷新
reader2 = new FileReader(file);
reader = new BufferedReader(reader2);
String tmp = null;
int i = 1; //计数器
while ((tmp=reader.readLine())!= null) {
//使用readLine()方法读取下一行信息，不需要引入参数保存数据。
System.out.println("第"+i+"行的内容为："+tmp);
i++;
}
}catch(IOException e){
e.printStackTrace();
}finally{
try {
//先开启的流最后关闭，开关顺序为 123，321
writer.close();
writer2.close();
reader.close();
reader2.close();
} catch (IOException e) {
e.printStackTrace();
}
}
}
}BufferedWriter类缓冲输入字节流使用注意：
（1）在try代码块中实例化，括号引入FileInWriter对象，进行包装，带入缓冲。
（2）在调用write()方法写入信息时，同时要调用flush()方法刷新，保证字符数据完整存入。
（3）最先开启的流，最后关闭。流的开关顺序为 123，321
BufferedReader类缓冲输出字节流使用注意：
（1）在try代码块中实例化，括号引入FileOutputStream对象，进行包装，带入缓冲。
（2）最先开启的流，最后关闭。流的开关顺序为 123，321
运行结果：
文件输入内容
文件输出内容
如图所示，字符输入输出流包装后，带入缓存。不仅能提升字符数据传输的效率，而且还能使用额外方便的方法，例如，readLine()、newLine等。
总结
以上就是带缓存的输入输出流，本文只是简单介绍了带缓存的输入输出流的使用，而输入输出流带上缓存既能提高运行速度，又有新的便利的方法可供使用。
