1. import java.io.*;
   
2. class  CopyMp3
   
3. {
   
4.         public static void main(String[] args) throws IOException
   
5.         {
   
6.                 long start = System.currentTimeMillis();
   
7.                 copy_2();
   
8.                 long end = System.currentTimeMillis();
   
9.                 System.out.println("copy2消耗时间"+(end-start)+"毫秒");
   
10.         }
    
11.         
    
12.         public static void copy_3()throws IOException
    
13.         {
    
14.                 FileInputStream bufis = new FileInputStream("d:\\in.mp3");
    
15.                 BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("d:\\out3.mp3"));
    
16.                
    
17.                 int num  = 0;
    
18.                 byte[] buf = new byte[1024*4];
    
19.                 //System.out.println("第一个字节:"+bufis.myRead());
    
20. 
    
21.                 while((num=bufis.read(buf))!=-1)
    
22.                 {
    
23.                         for(byte i:buf)
    
24.                                 bufos.write(i);
    
25.                         //for(int i=0;i<num;i++)
    
26.                                 //bufos.write(buf[i]);
    
27.                 }
    
28. 
    
29.                 bufos.close();
    
30.                 bufis.close();
    
31.         }
    
32. 
    
33.         public static void copy_2()throws IOException
    
34.         {
    
35.                 MyBufferedInputStream bufis = new MyBufferedInputStream(new FileInputStream("d:\\in.mp3"));
    
36.                 BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("d:\\out2.mp3"));
    
37.                
    
38.                 int by = 0;
    
39. 
    
40.                 //System.out.println("第一个字节:"+bufis.myRead());
    
41. 
    
42.                 while((by=bufis.myRead())!=-1)
    
43.                 {
    
44.                         bufos.write(by);
    
45.                 }
    
46. 
    
47.                 bufos.close();
    
48.                 bufis.myClose();
    
49.         }
    
50. 
    
51.         //通过字节流的缓冲区完成复制。
    
52.         public static void copy_1()throws IOException
    
53.         {
    
54.                 BufferedInputStream bufis = new BufferedInputStream(new FileInputStream("d:\\in.mp3"));
    
55.                 BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("d:\\out1.mp3"));
    
56.                
    
57.                 int by = 0;
    
58. 
    
59.                 while((by=bufis.read())!=-1)
    
60.                 {
    
61.                         bufos.write(by);
    
62.                 }
    
63. 
    
64.                 bufos.close();
    
65.                 bufis.close();
    
66. 
    
67.                
    
68.         }
    
69. }

复制代码

昨天看到IO部分，就想我不使用缓冲区，直接写出去能怎么样，然后就自己加上了函数copy_3,然后测试了一下copy_2与copy_3的耗时，明显平均速度还是毕老师使用缓冲区技术快了几毫秒。
不明白具体快在了哪里。。。

你问我天有多高,我只能告诉你很高很高...

下面是MyBufferedInputStream类的代码：

1. class MyBufferedInputStream
   
2. {
   
3.         private InputStream in;
   
4. 
   
5.         private byte[] buf = new byte[1024*4];
   
6.                
   
7.         private int pos = 0,count = 0;
   
8.         
   
9.         MyBufferedInputStream(InputStream in)
   
10.         {
    
11.                 this.in = in;
    
12.         }
    
13. 
    
14.         //一次读一个字节，从缓冲区(字节数组)获取。
    
15.         public int myRead()throws IOException
    
16.         {
    
17.                 //通过in对象读取硬盘上数据，并存储buf中。
    
18.                 if(count==0)
    
19.                 {
    
20.                         count = in.read(buf);
    
21.                         if(count<0)
    
22.                                 return -1;
    
23.                         pos = 0;
    
24.                 }
    
25.                 if(count>=0)
    
26.                 {
    
27.                         byte b = buf[pos];
    
28. 
    
29.                         count--;
    
30.                         pos++;
    
31.                         return b&0xff;
    
32.                 }
    
33.                 return -1;
    
34. 
    
35.         }
    
36.         public void myClose()throws IOException
    
37.         {
    
38.                 in.close();
    
39.         }
    
40. }

复制代码

你要明白I/O的输出对系统来说其实是一个中断操作，那使用缓冲技术就是减少了高频率的中断，那么时间和性能上肯定是会提高的。

不明白，

事实证明自定义一个数组比加缓冲区快得多

{:2_32:} 说一个简单的，水缸里有水，需要你把水全倒出来，你可以使用勺子，也可以使用水桶，你说哪个快{:2_43:}

缓冲区技术不是就是在内部封装了一个数组吗

记得有一道题就是：怎么高效复制文件！却是使用字符数组最快！