关于缓冲流的使用

前言：

为了提高数据读写的速度，Java API提供了带缓冲功能的流类，在使用这些流类时，会创建一个内部缓冲区数组

根据数据操作单位可以把缓冲流分为：

BufferedInputStream 和 BufferedOutputStream

BufferedReader 和 BufferedWriter

缓冲流要“套接”在相应的节点流之上，对读写的数据提供了缓冲的功能，提高了读写的效率，同时增加了一些新的方法

对于输出的缓冲流，写出的数据会先在内存中缓存，使用flush()将会使内存中的数据立刻写出

缓冲流的代码示例如下：

package com.atguigu.java;

import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

import org.junit.Test;

/*
* 抽象基类	 节点流（文件流）                                缓冲流（处理流的一种,可以提升文件操作的效率）
* InputStream	 FileInputStream	 BufferedInputStream
* OutputStream	 FileOutputStream	 BufferedOutputStream  (flush())
* Reader	 FileReader	 BufferedReader  (readLine())
* Writer	 FileWriter	 BufferedWriter  (flush())
*/
public class TestBuffered {
@Test
public void testBufferedReader(){
BufferedReader br = null;
BufferedWriter bw = null;
try {
File file = new File("dbcp.txt");
File file1 = new File("dbcp3.txt");
FileReader fr = new FileReader(file);

FileWriter fw = new FileWriter(file1);
br = new BufferedReader(fr);
bw = new BufferedWriter(fw);
//	 char[] c = new char[1024];
//	 int len;
//	 while((len = br.read(c))!= -1){
//	 String str = new String(c, 0, len);
//	 System.out.print(str);
//	 }

String str;
while((str = br.readLine()) != null){
//	 System.out.println(str);
bw.write(str + "\n");     // 用readLine()时，那么写的时候，不会自动换行，所以在写时，需要手动换行
//	 bw.newLine();
bw.flush();
}
}catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
if(bw != null){
try {
bw.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if(br != null){
try {
br.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}

}
}
}

@Test
public void testCopyFile(){
long start = System.currentTimeMillis();
//	 String src = "C:\\Users\\shkstart\\Desktop\\1.avi";
//	 String dest = "C:\\Users\\shkstart\\Desktop\\3.avi";
String src = "C:\\Users\\shkstart\\Desktop\\实验.doc";
String dest = "C:\\Users\\shkstart\\Desktop\\实验1.doc";
copyFile(src,dest);
long end = System.currentTimeMillis();
System.out.println("花费的时间为：" + (end - start));//746
}

//使用缓冲流实现文件的复制的方法
public void copyFile(String src,String dest){
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
try {
//1.提供读入、写出的文件
File file1 = new File(src);
File file2 = new File(dest);
//2.想创建相应的节点流：FileInputStream、FileOutputStream
FileInputStream fis = new FileInputStream(file1);
FileOutputStream fos = new FileOutputStream(file2);
//3.将创建的节点流的对象作为形参传递给缓冲流的构造器中
bis = new BufferedInputStream(fis);
bos = new BufferedOutputStream(fos);
//4.具体的实现文件复制的操作
byte[] b = new byte[1024];
int len;
while((len = bis.read(b)) != -1){
bos.write(b, 0, len);
bos.flush();     //记得用flush()刷新
}
}catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
//5.关闭相应的流
if(bos != null){
try {
bos.close();    //关闭过滤流时,会自动关闭它所包装的底层节点流,所以在本例中就无需再关闭fos
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if(bis != null){
try {
bis.close();  //关闭过滤流时,会自动关闭它所包装的底层节点流,所以在本例中就无需再关闭fis
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}

//使用BufferedInputStream和BufferedOutputStream实现非文本文件的复制
@Test
public void testBufferedInputOutputStream(){
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
try {
//1.提供读入、写出的文件
File file1 = new File("1.jpg");
File file2 = new File("2.jpg");
//2.想创建相应的节点流：FileInputStream、FileOutputStream
FileInputStream fis = new FileInputStream(file1);
FileOutputStream fos = new FileOutputStream(file2);
//3.将创建的节点流的对象作为形参传递给缓冲流的构造器中
bis = new BufferedInputStream(fis);
bos = new BufferedOutputStream(fos);
//4.具体的实现文件复制的操作
byte[] b = new byte[1024];
int len;
while((len = bis.read(b)) != -1){
bos.write(b, 0, len);
bos.flush();
}
}catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}finally{
//5.关闭相应的流
if(bos != null){
try {
bos.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
if(bis != null){
try {
bis.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}