黑马程序员技术交流社区

标题: 字节流与字节流缓冲区读写速度的疑问? [打印本页]
作者: Paul_Chang    时间: 2014-10-30 22:39
标题: 字节流与字节流缓冲区读写速度的疑问?
  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();

  14.                 System.out.println("运行时间="+(end - start)+"毫秒");
  15.         }
  16.        

  18.         //通过字节流缓冲区完成复制
  19.         public static void copyMethod_2()
  20.         {
  21.                 BufferedInputStream buis = null;
  22.                 BufferedOutputStream buos = null;

  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.         }

  63.         //通过字节流完成复制
  64.        
  65.         public static void copyMethod_1()
  66.         {
  67.                 FileInputStream fis = null;
  68.                 FileOutputStream fos = null;

  70.                 try
  71.                 {
  72.                         fis = new FileInputStream("再见理想.mp3");
  73.                         fos = new FileOutputStream("Beyond-再见理想.mp3");

  75.                         byte[] buf = new byte[1024];

  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(),想不明白,还是我的代码有问题?!
作者: Paul_Chang    时间: 2014-10-31 14:13
自己顶起来.....
作者: 姜浩    时间: 2014-10-31 14:36
copyMethod_2()方法中，你用的是java中自带的字节流缓冲区；
copyMethod_1()方法中，你也是用了缓冲区啊，只不过是你自己手动定义的。
给你说一个我自己想的例子：假如你去捡鸡蛋，捡一个就送家里一个，效率特别低，还能把你累死。
这样你就会手里拿一个篮子，一直捡到篮子满为止，再送回家，这样效率就高了很多。
这就是我想到的缓冲区的道理，可能不准确吧。
作者: Paul_Chang    时间: 2014-10-31 16:53
姜浩 发表于 2014-10-31 14:36
copyMethod_2()方法中，你用的是java中自带的字节流缓冲区；
copyMethod_1()方法中，你也是用了缓冲区啊， ...

可不可以理解为API定义好的缓冲区比较复杂,导致运行速度比自定义慢?
作者: 姜浩    时间: 2014-10-31 17:00
Paul_Chang 发表于 2014-10-31 16:53
可不可以理解为API定义好的缓冲区比较复杂,导致运行速度比自定义慢?

应该不是这个问题。毕竟那都是一代代大神们总结出来的。
可能和运行代码的时候，cpu的使用率有关系吧，也有可能是你复制的文件不够大，没能体现出来优势。
作者: Paul_Chang    时间: 2014-10-31 17:19
姜浩 发表于 2014-10-31 17:00
应该不是这个问题。毕竟那都是一代代大神们总结出来的。
可能和运行代码的时候，cpu的使用率有关系吧，也 ...

感谢解答啊,我把三种方法都写了,一会拿个大点的文件实验下...
作者: Paul_Chang    时间: 2014-10-31 18:00
本帖最后由 Paul_Chang 于 2014-10-31 18:07 编辑
姜浩 发表于 2014-10-31 17:00
应该不是这个问题。毕竟那都是一代代大神们总结出来的。
可能和运行代码的时候，cpu的使用率有关系吧，也 ...

进行了简单的DOE验证(结果如下),从有限样本看      1.感觉method_2()方法执行时间比较均衡,method_1()方法浮动比较大;
      2.当文件增大时,两种方法的时间差距在缩短;
      3.由于样本有限,无法得出更进一步结论.......

                                                            第一次                第二次               第三次
文件(1.56G):          method_1():         82490毫秒         79073毫秒        108272毫秒
Alien.mp4             method_2():        144688毫秒        148441毫秒      149806毫秒

文件(6.06M):          method_1():         1060毫秒              77毫秒              126毫秒
再见理想.mp3         method_2():         433毫秒              436毫秒             445毫秒


作者: 千里马    时间: 2014-10-31 18:10
这个问题像7楼那样理解，理论上是字节缓冲流的读写速度比字节流快，因为字节缓冲流是读取缓冲区的数据，缓冲区的数据是存在内存的，字节流的读取是直接对硬盘的操作，很明显内存的读写速度比硬盘的读写速度快；但具体情况还得分析文件的大小、cpu的占用率等问题。



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2