1. //复制一文件，比较两个复制快慢
   
2. import java.io.*;
   
3. class  CopyPic
   
4. {
   
5.         public static void main(String[] args)
   
6.         {
   
7.                 FileOutputStream fos = null;
   
8.                 FileInputStream fis = null;
   
9.                 try
   
10.                 {
    
11.                         long start = System.currentTimeMillis();
    
12.                         //方法一
    
13.                         /*fis = new FileInputStream("d:\\1.rar");
    
14.                         fos = new FileOutputStream("d:\\2.rar");
    
15.                         byte [] buf = new byte[1024];
    
16.                         int len = 0;
    
17.                         while ((len = fis.read(buf))!=-1)
    
18.                         {
    
19.                                 fos.write(buf,0,len);
    
20.                         }
    
21.                         */
    
22.                         //方法二
    
23.                         fis = new FileInputStream("d:\\1.rar");
    
24.                         fos = new FileOutputStream("d:\\2.rar");
    
25.                         int num = fis.available();
    
26.                         byte [] buf = new byte[num];
    
27.                         fis.read(buf);
    
28.                         fos.write(buf,0,num);
    
29.                         
    
30.                         long end = System.currentTimeMillis();
    
31.                         System.out.println("复制时间："+(end-start));
    
32.                 }
    
33.                 catch (IOException e)
    
34.                 {
    
35.                         throw new RuntimeException("复制文件失败");
    
36.                 }
    
37.                 finally
    
38.                 {
    
39.                         try
    
40.                         {
    
41.                                 if(fos!=null)
    
42.                                         fos.close();
    
43.                         }
    
44.                         catch (IOException e)
    
45.                         {
    
46.                                 throw new RuntimeException("读取文件关闭失败");
    
47.                         }
    
48.                         try
    
49.                         {
    
50.                                 if(fis!=null)
    
51.                                         fis.close();
    
52.                         }
    
53.                         catch (IOException e)
    
54.                         {
    
55.                                 throw new RuntimeException("复制文件关闭失败");
    
56.                         }
    
57.                 }
    
58.         }
    
59. }
    

复制代码

两个方法不一样，但都是使用数组，只是数组大小不一样，能解释下具体原因吗
而且把方法一种数组调大成1024*1024结果就是第三副图那样，变快了，如果在大点变成1024*1024*30，结果复制的时间又会变长如果是通过缓冲区复制，花费的时间更长
why
..................

学习下~~

图片对应有点不明白
byte[1024]是572ms，byte[fis.available()]是1224ms，byte[1024*1024]是213ms，byte[1024*1024*30]是5535ms吗~？
你复制的文件是多大的~？

longlangcx 发表于 2013-7-26 13:38
学习下~~

图片对应有点不明白

对  是这样的
文件大小为10m

longlangcx 发表于 2013-7-26 13:38
学习下~~

图片对应有点不明白

5535是使用缓冲区

1. long start = System.currentTimeMillis();
   
2.                         BufferedInputStream bufis = new BufferedInputStream(new FileInputStream("d:\\1.rar"));
   
3.                         BufferedOutputStream bufos = new BufferedOutputStream(new FileOutputStream("d:\\2.rar"));
   
4.                         int by =0;
   
5.                         while ((by=bufis.read())!=-1)
   
6.                         {
   
7.                                 bufos.write(by);
   
8.                         }

复制代码

俺我的理解是跟数组的特性有关，数组适合做查找，不适合增删要牵扯到元素的移动有点费时，刚好你的文件超过了byte[]定义的大小，需要时间来不断重复填充。或者你找个在你定义的数组大小之间文件进行下拷贝试下这个观点是否准确 ？       我没实验，只是按照数组的特性来理解，也不知道解释合理?