1. import java.io.*;
   
2. //用不同方法复制一个8m大小的MP3文件并统计运行时间
   
3. public class Test {
   
4.         public static void main(String[] args) throws IOException{
   
5.                  long startTime = System.currentTimeMillis();
   
6.          copyFile_1();
   
7.          long endTime = System.currentTimeMillis();
   
8.          System.out.println(endTime-startTime+"ms");
   
9.          
   
10.          startTime = System.currentTimeMillis();
    
11.          copyFile_2();
    
12.          endTime = System.currentTimeMillis();
    
13.          System.out.println(endTime-startTime+"ms");
    
14.          
    
15.          startTime = System.currentTimeMillis();
    
16.          copyFile_3();
    
17.          endTime = System.currentTimeMillis();
    
18.          System.out.println(endTime-startTime+"ms");
    
19.          
    
20.          startTime = System.currentTimeMillis();
    
21.          copyFile_4();
    
22.          endTime = System.currentTimeMillis();
    
23.          System.out.println(endTime-startTime+"ms");
    
24. }
    
25. 
    
26. //基本读取方式
    
27. public static void copyFile_1() throws IOException {
    
28.          //创建IO流对象
    
29.          FileInputStream fis = new FileInputStream("D:\\An end,once and for all.mp3");
    
30.          FileOutputStream fos = new FileOutputStream("D:\\An end,once and for all1.mp3");
    
31.          
    
32.          int data = 0;
    
33.          //循环读取
    
34.          while ((data=fis.read())!=-1) {
    
35.                  fos.write(data);
    
36.          }
    
37.                  fis.close();
    
38.                  fos.close();               
    
39. }
    
40. 
    
41. //在基本读取的方式上定义字节数组作为缓存
    
42. public static void copyFile_2() throws IOException {
    
43. 
    
44.          FileInputStream fis = new FileInputStream("D:\\An end,once and for all.mp3");
    
45.          FileOutputStream fos = new FileOutputStream("D:\\An end,once and for all2.mp3");
    
46.          
    
47.          byte[] buf = new byte[1024];
    
48.          int len = 0;
    
49.          while ((len=fis.read(buf))!=-1) {
    
50.                  fos.write(buf,0,len);
    
51.          }
    
52.                  fis.close();
    
53.                  fos.close();                        
    
54. }
    
55. 
    
56. //通过装饰类来读写文件
    
57. public static void copyFile_3() throws IOException {
    
58.          BufferedInputStream fis = new BufferedInputStream(new FileInputStream("D:\\An end,once and for all.mp3"));
    
59.          BufferedOutputStream fos = new BufferedOutputStream(new FileOutputStream("D:\\An end,once and for all3.mp3"));
    
60.          
    
61.          int data = 0;
    
62.          while ((data=fis.read())!= -1) {
    
63.                  fos.write(data);
    
64.          }
    
65.                  fis.close();
    
66.                  fos.close();               
    
67. }
    
68. 
    
69. //在使用装饰类也同时使用字节数组缓存
    
70. public static void copyFile_4() throws IOException {
    
71.       
    
72.          BufferedInputStream fis = new BufferedInputStream(new FileInputStream("D:\\An end,once and for all.mp3"));
    
73.          BufferedOutputStream fos = new BufferedOutputStream(new FileOutputStream("D:\\An end,once and for all4.mp3"));
    
74.          
    
75.          int data = 0;
    
76.          byte[] buf = new byte[1024];
    
77.          while ((data=fis.read(buf))!= -1) {
    
78.                  fos.write(buf,0,data);                                    
    
79.          }
    
80.                  fis.close();
    
81.                  fos.close();               
    
82. }   
    
83. }

复制代码

运行结果：
62894ms
94ms
109ms
23ms
虽说是有缓存数组，为何第四种方式比其他都快这么多呢？第一种方式为什么会比其他三种方式慢这么多？不解，请指教，先谢谢了

就像毕老师觉得喝水的例子，是找个杯子接满一起喝，还是一滴滴等着喝快？？
第一种方式是读一个字符就写一次，第二种独到的放进数组，再一次性的写！第三、第四一样只不过加入了缓冲技术。
2、4比1、3少了很多往出写的次数，这就少了很多的时间。毕竟切换一次也是要花时间的。4和2比较就是加入了缓冲技术，所以减少时间很多的！