黑马程序员技术交流社区

标题: BufferedInputStream和BufferedOutputStream怎么用 [打印本页]
作者: 黑马刘杰    时间: 2013-1-20 21:55
标题: BufferedInputStream和BufferedOutputStream怎么用
本帖最后由 黑马刘杰 于 2013-1-21 11:09 编辑

  2. public static void copyPic(){
  3.   FileInputStream fis=null;
  4.   FileOutputStream fos=null;
  5.   try {
  6.    fis=new FileInputStream("fis.bmp");
  7.    fos=new FileOutputStream("fos.bmp");
  8.    byte[] buf=new byte[1024];
  9.    int len=0;
  10.    while((len=fis.read(buf))!=-1){
  11.     fos.write(buf,0,len);
  12.     fos.flush();//不可以忘记！！！
  13.    }
  14.   } catch (IOException e) {
  15.    e.printStackTrace();
  16.   }finally{
  17.    if(fos!=null){
  18.     try {
  19.      fos.close();
  20.     } catch (IOException e) {
  21.      e.printStackTrace();
  22.     }
  23.    }
  24.    if(fis!=null){
  25.     try {
  26.      fis.close();
  27.     } catch (IOException e) {
  28.      e.printStackTrace();
  29.     }
  30.    }
  31.   }
  32. }

  34. 上面是一个用FileInputStream,和FileOutputStream实现复制图片的方法，如果用BufferedInputStream，BufferedOutputStream该怎么实现呢？

复制代码
作者: 黑马伍哲沂    时间: 2013-1-20 23:01
  1. import java.io.*;
  2. class TestCopyPictrue
  3. {
  4.         public static void main(String[] args)  throws IOException
  5.         {
  6.                 copyPic();
  7.         }
  8.         public static void copyPic() throws IOException
  9.         {
  10.                 BufferedInputStream bufis = new BufferedInputStream(new FileInputStream("fis.JPG"));
  11.                 BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("copy_fis.JPG"));
  12.                 int by = 0;
  13.                 while ((by=bufis.read())!=-1)
  14.                 {
  15.                         bufos.write(by);
  16.                 }
  17.                 bufis.close();
  18.                 bufos.close();
  19.         }
  20. }
复制代码
BufferedInputStream和BufferedOutputStream属于装饰类，是为提高操作效率设计的。查看其构造函数，
把fis=new FileInputStream("fis.bmp");和fos=new FileOutputStream("fos.bmp");
作为BufferedInputStream和BufferedOutputStream的参数构造就好了。但要记得关闭资源，bufis.close();
bufos.close();如上代码经过运行通过（异常都抛了）。其实操作的和FileStream一致。

作者: 肖志锋    时间: 2013-1-20 23:05
其实是一样的，这是装饰设计模式，也就是在FileInputStream,和FileOutputStream外面加了一些装饰，内部其实还是他们实现的。
看看API你就会找到BufferedInputStream，BufferedOutputStream他们的构造函数 ，比如说：BufferedOutputStream(OutputStream out)
他构造函数的参数需要传一个输出字节流的对象，那么你传一个他的子类FileOutputStream的对象即可。
其他的使用是完全没有变化的。
至于说原理，前面已经说了，其实就是一个包装而已，至于说缓存，其实就跟你上面代码里面使用数组缓存一个道理，sun公司的工程师也想到了这个方式，添加了一些缓存。
如果你想深一步的了解，可以去看看原码。
作者: vmvm555    时间: 2013-1-20 23:08
  1. import java.io.*;

  3. public class CopyPicture {
  4.        
  5.         public static void main(String[] args) {
  6.                 copyPic();
  7.         }
  8.        
  9.         public static void copyPic() {
  10.                 FileInputStream fis = null;
  11.                 FileOutputStream fos = null;
  12.                 try {
  13.                         fis = new FileInputStream("psb.jpg");
  14.                         BufferedInputStream bi = new BufferedInputStream(fis);
  15.                         fos = new FileOutputStream("psb1.jpg");
  16.                         BufferedOutputStream bo = new BufferedOutputStream(fos);
  17.                         byte[] b = new byte[1024];
  18.                         int leng;
  19.                         while((leng = bi.read(b, 0, b.length)) != -1) {
  20.                                 bo.write(b, 0, leng);
  21.                                 bo.flush();
  22.                         }
  23. /*                        byte[] buf = new byte[1024];
  24.                         int len = 0;
  25.                         while ((len = fis.read(buf)) != -1) {
  26.                                 fos.write(buf, 0, len);
  27.                                 fos.flush();// 不可以忘记！！！
  28.                         }*/
  29.                 } catch (IOException e) {
  30.                         e.printStackTrace();
  31.                 } finally {
  32.                         if (fos != null) {
  33.                                 try {
  34.                                         fos.close();
  35.                                 } catch (IOException e) {
  36.                                         e.printStackTrace();
  37.                                 }
  38.                         }
  39.                         if (fis != null) {
  40.                                 try {
  41.                                         fis.close();
  42.                                 } catch (IOException e) {
  43.                                         e.printStackTrace();
  44.                                 }
  45.                         }
  46.                 }
  47.         }
  48. }
复制代码
在此我认为我有必要说明一下 FileInputStream 和 BufferedInputStream中的read方法的区别
FileInputStream 是从硬盘上一个字节，一个字节的读取，速度相当的慢，但是如果在外面套一层BufferedInputStream，因为BufferedInputStream内部有一个缓冲区，首先
读取一次数据，将缓冲区填满，之后直接从缓冲区中读取数据，这样cpu访问硬盘的次数下降了好多，效率就提高了许多倍FileOutputStream和BufferedOutputStream是同样的道理
作者: 黄锦成    时间: 2013-1-21 00:06
vmvm555 发表于 2013-1-20 23:08
在此我认为我有必要说明一下 FileInputStream 和 BufferedInputStream中的read方法的区别
FileInputStream  ...

  while((leng = bi.read(b, 0, b.length)) != -1)  写成   while((leng = bi.read(b) != -1)就行了



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2