文章目录
- 0. 引言
- 1. 缓冲流
- 2. 缓冲字节流
- 2.1. 缓冲字节输入流
- 2.2. 缓冲字节输出流
- 2.3. 缓冲流实现文件的复制
- 3. 缓冲字符流
0. 引言
上一章节讲了：文件字符流和字节流（基于硬盘）
其中，用到的方法有：FlieInuputStream、FileOutputStream、FileReader、FileWriter，这些都是计算机与硬盘之间发生的io操作。
基于硬盘的读写相对是比较慢的，这个操作的速度受到硬盘的读写速度制约，为了能够提高读写速度，一定程度上绕过硬盘的限制，java提供一种缓冲流（基于内存）来实现。
对应关系如下：
| 字符流&字节流 | 提高读写速度 | 缓冲流 |
|---|---|---|
| FlieInuputStream | → | BufferedInputStream |
| FileOutputStream | → | BufferedOutputStream |
| FileReader | → | BufferedReader |
| FileWriter | → | BufferedWriter |
1. 缓冲流
为了提高数据读写的速度， Java API 提供了带缓冲功能的流类，在使用这些流类时，会创建一个内部缓冲区数组。
根据数据操作单位可以把缓冲流分为：
ufferedInputStream 和 BufferedOutputStream；
BufferedReader 和 BufferedWriter
缓冲流要“套接”在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写的效率，同时增加了一些新的方法。
对于输出的缓冲流，写出的数据会先在内存中缓存，使用 flush() 将会使内存中的数据立刻写出。
缓冲流就是先把数据缓冲到内存里，在内存中去做io操作；
基于内存的io操作大概能比基于硬盘的io操作快75000多倍。
2. 缓冲字节流
ufferedInputStream 和 BufferedOutputStream；
2.1. 缓冲字节输入流
举例：
将D:/java_doc/eclipse-workspace/demo/src/day13/tt.txt 的内容输入到控制台，其中tt.txt的内容为：“这个是tt.txt文件里的内容”
package day13;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
public class Test {
public static void main(String[] args) {
try {
Test.testBufferedInputStream();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 缓冲字节输入流
* BufferedInputStream
* @throws Exception
*/
public static void testBufferedInputStream() throws Exception {
//文件字节输入流对象
FileInputStream in = new FileInputStream("D:\\java_doc\\eclipse-workspace\\demo\\src\\day13\\tt.txt");
//把文件字节输入流 放到 缓冲字节输入流对象
BufferedInputStream br = new BufferedInputStream(in);
byte[] b = new byte[100];
int len = 0;
while((len = br.read(b)) != -1) {
System.out.println(new String(b, 0, len));
}
//关闭流的时候，本着一个最晚开的最早关，依次关
br.close();
in.close();
}
}
运行结果：
2.2. 缓冲字节输出流
举例：
将“hello world”字符串输出到D:/java_doc/eclipse-workspace/demo/src/day13/tt1.txt 中
package day13;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
public class Test {
public static void main(String[] args) {
try {
Test.testBufferedOutputStream();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 缓冲字节输出流
* BufferedOutputStream
*/
public static void testBufferedOutputStream() throws Exception {
//创建字节输出流对象
FileOutputStream out = new FileOutputStream ("D:\\java_doc\\eclipse-workspace\\demo\\src\\day13\\tt1.txt");
//把字节输出流对象放到缓冲字节输出流中
BufferedOutputStream bo = new BufferedOutputStream(out);
String s = "hello world";
bo.write(s.getBytes());//写到内存中
bo.flush();//刷到硬盘上
bo.close();
out.close();
}
}
运行结果：（程序会创建tt1.txt文件，打开tt1.txt文件会看到里面的内容）
2.3. 缓冲流实现文件的复制
举例：
将D:/java_doc/eclipse-workspace/demo/src/day13/tt1.txt 的内容复制到 D:/java_doc/eclipse-workspace/demo/src/day13/tt2.txt 中。其中，tt1.txt文件的内容为：“hello world”。
package day13;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
public class Test {
public static void main(String[] args) {
try {
Test.copyFile();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 缓冲流实现文件的复制
*/
public static void copyFile() throws Exception {
//缓冲输入流
BufferedInputStream br = new BufferedInputStream(new FileInputStream("D:\\java_doc\\eclipse-workspace\\demo\\src\\day13\\tt1.txt"));
//缓冲输出流
BufferedOutputStream bo = new BufferedOutputStream(new FileOutputStream("D:\\java_doc\\eclipse-workspace\\demo\\src\\day13\\tt2.txt"));
byte[] b = new byte[1024];
int len = 0;//设置一个每次读取到的数据长度，直到br.read方法执行到最后（比如说，文件中只有“hello world”，执行到最后一个就是读取到d的后面。这个时候返回值就是-1）
while((len = br.read(b)) != -1) {
bo.write(b, 0, len);//写到内存
}
bo.flush();//刷到硬盘
bo.close();
br.close();
}
}
运行结果：（程序会创建tt2.txt文件，将 tt1.txt 的内容复制到 tt2.txt 中）
3. 缓冲字符流
BufferedReader 和 BufferedWriter；
举例：
与上面代码流程一样，只是换了字符流相关的函数，下面将三种例子写在了一起。
package day13;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
/**
* 缓冲字符流
* @author lby
*
*/
public class Test1 {
public static void main(String[] args) {
try {
// Test1.testBufferedReader();
// Test1.testBufferedWriter();
Test1.copyFile();
} catch (Exception e) {
e.printStackTrace();
}
}
/**
* 缓冲字符输入流
* BufferedReader
*/
public static void testBufferedReader() throws Exception{
FileReader r = new FileReader("D:\\testdemo\\demo\\src\\day13\\tt.txt");
BufferedReader br = new BufferedReader(r);
char[] c = new char[100];
int len = 0;
while((len = br.read(c)) != -1){//br.read(c)读到文件的最后一个字符的下一位，返回值就是-1
System.out.println(new String(c, 0, len));
}
br.close();
r.close();
}
/**
* 缓冲字符输出流
* BufferedWriter
*/
public static void testBufferedWriter() throws Exception{
FileWriter fw = new FileWriter("D:\\testdemo\\demo\\src\\day13\\tt3.txt");
BufferedWriter bw = new BufferedWriter(fw);
String s = "hello world!!!!";
bw.write(s);
bw.flush();
bw.close();
fw.close();
}
/**
* 缓冲字符流复制文件
*/
public static void copyFile() throws Exception{
BufferedReader br = new BufferedReader(new FileReader("D:\\testdemo\\demo\\src\\day13\\tt3.txt"));
BufferedWriter bw = new BufferedWriter(new FileWriter("D:\\testdemo\\demo\\src\\day13\\tt4.txt"));
char[] c = new char[100];
int len = 0;
while((len = br.read(c)) != -1){
bw.write(c, 0, len);
}
bw.flush();
bw.close();
br.close();
}
}
注意：缓冲流是把数据缓冲到内存中
