java核心技术之IO流(四)BufferedInputStream和BufferedOutputStream
最后更新于：2022-04-01 09:58:46
### 简单的说明
一般小的字节(byte)文件的读取和写入数据，我们使用FileInputStream和FileOutputStream类就可以实现了，但是对于大的字节(byte)文件的读取和写入数据，性能就会有很大的问题，我们一般选择BufferedInputStream和BufferedOutputStream来处理，也就是说BufferedInputStream和BufferedOutputStream主要的目的是提高字节(byte)文件的内容读取和写入的性能。
### BufferedInputStream和BufferedOutputStream
### BufferedInputStream类
构造方法：
BufferedInputStream(InputStream in)
创建一个有32字节的缓存区
BufferedInputStream(InputStream in, int size)
创建一个有size大小字节的缓存区
关键方法：
read()
read(byte[] buffer, int byteOffset, int byteCount)
常用使用方式：
~~~
BufferedInputStream buf = new BufferedInputStream(new FileInputStream("file.java"));
~~~
### BufferedOutputStream类
构造方法：
BufferedOutputStream(OutputStream out)
BufferedOutputStream(OutputStream out, int size)
关键方法：
write(int oneByte)
write(byte[] buffer, int offset, int length)
flush()
主要是用来把缓存区的数据刷新到文件中去
常用使用方式：
~~~
BufferedOutputStream buf = new BufferedOutputStream(new FileOutputStream("file.java"));
~~~
### 一个测试的Demo
定义三个方法：
(1)testBufferedInputStream方法—读取文件内容
BufferedInputStream的使用方法：
~~~
//1.创建一个输入字符文件
//2.定义一个输入流FileInputStream
//3.定义一个BufferedInputStream
//4.输入操作
//5.关闭对应的流，注意，可以只关闭最外面的流
~~~
(2)testBufferedOutputStream方法—-往文件写内容
BufferedOutputStream的使用方法：
~~~
//1.创建一个File文件
//2.定义一个输出流
//3.定义一个BufferedOutputStream
//4.输出操作
//5.关闭对应的流，注意，可以只关闭最外面的流
~~~
(3)copyFile方法—-复制文件的方法
~~~
//1.定义输入和输出的文件
//2.定义二个输入输出流
//3.定义二个输入输出缓存流
//4.实现复制功能
//5.关闭对应的流，缓存流的时候，可以只关闭对应的缓存流就可以，先关输出缓存流，再关输入缓存流
~~~
~~~
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.File;
import java.io.FileInputStream;
import java.io.FileNotFoundException;
import java.io.FileOutputStream;
import java.io.IOException;
public class BufferedInputStreamBufferedOutputStream {
//使用BufferedInputStream和BufferedOutputStream，实现文件的复制功能
public static void copyFile(String src,String des,int lenByte){
//3.定义二个输入输出缓存流
BufferedInputStream bis = null;
BufferedOutputStream bos = null;
try {
//1.定义输入和输出文件
File fin = new File(src);
File fout = new File(des);
//2.定义二个输入输出流
FileInputStream fis = new FileInputStream(fin);
FileOutputStream fos = new FileOutputStream(fout);
bis = new BufferedInputStream(fis);
bos = new BufferedOutputStream(fos);
//4.实现复制功能
byte[] b = new byte[lenByte];
int len;
while((len = bis.read(b))!= -1){
bos.write(b, 0, len);
bos.flush();
}
} catch (FileNotFoundException e) {
// TODO Auto-generated catch block
e.printStackTrace();
} 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();
}
}
}
}
//BufferedOutputStream使用样例
public static void testBufferedOutputStream(){
//3.定义一个BufferedOutputStream
BufferedOutputStream bos = null;
try {
//1.定义输出File
//File fin = new File("music_01.mp3");
File fout = new File("BufferedOutputStream.txt");
//2.定义一个输出流
FileOutputStream fos = new FileOutputStream(fout);
bos = new BufferedOutputStream(fos);
//4.输出操作
String str = "BufferedOutputStream使用样例";
bos.write(str.getBytes());
fos.flush();
}catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}finally{
//5.关闭对应的流，注意，可以只关闭最外面的流
if(bos != null){
try {
bos.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
//BufferedInputStream使用样例
public static void testBufferedInputStream(){
//3.定义一个BufferedInputStream
BufferedInputStream bis = null;
try {
//1.定义输入File
//File fin = new File("music_01.mp3");
File fin = new File("hello.txt");
//2.定义一个输入流
FileInputStream fis = new FileInputStream(fin);
bis = new BufferedInputStream(fis);
//4.输入操作
byte[] b = new byte[16];
int len;
while((len = bis.read(b)) != -1){
System.out.println(new String(b, 0,len));
}
}catch (IOException e1) {
// TODO Auto-generated catch block
e1.printStackTrace();
}finally{
//5.关闭对应的流，注意，可以只关闭最外面的流
if(bis != null){
try {
bis.close();
} catch (IOException e) {
// TODO Auto-generated catch block
e.printStackTrace();
}
}
}
}
}
~~~
调用：
~~~
//BufferedInputStream使用样例
BufferedInputStreamBufferedOutputStream.testBufferedInputStream();
//BufferedOutputStream使用样例
BufferedInputStreamBufferedOutputStream.testBufferedOutputStream();
//使用BufferedInputStream和BufferedOutputStream，实现文件的复制功能
long t1 = System.currentTimeMillis();
BufferedInputStreamBufferedOutputStream.copyFile("music_01.mp3","music_02.mp3",1024);//10M大小的音乐
long t2 = System.currentTimeMillis();
System.out.print("复制文件消耗的时间："+(t2 - t1));//10-4437 100-431 1024-60
~~~
说明：
测试来复制一个10M大小的音乐文件(music_01.mp3)，使用缓存流在一次复制10byte时要4437毫秒，一次复制100byte时要431毫秒，一次复制1024byte时要60毫秒。
参考资料：
1.BufferedOutputStream api文档
android_sdk_docs_offline/reference/java/io/BufferedOutputStream.html
2.BufferedInputStream文档
android_sdk_docs_offline/reference/java/io/BufferedInputStream.html
3.BufferedOutputStream与BufferedInputStream视频
[http://edu.csdn.net/course/detail/805/10967?auto_start=1](http://edu.csdn.net/course/detail/805/10967?auto_start=1)