Java基础-IO流对象之字节缓冲流(BufferedOutputStream与BufferedInputStream)

　　　　　　　　　　Java基础-IO流对象之字节缓冲流(BufferedOutputStream与BufferedInputStream)

　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　　作者：尹正杰

版权声明：原创作品，谢绝转载！否则将追究法律责任。

　　在我们学习字节流与字符流的时候，大家都进行过读取文件中数据的操作，读取数据量大的文件时，读取的速度会很慢，很影响我们程序的效率，那么，我想提高速度，怎么办？Java中提高了一套缓冲流，它的存在，可提高IO流的读写速度

　　缓冲流，根据流的分类分为字节缓冲流与字符缓冲流。本篇博客主要介绍的是字节缓冲流。

一.字节缓冲流

　　字节缓冲流根据流的方向，共有2个:

　　　　　　1>. 写入数据到流中，字节缓冲输出流 BufferedOutputStream

　　　　　　2>.读取流中的数据，字节缓冲输入流 BufferedInputStream

　　它们的内部都包含了一个缓冲区，通过缓冲区读写，就可以提高了IO流的读写速度

二.字节输出缓冲流

　　java.io.BufferedOutputStream作用：提高原有输出流的写入效率。

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */

 package cn.org.yinzhengjie.note5;

 import java.io.BufferedOutputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;

 public class BufferedOutputStreamDemo {
     public static void main(String[] args) throws IOException {
         //创建字节输出流，绑定文件
         FileOutputStream fos = new FileOutputStream("yinzhengjie.txt");
         //创建字节输出流缓冲流对象，构造方法中，传递字节输出流，实这里也可以直接匿名生成。
         BufferedOutputStream bos = new BufferedOutputStream(fos);
         //写入一个字节
         bos.write(97);
         //将字符串变成字节数组
         byte[] buf = "yinzhengjie".getBytes();
         //写一个字节数组
         bos.write(buf);
         //写入字节数组的一部分
         bos.write(buf, 3, 5);
         //释放资源,我们不用关闭fos对象，因为关闭bos对象会自动关闭fos流。
         bos.close();
     }
 }

三.字节输入缓冲流

　　java.io.BufferedInputStream作用：提高原有输入流的读取效率。

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */

 package cn.org.yinzhengjie.note5;

 import java.io.BufferedInputStream;
 import java.io.FileInputStream;
 import java.io.IOException;

 public class BufferedInputStreamDemo {
     public static void main(String[] args) throws IOException {
         //创建字节输入流，包装文件
         FileInputStream fis = new FileInputStream("yinzhengjie.txt");
         //创建字节输入流缓冲流对象，构造方法中包装字节输入流，包装文件
         BufferedInputStream bis = new BufferedInputStream(fis);
         //按照字节数组的方式进行读取操作，此处我并没有按照单个字节方式进行读取。
         byte[] buf = new byte[4096];
         int len;
         while(( len = bis.read(buf)) != -1 ) {
             System.out.println(new String(buf,0,len));
         }
         //释放资源,此处还是不用关闭fis流对象。
         bis.close();
     }
 }

 /*
 以上代码执行结果如下：
 ayinzhengjiezheng
 */

四.四种文件复制方式的效率比较

 /*
 @author :yinzhengjie
 Blog:http://www.cnblogs.com/yinzhengjie/tag/Java%E5%9F%BA%E7%A1%80/
 EMAIL:[e-mail]
 */

 package cn.org.yinzhengjie.note5;

 import java.io.BufferedInputStream;
 import java.io.BufferedOutputStream;
 import java.io.File;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;

 public class CopyFile {
     public static void main(String[] args) throws IOException {

         long start = System.currentTimeMillis();
 //        copy1(new File("yinzhengjie.sql"),new File("yinzhengjie.sql.backup"));
 //        copy2(new File("yinzhengjie.sql"),new File("yinzhengjie.sql.backup"));
 //        copy3(new File("yinzhengjie.sql"),new File("yinzhengjie.sql.backup"));      //
         copy4(new File("yinzhengjie.sql"),new File("yinzhengjie.sql.backup"));   ////拷贝的是600M的文件只需要862毫秒，效率是最高的！（固态硬盘）
         long stop = System.currentTimeMillis();
         System.out.println(stop-start);
     }

     //1>.字节流读写单个字符。
     public static void copy1(File src,File dest) throws IOException{
         FileInputStream fis = new FileInputStream(src);
         FileOutputStream fos = new FileOutputStream(dest);
         int len;
         while( (len = fis.read()) != -1) {
             fos.write(len);
         }
         fos.close();
         fis.close();
     }

     //2>.字节流读写字节数组
     public static void copy2(File src,File dest) throws IOException{
         FileInputStream fis = new FileInputStream(src);
         FileOutputStream fos = new FileOutputStream(dest);
         byte[] cache = new byte[1024];
         int len = 0;
         while( (len = fis.read(cache)) != -1) {
             fos.write(cache, 0, len);
         }
         fos.close();
         fis.close();
     }

     //字节流缓冲区读取单个字符
     public static void copy3(File src,File dest) throws IOException{
         BufferedInputStream bis = new BufferedInputStream(new FileInputStream(src));
         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(dest));

         int len = 0;
         while( (len = bis.read()) != -1 ) {
             bos.write(len);
         }
         bos.close();
         bis.close();
     }

     //字节流缓冲区读取字符数组
     public static void copy4(File src,File dest) throws IOException{
         BufferedInputStream bis = new BufferedInputStream(new FileInputStream(src));
         BufferedOutputStream bos = new BufferedOutputStream(new FileOutputStream(dest));
         byte[] cache = new byte[1024];
         int len;
         while((len = bis.read(cache)) != -1 ) {
             bos.write(cache, 0, len);
         }
     }

 }