用三种方式复制图片，1，读一个字节写一个字节； 2，自定义缓冲区byte[1024]；3.定义字符流缓冲区
问题一、第二种方式复制出来的图片大小竟然不一样？！ 但是都能打开。


问题二、复制效率为什么自定义缓冲区比使用字符流缓冲区高，还是我程序有问题


程序如下：

1. package com.java19;
   
2. 
   
3. import java.io.BufferedInputStream;
   
4. import java.io.BufferedOutputStream;
   
5. import java.io.FileInputStream;
   
6. import java.io.FileOutputStream;
   
7. import java.io.IOException;
   
8. 
   
9. class Java19_11 {
   
10.         public static void main(String[] args) {
    
11.                
    
12.                 //读一个字节写一个字节
    
13.                 long start1 = System.currentTimeMillis();
    
14.                 pictureCopy_1();
    
15.                 long end1 = System.currentTimeMillis();
    
16.                 System.out.println("字节读取复制完成，花费时间" + (end1-start1) + "毫秒");
    
17.                
    
18.                 //自定义缓冲器byte[1024]
    
19.                 long start2 = System.currentTimeMillis();
    
20.                 pictureCopy_2();
    
21.                 long end2 = System.currentTimeMillis();
    
22.                 System.out.println("自定义缓冲区复制完成，花费时间" + (end2-start2) + "毫秒");
    
23.                
    
24.                 //定义字符流缓冲区
    
25.                 long start3 = System.currentTimeMillis();
    
26.                 pictureCopy_3();
    
27.                 long end3 = System.currentTimeMillis();
    
28.                 System.out.println("定义字符流缓冲区复制完成，花费时间" + (end3-start3) + "毫秒");
    
29.         }
    
30.         
    
31.         //读一个字节写一个字节
    
32.         public static void pictureCopy_1() {
    
33.                 FileInputStream fis = null;
    
34.                 FileOutputStream fos = null;
    
35.                 try {
    
36.                         fis = new FileInputStream("E:\\wolf.jpg");
    
37.                         fos = new FileOutputStream("E:\\wolf_copy2.jpg");
    
38.                         
    
39.                         int ch;
    
40.                         while((ch=fis.read())!=-1) {
    
41.                                 fos.write(ch);
    
42.                         }
    
43.                 } catch (Exception e) {
    
44.                         throw new RuntimeException("图片读取失败！");
    
45.                 } finally {
    
46.                         try {
    
47.                                 if(fis!=null) {
    
48.                                         fis.close();
    
49.                                 }
    
50.                         } catch (IOException e) {
    
51.                                 throw new RuntimeException("图片读取关闭失败！");
    
52.                         }
    
53.                         try {
    
54.                                 if(fos!=null) {
    
55.                                         fos.close();
    
56.                                 }                                
    
57.                         } catch (IOException e) {
    
58.                                 throw new RuntimeException("图片写入关闭失败！");
    
59.                         }
    
60.                 }
    
61.         }        
    
62.         
    
63.         //自定义缓冲器byte[1024]
    
64.         public static void pictureCopy_2() {
    
65.                 FileInputStream fis = null;
    
66.                 FileOutputStream fos = null;
    
67.                 try {
    
68.                         fis = new FileInputStream("E:\\wolf.jpg");
    
69.                         fos = new FileOutputStream("E:\\wolf_copy2.jpg");
    
70.                                 
    
71.                         byte[] buf = new byte[1024];
    
72.                         while((fis.read(buf))!=-1) {
    
73.                                 fos.write(buf);
    
74.                         }
    
75.                 } catch (Exception e) {
    
76.                         throw new RuntimeException("图片读取失败！");
    
77.                 } finally {
    
78.                         try {
    
79.                                 if(fis!=null) {
    
80.                                         fis.close();
    
81.                                 }
    
82.                         } catch (IOException e) {
    
83.                                 throw new RuntimeException("图片读取关闭失败！");
    
84.                         }
    
85.                         try {
    
86.                                 if(fos!=null) {
    
87.                                         fos.close();
    
88.                                 }                                
    
89.                         } catch (IOException e) {
    
90.                                 throw new RuntimeException("图片写入关闭失败！");
    
91.                         }
    
92.                 }
    
93.         }
    
94.                
    
95.         //定义字符流缓冲区
    
96.         public static void pictureCopy_3() {
    
97.                 BufferedInputStream bufis = null;
    
98.                 BufferedOutputStream bufos = null;
    
99.                 try {
    
100.                         bufis = new BufferedInputStream(new FileInputStream("E:\\wolf.jpg"));
     
101.                         bufos = new BufferedOutputStream(new FileOutputStream("E:\\wolf_copy3.jpg"));
     
102.                         
     
103.                         int by = 0;
     
104.                         while((by=bufis.read())!=-1) {
     
105.                                 bufos.write(by);
     
106.                         }
     
107.                 } catch (Exception e) {
     
108.                         throw new RuntimeException("图片读取失败！");
     
109.                 } finally {
     
110.                         try {
     
111.                                 if(bufis!=null) {
     
112.                                         bufis.close();
     
113.                                 }
     
114.                         } catch (IOException e) {
     
115.                                 throw new RuntimeException("图片读取关闭失败！");
     
116.                         }
     
117.                         try {
     
118.                                 if(bufos!=null) {
     
119.                                         bufos.close();
     
120.                                 }                                
     
121.                         } catch (IOException e) {
     
122.                                 throw new RuntimeException("图片写入关闭失败！");
     
123.                         }
     
124.                 }        
     
125.         }
     
126. }

复制代码

package study;
import java.io.BufferedInputStream;
import java.io.BufferedOutputStream;
import java.io.FileInputStream;
import java.io.FileOutputStream;
import java.io.IOException;
public class FileStreamPicCopy {
public static void main(String[] args) {
        
        //读一个字节写一个字节
        long start1 = System.currentTimeMillis();
        pictureCopy_1();
        long end1 = System.currentTimeMillis();
        System.out.println("字节读取复制完成，花费时间" + (end1-start1) + "毫秒");
        
        //自定义缓冲器byte[1024]
        long start2 = System.currentTimeMillis();
        pictureCopy_2();
        long end2 = System.currentTimeMillis();
        System.out.println("自定义缓冲区复制完成，花费时间" + (end2-start2) + "毫秒");
        
        //定义字符流缓冲区
        long start3 = System.currentTimeMillis();
        pictureCopy_3();
        long end3 = System.currentTimeMillis();
        System.out.println("定义字符流缓冲区复制完成，花费时间" + (end3-start3) + "毫秒");
}
//读一个字节写一个字节
public static void pictureCopy_1() {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
                fis = new FileInputStream("toy.jpg");
                fos = new FileOutputStream("toy1.jpg");
               
                int ch;
                while((ch=fis.read())!=-1) {
                        fos.write(ch);
                }
        } catch (Exception e) {
                throw new RuntimeException("图片读取失败！");
        } finally {
                try {
                        if(fis!=null) {
                                fis.close();
                        }
                } catch (IOException e) {
                        throw new RuntimeException("图片读取关闭失败！");
                }
                try {
                        if(fos!=null) {
                                fos.close();
                        }                                
                } catch (IOException e) {
                        throw new RuntimeException("图片写入关闭失败！");
                }
        }
}        
//自定义缓冲器byte[1024]
public static void pictureCopy_2() {
        FileInputStream fis = null;
        FileOutputStream fos = null;
        try {
                fis = new FileInputStream("toy.jpg");
                fos = new FileOutputStream("toy2.jpg");
                        
                byte[] buf = new byte[1024];
                int len = 0;
       while((len = fis.read(buf)) != -1)
       {
        fos.write(buf, 0, len);//这里修改后，应该就可以解决问题了，我按照你的程序运行，没有发现问题，我个人分析，问题是可能发生
                //读取的和写入的内容不一致，这里对读取长度进行记录，保证了读写一致
       }
//                while((fis.read(buf))!=-1) {
//                        fos.write(buf);
//                }
        } catch (Exception e) {
                throw new RuntimeException("图片读取失败！");
        } finally {
                try {
                        if(fis!=null) {
                                fis.close();
                        }
                } catch (IOException e) {
                        throw new RuntimeException("图片读取关闭失败！");
                }
                try {
                        if(fos!=null) {
                                fos.close();
                        }                                
                } catch (IOException e) {
                        throw new RuntimeException("图片写入关闭失败！");
                }
        }
}
        
//定义字符流缓冲区
public static void pictureCopy_3() {
        BufferedInputStream bufis = null;
        BufferedOutputStream bufos = null;
        try {
                bufis = new BufferedInputStream(new FileInputStream("toy.jpg"));
                bufos = new BufferedOutputStream(new FileOutputStream("toy3.jpg"));
               
                int by = 0;
                while((by=bufis.read())!=-1) {
                        bufos.write(by);
                }
        } catch (Exception e) {
                throw new RuntimeException("图片读取失败！");
        } finally {
                try {
                        if(bufis!=null) {
                                bufis.close();
                        }
                } catch (IOException e) {
                        throw new RuntimeException("图片读取关闭失败！");
                }
                try {
                        if(bufos!=null) {
                                bufos.close();
                        }                                
                } catch (IOException e) {
                        throw new RuntimeException("图片写入关闭失败！");
                }
        }        
}
}

fos.write(buf, 0, len);