1. /*
   
2. 演示MP3的复制
   
3. */
   
4. import java.io.*;
   
5. class CopyMp3
   
6. {
   
7.         public static void main(String[] args)
   
8.         {
   
9.                 long start = System.currentTimeMillis();
   
10.                 copyMethod_1();
    
11.                 //copyMethod_2();
    
12.                 long end = System.currentTimeMillis();
    
13. 
    
14.                 System.out.println("运行时间="+(end - start)+"毫秒");
    
15.         }
    
16.         
    
17. 
    
18.         //通过字节流缓冲区完成复制
    
19.         public static void copyMethod_2()
    
20.         {
    
21.                 BufferedInputStream buis = null;
    
22.                 BufferedOutputStream buos = null;
    
23. 
    
24.                 try
    
25.                 {
    
26.                         buis = new BufferedInputStream(new FileInputStream("再见理想.mp3"));
    
27.                         buos = new BufferedOutputStream(new FileOutputStream("再见理想-beyond2.mp3"));
    
28.                         
    
29.                         int by = 0;
    
30.                         while ((by = buis.read())!=-1)
    
31.                         {
    
32.                                 buos.write(by);
    
33.                         }
    
34.                         
    
35.                 }
    
36.                 catch (IOException e )
    
37.                 {
    
38.                         throw new RuntimeException("复制文件失败");
    
39.                 }
    
40.                 finally
    
41.                 {
    
42.                         try
    
43.                         {
    
44.                                 if (buis!=null)
    
45.                                         buis.close();
    
46.                         }
    
47.                         catch (IOException e)
    
48.                         {
    
49.                                 throw new RuntimeException("读取关闭失败");
    
50.                         }
    
51.                         try
    
52.                         {
    
53.                                 if (buos!=null)
    
54.                                         buos.close();
    
55.                         }
    
56.                         catch (IOException e)
    
57.                         {
    
58.                                 throw new RuntimeException("写入关闭失败");
    
59.                         }
    
60.                 }
    
61.         }
    
62. 
    
63.         //通过字节流完成复制
    
64.         
    
65.         public static void copyMethod_1()
    
66.         {
    
67.                 FileInputStream fis = null;
    
68.                 FileOutputStream fos = null;
    
69. 
    
70.                 try
    
71.                 {
    
72.                         fis = new FileInputStream("再见理想.mp3");
    
73.                         fos = new FileOutputStream("Beyond-再见理想.mp3");
    
74. 
    
75.                         byte[] buf = new byte[1024];
    
76. 
    
77.                         int len = 0;
    
78.                         while ((len = fis.read(buf))!=-1)
    
79.                         {
    
80.                                 fos.write(buf,0,len);
    
81.                         }
    
82.                 }
    
83.                 catch (IOException e)
    
84.                 {
    
85.                         throw new RuntimeException("复制文件失败");
    
86.                 }
    
87.                 finally
    
88.                 {
    
89.                         try
    
90.                         {
    
91.                                 if (fis!=null)
    
92.                                         fis.close();
    
93.                         }
    
94.                         catch (IOException e)
    
95.                         {
    
96.                                 throw new RuntimeException("读取关闭失败");
    
97.                         }
    
98.                         try
    
99.                         {
    
100.                                 if (fos!=null)
     
101.                                         fos.close();
     
102.                         }
     
103.                         catch (IOException e)
     
104.                         {
     
105.                                 throw new RuntimeException("写入关闭失败");
     
106.                         }
     
107.                 }
     
108.         }
     
109. }
     

复制代码

按理说使用字节流缓冲区应该比字节流直接复制要快啊,可是我的运行结果却是copyMethod_1()的运行时间短于copyMethod_2(),想不明白,还是我的代码有问题?!哪位大神给讲解下...

这里的提高效率是不是指的节省资源避免CPU的过多占用，用极少的资源完成任务，用其余的资源去做其他任务，而不是指的提高效率就是节省时间，我也不太懂，希望能给出一个答案，学习学习

读写的文件够大，差别就显现出来了

楼主，你的这两个方法没有什么可比较的了，第一个虽然是字节流缓冲，但是你每次是不是读出来的是1个字符，写的时候也是一个字符一个字符放进输出流缓冲区的？，你在看看你的下面的方法，你一次读出的是1K，写的时候也是1k一起写。硬盘的读写都是相对内存很慢的，可以想想一个字节一个字节的读写，和1k的读写，当然是后者快啦

路过看看！！！！！！！

你好楼主一下分析希望对你有帮助：
字节流 直接往硬盘上写，就是读取一个字节往硬盘上写一个。
字节缓冲流，先把一部分数据读到缓冲区，缓冲区里面存放了一定量的的数据，再将缓冲区里数据批量的往硬盘上写；

那么当你的要写的文件很小的时候，电脑处理速度很快，虽说在多个线程之间来回切换执行，但是由于文件小，
这时候你用字节流也能很快的处理，你用缓冲流因为多了把数据放到缓冲区这个步骤，所以它的运行时间要比字节流长。

楼主你可以用一个大的文件试试；
比如说这个文件有1G，计算机来回在多个线程之间切换执行，当切换到你这个线程，你只读取了几个字节写入了几个字节
又切换到别的线程上，和你用缓冲，当计算机切换到该线程上，往硬盘上写入批量的数据。这样比较起来 速度是相差很大的，
也就是楼上一位哥们让你用大文件试试的原因。

Jeik 发表于 2014-11-3 21:37
你好楼主一下分析希望对你有帮助：
字节流 直接往硬盘上写，就是读取一个字节往硬盘上写一个。
字节缓冲流 ...

大文件有试过,结果放在另一个帖子了,结论就是随着文件的增大,两者的执行时间越来越接近,但是由于样本有限,还没进一步结论.....不过我比较认同:效率不仅仅单纯代表执行速度快,还代表其他资源的优化...

newLife 发表于 2014-10-31 10:24
这里的提高效率是不是指的节省资源避免CPU的过多占用，用极少的资源完成任务，用其余的资源去做其他任务， ...

比较认同你的说法...貌似没人关注这些.分送你了,哈哈哈哈

Paul_Chang 发表于 2014-11-3 22:07
比较认同你的说法...貌似没人关注这些.分送你了,哈哈哈哈

谢谢哈，:handshake