java文件拷贝

使用 java 进行文件拷贝 

第一种方法:古老的方式

1. public static long forJava(File f1,File f2) throws Exception{   
2. int length=2097152;   
3.   FileInputStream in=new FileInputStream(f1);   
4.    FileOutputStream out=new FileOutputStream(f2);   
5.    byte[] buffer=newbyte[length];   
6.   while(true){   
7.     int ins=in.read(buffer);   
8.     if(ins==-1){   
9.      in.close();   
10.      out.flush();   
11.      out.close();   
12.      return new Date().getTime()-time;   
13.     }else  
14.      out.write(buffer,0,ins);   
15.    }   
16. }  

  

方法的2参数分别是原始文件,和拷贝的目的文件.这里不做过多介绍.

实现方法很简单,分别对2个文件构建输入输出流,并且使用一个字节数组作为我们内存的缓存器, 然后使用流从f1 中读出数据到缓存里,在将缓存数据写到f2里面去.这里的缓存是2MB的字节数组

第2种方法:使用NIO中的管道到管道传输

1. publicstaticlong forTransfer(File f1,File f2) throws Exception{   
2.         long time=new Date().getTime();   
3.         int length=2097152;   
4.          FileInputStream in=new FileInputStream(f1);   
5.          FileOutputStream out=new FileOutputStream(f2);   
6.          FileChannel inC=in.getChannel();   
7.          FileChannel outC=out.getChannel();   
8.         int i=0;   
9.         while(true){   
10.             if(inC.position()==inC.size()){   
11.                  inC.close();   
12.                  outC.close();   
13.                 returnnew Date().getTime()-time;   
14.              }   
15.             if((inC.size()-inC.position())<20971520)   
16.                  length=(int)(inC.size()-inC.position());   
17.             else  
18.                  length=20971520;   
19.              inC.transferTo(inC.position(),length,outC);   
20.              inC.position(inC.position()+length);   
21.              i++;   
22.          }   
23.      }  

    

实现方法:在第一种实现方法基础上对输入输出流获得其管道,然后分批次的从f1的管道中像f2的管道中输入数据每次输入的数据最大为2MB

方法3:内存文件景象写(读文件没有使用文件景象,有兴趣的可以回去试试,,我就不试了,估计会更快)

1. publicstaticlong forImage(File f1,File f2) throws Exception{   
2.         long time=new Date().getTime();   
3.         int length=2097152;   
4.          FileInputStream in=new FileInputStream(f1);   
5.          RandomAccessFile out=new RandomAccessFile(f2,"rw");   
6.          FileChannel inC=in.getChannel();   
7.          MappedByteBuffer outC=null;   
8.          MappedByteBuffer inbuffer=null;   
9.         byte[] b=newbyte[length];   
10.         while(true){   
11.             if(inC.position()==inC.size()){   
12.                  inC.close();   
13.                  outC.force();   
14.                  out.close();   
15.                 returnnew Date().getTime()-time;   
16.              }   
17.             if((inC.size()-inC.position())<length){   
18.                  length=(int)(inC.size()-inC.position());   
19.              }else{   
20.                  length=20971520;   
21.              }   
22.              b=newbyte[length];   
23.              inbuffer=inC.map(MapMode.READ_ONLY,inC.position(),length);   
24.              inbuffer.load();   
25.              inbuffer.get(b);   
26.              outC=out.getChannel().map(MapMode.READ_WRITE,inC.position(),length);   
27.              inC.position(b.length+inC.position());   
28.              outC.put(b);   
29.              outC.force();   
30.          }   
31.      }  

    

实现方法:跟伤2个例子不一样,这里写文件流没有使用管道而是使用内存文件映射(假设文件f2在内存中).在循环中从f1的管道中读取数据到字节数组里,然后在像内存映射的f2文件中写数据.

第4种方法:管道对管道

   public static long forChannel(File f1,File f2) throws Exception{   

1.         long time=new Date().getTime();   
2.         int length=2097152;   
3.          FileInputStream in=new FileInputStream(f1);   
4.          FileOutputStream out=new FileOutputStream(f2);   
5.          FileChannel inC=in.getChannel();   
6.          FileChannel outC=out.getChannel();   
7.          ByteBuffer b=null;   
8.         while(true){   
9.             if(inC.position()==inC.size()){   
10.                  inC.close();   
11.                  outC.close();   
12.                 returnnew Date().getTime()-time;   
13.              }   
14.             if((inC.size()-inC.position())<length){   
15.                  length=(int)(inC.size()-inC.position());   
16.              }else  
17.                  length=2097152;   
18.              b=ByteBuffer.allocateDirect(length);   
19.              inC.read(b);   
20.              b.flip();   
21.              outC.write(b);   
22.              outC.force(false);   
23.          }   
24.      }  

解释: 在测试结果中看到 古老方式,和管道向管道传输是最快的,,,,,为什么呢?

我分析是这样的,由于另外2种方法内部都使用了 字节数组作为缓存中转,在加上NIO内部有一个贴近系统的缓存区,这无意就增加了另一个缓存器,所以相对于这2个方法就要慢许多,,如果不使用 字节数组作为数据中转的话相信速度会更快的..