四种读写方式，问题都在注释中了。。。。

1. import java.io.*;
   
2. 
   
3. public class copyDir {
   
4. 
   
5.         public static void main(String[] args) throws IOException {
   
6.                 // TODO Auto-generated method stub
   
7.                 String target = "e:\\test\\84.jpg";
   
8.                 String source = "e:\\test\\88.jpg";        
   
9.                 File file1 = new File(target);
   
10.                 File file2 = new File(source);
    
11.                 copyFile(file1,file2);
    
12.         }
    
13.         
    
14.         public static void copyFile(File file1,File file2) throws IOException{
    
15.                 //定义文件读取流
    
16.                 FileInputStream fis = new FileInputStream(file1);
    
17.                 BufferedInputStream bufis = new BufferedInputStream(fis);
    
18.                 //定义文件写入流
    
19.                 FileOutputStream fos = new FileOutputStream(file2);
    
20.                 BufferedOutputStream bufos = new BufferedOutputStream(fos);
    
21.                
    
22.                 //读取和写入
    
23.                
    
24.                 //文件字节流复制——太慢我们想到了自定义缓冲区
    
25.                 int b = 0;
    
26.                 while((b=fis.read())!=-1) {
    
27.                         fos.write(b);
    
28.                 }
    
29.                 /*
    
30.                 //文件流字节流复制——自定义缓冲区——为了进一步提高效率我们想到加入缓冲流
    
31.                 byte[] buf = new byte[1024];
    
32.                 int b = 0;
    
33.                 while((b=fis.read(buf))!=-1){
    
34.                         //fos.write(buf,0,b);
    
35.                         fos.write(buf);        //一样的效果。。为什么还要写0到b呢？
    
36.                 }               
    
37.                
    
38.                  //缓冲流复制
    
39.                 int b = 0;
    
40.                 while((b=bufis.read())!=-1){
    
41.                         bufos.write(b);
    
42.                 }
    
43.                  //带数组缓冲区的缓冲流复制————最后我想问缓冲流里为什么还要定义缓冲数组？更高效吗？
    
44.                 byte[] buf = new byte[1024];
    
45.                 int b = 0;
    
46.                 while((b=bufis.read(buf))!=-1){
    
47.                         bufos.write(buf,0,b);
    
48.                 }
    
49.                 */
    
50.                 //关闭流
    
51.                 fis.close();
    
52.                 fos.close();
    
53.                 bufis.close();
    
54.                 bufos.close();
    
55.         }
    
56. }

复制代码

2666fff 发表于 2015-6-4 19:56
我是想让版主给我加技术分的本来，你给我加了，那我帮你测试下。
帮你测试了，不用长度的话，第二个是有冗 ...

:kiss:谢谢啦

我是想让版主给我加技术分的本来，你给我加了，那我帮你测试下。
帮你测试了，不用长度的话，第二个是有冗余数据的，比第一个大。

被淹死的虫子 发表于 2015-6-4 19:37
解释的很透彻。。。。第一个问题还有点疑惑。。。我拷贝的图片是2.3M的，亲自都试过了 ...

那你点开文件详细，看看两个文件大小是否完全一样？

2666fff 发表于 2015-6-4 19:01
第一个问题：
fos.write(buf);        //一样的效果。。为什么还要写0到b呢？
byte[] buf = new byte[1024 ...

解释的很透彻。。。。第一个问题还有点疑惑。。。我拷贝的图片是2.3M的，亲自都试过了

第一个问题：
fos.write(buf);        //一样的效果。。为什么还要写0到b呢？
byte[] buf = new byte[1024];
如果不赋值 初始值都是0，你出现都一样的情况，应该是因为你读取的文件长度不够1024字节，你可以试试
1026字节的文件，如果你不定义write的长度，那么写出的内容会包含第二次读取的 1025 1026 以及 之前的3 4 5 6...

第二个问题
//带数组缓冲区的缓冲流复制————最后我想问缓冲流里为什么还要定义缓冲数组？更高效吗？
                byte[] buf = new byte[1024];
                int b = 0;
                while((b=bufis.read(buf))!=-1){
                        bufos.write(buf,0,b);
                }

BufferedInputStream是一个带有缓冲区域的InputStream,它的继承体系如下：
InputStream
|__FilterInputStream
        |__BufferedInputStream

bufis api中有说：

可以指定缓冲区的大小或者可以已使用默认大小。大多数情况下，默认值就足够大了。
private static int defaultBufferSize = 8192 //该变量定义了默认的缓冲大小

而bufis指定的这个缓冲区域的用途是：
先读取比请求更多的数据到缓冲区，当调用read时如果数据已经在缓存区，则直接返回对应数据不做IO操作，否则去读取新的数据到缓冲区(通常比请求的数据要多)。
所以：
你去读的时候是从缓冲区中拿东西。这种模式最大的特点是半阻塞式，大部分情况下能大幅度提高处理速度。
在程序逻辑速度大大慢于IO速度时，此方法效率明显。

我写这么好不给技术分，我不服！

总结得不错