真的发现这两个拷贝方法差别好大，速度相差十几倍（末尾有截图~~），是我不理解BufferedInputStream和BufferedOutputStream的妙用吗？还是这个真的比BufferedInputStream和BufferedOutputStream好？如果是这样，要BufferedInputStream和BufferedOutputStream有何用？

1. /*
   
2.         对比利用装饰类拷贝，和直接利用byte数组拷贝。
   
3. */
   
4. import java.io.*;
   
5. class CopyDemo1
   
6. {
   
7.         public static void main(String[] args)
   
8.         {
   
9.                 long i = System.currentTimeMillis();
   
10.                 copy1();
    
11.                 long e = System.currentTimeMillis();
    
12.                 System.out.println("1++++++"+(e-i)+"毫秒");
    
13. 
    
14.                 long i1 = System.currentTimeMillis();
    
15.                 copy2();
    
16.                 long e1 = System.currentTimeMillis();
    
17.                 System.out.println("2++++++"+(e1-i1)+"毫秒");
    
18.         }
    
19.         //方法一，利用自定义的字符串做缓冲区，实现复制
    
20.         public static void copy1()
    
21.         {
    
22.                 FileInputStream fis = null;
    
23.                 FileOutputStream fos = null;
    
24.                 int cpymax = 1024*4;
    
25.                 byte[] byt = new byte[cpymax];
    
26.                 try
    
27.                 {
    
28.                         fis =new FileInputStream("浮夸原1.mp3");
    
29.                         fos =new FileOutputStream("浮夸1.mp3");
    
30.                         while(fis.read(byt)!=-1)
    
31.                         {
    
32.                                 fos.write(byt);
    
33.                         }
    
34.                 }
    
35.                 catch (IOException ioe){}
    
36.                 finally
    
37.                 {
    
38.                         try
    
39.                         {
    
40.                                 if (fis != null)
    
41.                                                 fis.close();
    
42.                         }
    
43.                         catch (IOException ioe){}                        
    
44.                         try
    
45.                         {
    
46.                                 if (fos != null)
    
47.                                                 fos.close();
    
48.                         }
    
49.                         catch (IOException ioe){}                        
    
50.                 }
    
51.                
    
52.         }
    
53.         //方法二：利用系统自定义的BufferedInputStream装饰类拷贝。
    
54.         public static void copy2()
    
55.         {
    
56.                 FileInputStream fis = null;
    
57.                 FileOutputStream fos = null;
    
58.                 BufferedInputStream bufis = null;
    
59.                 BufferedOutputStream bufos = null;
    
60.                 try
    
61.                 {
    
62.                         fis =new FileInputStream("浮夸原2.mp3");
    
63.                         fos =new FileOutputStream("浮夸2.mp3");
    
64.                         bufis = new BufferedInputStream(fis);
    
65.                         bufos =new BufferedOutputStream(fos);
    
66.                         int num;
    
67.                         while((num=bufis.read()) != -1)
    
68.                         {
    
69.                                 bufos.write(num);
    
70.                         }
    
71.                 }
    
72.                 catch (IOException ioe){}
    
73.                 finally
    
74.                 {
    
75.                         try
    
76.                         {
    
77.                                 if (bufis != null)
    
78.                                                 bufis.close();
    
79.                         }
    
80.                         catch (IOException ioe){}
    
81.                         try
    
82.                         {
    
83.                                 if (fos != null)
    
84.                                                 bufos.close();
    
85.                         }
    
86.                         catch (IOException ioe){}
    
87.                 }
    
88.         }
    
89. }
    
90. /*
    
91. //毕老师自定义的BufferedInputStream类，所用的时间跟系统自定义的一样。
    
92. class MyBufferedInputStream
    
93. {
    
94.         private InputStream in;
    
95. 
    
96.         private byte[] buf = new byte[1024*4];
    
97.                
    
98.         private int pos = 0,count = 0;
    
99.         
    
100.         MyBufferedInputStream(InputStream in)
     
101.         {
     
102.                 this.in = in;
     
103.         }
     
104. 
     
105.         //一次读一个字节，从缓冲区(字节数组)获取。
     
106.         public int myRead()throws IOException
     
107.         {
     
108.                 //通过in对象读取硬盘上数据，并存储buf中。
     
109.                 if(count==0)
     
110.                 {
     
111.                         count = in.read(buf);
     
112.                         if(count<0)
     
113.                                 return -1;
     
114.                         pos = 0;
     
115.                         byte b = buf[pos];
     
116. 
     
117.                         count--;
     
118.                         pos++;
     
119.                         return b&255;
     
120.                 }
     
121.                 else if(count>0)
     
122.                 {
     
123.                         byte b = buf[pos];
     
124. 
     
125.                         count--;
     
126.                         pos++;
     
127.                         return b&0xff;
     
128.                 }
     
129.                 return -1;
     
130. 
     
131.         }
     
132.         public void myClose()throws IOException
     
133.         {
     
134.                 in.close();
     
135.         }
     
136. }
     
137. */

复制代码

使用一个byte数组来作为数据读入的缓冲区，以文件存取为例，硬盘存取的速度远低于内存中的数据存取速度。为了减少对硬盘的存取，通常从文件中一次读入一定长度的数据，而写入时也是一次写入一定长度的数据，这可以增加文件存取的效率。java.io.BufferedInputStream与java.io.BufferedOutputStream可以为InputStream、OutputStream类的对象增加缓冲区功能。构建BufferedInputStream实例时，需要给定一个InputStream类型的实例，实现BufferedInputStream时，实际上最后是实现InputStream实例。同样地，在构建BufferedOutputStream时，也需要给定一个OutputStream实例，实现BufferedOutputStream时，实际上最后是实现OutputStream实例。BufferedInputStream的数据成员buf是一个位数组，默认为2048字节。当读取数据来源时，例如文件，BufferedInputStream会尽量将buf填满。当使用read()方法时，实际上是先读取buf中的数据，而不是直接对数据来源作读取。当buf中的数据不足时，BufferedInputStream才会再实现给定的InputStream对象的read()方法，从指定的装置中提取数据。
BufferedInputStream和BufferedOutputStream并没有改变InputStream或 OutputStream的行为，读入或写出时的动作还是InputStream和OutputStream负责。BufferedInputStream和BufferedOutputStream只是在操作对应的方法之前，动态地为它们加上一些额外功能(像缓冲区功能)。

while(fis.read(byt)!=-1)

                        {

                                fos.write(byt);

                        }



int num;

                        while((num=bufis.read()) != -1)

                        {

                                bufos.write(num);

                        }

两次写得是不是不一样啊？

黑马—陈磊 发表于 2012-6-1 15:15
使用一个byte数组来作为数据读入的缓冲区，以文件存取为例，硬盘存取的速度远低于内存中的数据存取速度。为 ...

大哥，我问的不是BufferInputStream等的原理，我问的是为什么用BufferedInputStream反而比用数组直接转存的效率会低那么多啊！！其实BufferedStream的底层原理是先取一段，然后再一个一个的存，那我这个是取一段，然后一段整存，这跟BufferedReader读行的原理一样，可是就是想不明白，为什么BufferedInputStream为什么要这样设计而已，效率差死~~~~~~

我来给你说 ：终于查到了

你去看看java api源码 里面的实现，大体说一下：
FileInputStram里面实现了InputStream的read（）；这个read（）定义为native的 ，具体与操作系统硬盘的复制api有关，实现一次硬盘io读一个字节。（这个java管不了），另外重写了read(byte[] b, int off, int len)方法，而这个重写的方法里面调用的是FileInputStream独有的 private native int readBytes(byte b[], int off, int len) 方法，这个方法也是本地的方法。与硬盘io的直接操作有关，应该用c写的，这个和那个read（）有根本的区别，就是一次io读b个字节！BufferedInputStream里面继承了FilterInputStream里面的InputStream成员in，就在你构造这个BufferedInputStream对象的时候FileInputStram传进去了，BufferedInputStream的read（）调用的自己的fill（），而fill（）调用的FilterInputStream的read(byte b[], int off, int len)，继而调用传进去的FileInputStram的read(byte b[], int off, int len)，也就调用了native int readBytes(byte b[], int off, int len) 方法。 从而实现了缓存。
你也可以看看BufferedInputStream里面的read(byte b[], int off, int len)，方法，都是调用的一样的native方法，具体二者为什么会有时差，和缓存大小有关！就是和readByte里传的b的大小有关！仅此而已。什么方法怎么写都会回归到最原始和windows操作系统打交道的微软上，这个c++，我放弃的真不对。

上图是我运行的 利用修改的代码：

1. try
   
2. {
   
3. fis =new FileInputStream("浮夸原2.mp3");
   
4. fos =new FileOutputStream("浮夸2.mp3");
   
5. bufis = new BufferedInputStream(fis);
   
6. bufos =new BufferedOutputStream(fos);
   
7. int num;
   
8. int cpymax = 1024*4;
   
9. byte[] byt = new byte[cpymax];
   
10. while((num=bufis.read(byt)) != -1)
    
11. {
    
12. bufos.write(byt,0,num);
    
13. }
    
14. }
    
15. catch (IOException ioe){}

复制代码

我们老师也经常用自定义数组的形式,关键是这两句
while(fis.read(byt)!=-1)                        读一个存一个,后来直接把byt一起写出,所以块
         fos.write(byt);
while((num=bufis.read()) != -1)            读一个存一个,后来再一个一个写,所以慢(效率并不太高),楼上是又将这个自带缓冲区的输出流加了个 自定义数组,
         bufos.write(num);
使用BufferedReader的读行功能,能快很多,你试试