1. 
   
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. }
    
33. 
    
34. 上面是一个用FileInputStream,和FileOutputStream实现复制图片的方法，如果用BufferedInputStream，BufferedOutputStream该怎么实现呢？
    
35. 
    

复制代码

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)就行了

1. import java.io.*;
   
2. 
   
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是同样的道理

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

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一致。