小测试
使用缓冲流是否一定可以提高复制效率呢，下面能过一个小测试便可知道答案。
此小测试的内容是使用代理的知识测出不使用缓冲流与使用缓冲流时复制一个文件所需要的时间。
因为涉及到代理，所以这里我用到了3个类与2个接口：

1. import java.io.*;
   
2. 
   
3. import java.lang.reflect.*;
   
4. 
   
5. //1. MyTest 目标类
   
6. public class MyTest  implements TheImplemetedInterfaceOfMyTest
   
7. {
   
8.         public static void main(String[] args)
   
9.         {
   
10.                 File sourceVideo = new File("d:/e.3gp");
    
11.                 File targetVideo = new File("d:/f.3gp");
    
12.                 File targetVideo1 = new File("d:/g.3gp");
    
13.                 final MyTest target = new MyTest();
    
14.                 final MyAdvice advice = new MyAdvice();
    
15.                 TheImplemetedInterfaceOfMyTest test = (TheImplemetedInterfaceOfMyTest) new MyProxy().getProxy(target, advice);
    
16.                 test.copy(sourceVideo, targetVideo);
    
17.                 test.copy1(sourceVideo, targetVideo1);
    
18.         }
    
19.         
    
20.         public   boolean copy(File sourceFile, File targetFile) {
    
21.                
    
22.                     byte [] buf = new byte[1024];
    
23.                     
    
24.                      OutputStream os = null;
    
25.                      InputStream is =null;
    
26.                      DataOutputStream dos = null;
    
27.                      DataInputStream dis = null;
    
28.                     try {
    
29.                             is = new FileInputStream(sourceFile);
    
30.                             os = new FileOutputStream(targetFile);
    
31.                             dis = new DataInputStream(is);
    
32.                             dos = new DataOutputStream(os);
    
33.                             int len = dis.read(buf);
    
34.                             while(len != -1){
    
35.                                     dos.write(buf,0,len);
    
36.                                     len = dis.read(buf);
    
37.                             }
    
38.                             return true;
    
39.                     } catch (FileNotFoundException e) {
    
40.                             e.printStackTrace();
    
41.                             return false;
    
42.                     } catch (IOException e) {
    
43.                             e.printStackTrace();
    
44.                             return false;
    
45.                     }
    
46.             }
    
47. 
    
48.         public   boolean copy1(File sourceFile, File targetFile) {
    
49.                
    
50.                     byte [] buf = new byte[1024];
    
51.                     
    
52.                      OutputStream os = null;
    
53.                      InputStream is =null;
    
54.                      BufferedInputStream bis = null;
    
55.                      BufferedOutputStream bos = null;
    
56.                      DataOutputStream dos = null;
    
57.                      DataInputStream dis = null;
    
58.                     try {
    
59.                             is = new FileInputStream(sourceFile);
    
60.                             bis = new BufferedInputStream(is);
    
61.                             dis = new DataInputStream(bis);
    
62.                             os = new FileOutputStream(targetFile);
    
63.                             bos = new BufferedOutputStream(os);
    
64.                             dos = new DataOutputStream(bos);
    
65.                             int len = dis.read(buf);
    
66.                             while(len != -1){
    
67.                                     dos.write(buf,0,len);
    
68.                                     len = dis.read(buf);
    
69.                             }
    
70.                             return true;
    
71.                     } catch (FileNotFoundException e) {
    
72.                             e.printStackTrace();
    
73.                             return false;
    
74.                     } catch (IOException e) {
    
75.                             e.printStackTrace();
    
76.                             return false;
    
77.                     }
    
78.             }
    
79.             
    
80. }
    
81. 
    
82. //2. MyProxy 代理类 通过我的代理获得一个代理对象
    
83. class MyProxy {
    
84. 
    
85.         public Object getProxy(final Object target,final Advice advice) {
    
86.                 Object proxy = Proxy.newProxyInstance(
    
87.                                 target.getClass().getClassLoader(),
    
88.                                 target.getClass().getInterfaces(),
    
89.                                 new InvocationHandler(){
    
90.                         public Object invoke(Object proxy, Method method, Object[] args)
    
91.                                         throws Throwable {
    
92.                                 advice.beforeMethod();
    
93.                                 Object retVal = method.invoke(target, args);
    
94.                                 advice.afterMethod();
    
95.                                 return retVal;
    
96.                         }});
    
97.                 return proxy;
    
98.         }
    
99.         
    
100. }
     
101. 
     
102. //3. MyAdvice 计算方法运行时间的类
     
103. class MyAdvice implements Advice {
     
104.         long startTime = 0;
     
105.         public void afterMethod() {
     
106.                 // TODO Auto-generated method stub
     
107.                 long endTime = System.currentTimeMillis();
     
108.                 System.out.println(endTime - startTime);
     
109.         }
     
110. 
     
111.         public void beforeMethod() {
     
112.                 // TODO Auto-generated method stub
     
113.                 startTime = System.currentTimeMillis();
     
114.         }
     
115. 
     
116. }
     
117. 
     
118. //4. TheImplemetedInterfaceOfMyTest 目标类所实现的接口
     
119. interface TheImplemetedInterfaceOfMyTest {
     
120.         boolean copy(File sourceFile, File targetFile);
     
121.         boolean copy1(File sourceFile, File targetFile);
     
122. }
     
123. 
     
124. //5. Advice 代理忠告接口
     
125. interface Advice {
     
126.         void beforeMethod();
     
127.         void afterMethod();
     
128. }
     

复制代码

测试结果：
　　（具体测试结果自己测试观察便可知道）

测试结论：
　　当缓存buf为1024字节，文件大小为2M左右，即缓存buf比文件小时，使用了缓冲流比不使用快；
　　当缓存buf为1024*1024*10字节，文件大小为2M左右，即缓存buf比文件大时，没有使用缓冲流的变快了，
       使得两者复制的时间差不多，但还是使用了缓冲流的稍快一点；两者都比使用缓存buf为10字节时快。
　　
最终结论：
　　若要提提高复制效率，应尽可能使用缓冲流。
　　如果不使用缓冲流，则应把缓存buf尽量设到与要复制的文件一样大小或稍大。
　　使用缓冲流时，也应把缓存buf尽量设到与要复制的文件一样大小或稍大。

韦念欣 发表于 2012-7-21 14:46 如果我要拷贝高清电影（1G），应该使用多少缓存才好呢？不可能开一个跟这个电影差不多大的缓存。。。。。 ...

我那结论只是相对来说的。比较适合于十来几十兆的文件！估计缓存开太大复制效率也未心会太高，应该还要看硬盘的读写速度吧。设成与硬盘的读写速度那个值应该是效率最高的吧！

如果我要拷贝高清电影（1G），应该使用多少缓存才好呢？不可能开一个跟这个电影差不多大的缓存。。。。。