代码中copyPic_2和copyPic_3中的while的读取数据部分有什么区别吗？copyPic_2那个为什么会报java.lang.ArrayIndexOutOfBoundsException
代码如下，求大神解答

1. package FileStreamDemo;
   
2. 
   
3. import java.io.BufferedInputStream;
   
4. import java.io.BufferedOutputStream;
   
5. import java.io.FileInputStream;
   
6. import java.io.FileNotFoundException;
   
7. import java.io.FileOutputStream;
   
8. import java.io.IOException;
   
9. 
   
10. public class FileStreamDemo {
    
11. 
    
12.         public static void main(String[] args) {
    
13.                 // TODO Auto-generated method stub
    
14.                 long startTime = System.currentTimeMillis();
    
15.                 copyPic_2();
    
16.                 long endTime = System.currentTimeMillis();
    
17.                 System.out.println(endTime-startTime+"毫秒");
    
18.         }
    
19.        
    
20.         public static void copyPic_3(){
    
21.                 FileInputStream fis = null;
    
22.                 FileOutputStream fos = null;
    
23.                
    
24.                 try {
    
25.                         fis = new FileInputStream("1.jpg");
    
26.                         fos = new FileOutputStream("1_copy2.jpg");
    
27.                        
    
28.                         byte by[] = new byte[1024];
    
29.                        
    
30.                         int len = 0;
    
31.                         try {
    
32.                                 while((len=fis.read(by))!=-1){
    
33.                                         fos.write(by, 0, len);
    
34.                                 }
    
35.                         } catch (IOException e) {
    
36.                                 // TODO Auto-generated catch block
    
37.                                 e.printStackTrace();
    
38.                         }
    
39.                 } catch (FileNotFoundException e) {
    
40.                         // TODO Auto-generated catch block
    
41.                         e.printStackTrace();
    
42.                 }
    
43.                 finally{
    
44.                         try {
    
45.                                 if(fis!=null)
    
46.                                         fis.close();
    
47.                         } catch (IOException e) {
    
48.                                 // TODO Auto-generated catch block
    
49.                                 e.printStackTrace();
    
50.                         }
    
51.                         try {
    
52.                                 if(fos!=null)
    
53.                                         fos.close();
    
54.                         } catch (IOException e) {
    
55.                                 // TODO Auto-generated catch block
    
56.                                 e.printStackTrace();
    
57.                         }
    
58.                 }
    
59.         }
    
60.         public static void copyPic_2(){
    
61.                 BufferedInputStream bufIn= null;
    
62.                 BufferedOutputStream bufOut = null;
    
63.                
    
64.                 try {
    
65.                         bufIn = new BufferedInputStream(new FileInputStream("1.jpg"));
    
66.                         bufOut = new BufferedOutputStream(new FileOutputStream("1_copy2.jpg"));
    
67.                        
    
68.                         byte by[] = new byte[1024*1024*200];
    
69.                        
    
70.                         int len =0;
    
71.                         while(len!=-1){
    
72.                                 try {
    
73.                                         len = bufIn.read(by);
    
74.                                         bufOut.write(by, 0, len);
    
75.                                 } catch (IOException e) {
    
76.                                         // TODO Auto-generated catch block
    
77.                                         e.printStackTrace();
    
78.                                 }
    
79.                         }
    
80.                 } catch (FileNotFoundException e) {
    
81.                         // TODO Auto-generated catch block
    
82.                         e.printStackTrace();
    
83.                 }
    
84.                 finally{
    
85.                         try {
    
86.                                 if(bufIn!=null)
    
87.                                         bufIn.close();
    
88.                         } catch (IOException e) {
    
89.                                 // TODO Auto-generated catch block
    
90.                                 e.printStackTrace();
    
91.                         }
    
92.                         try {
    
93.                                 if(bufOut!=null)
    
94.                                         bufOut.close();
    
95.                         } catch (IOException e) {
    
96.                                 // TODO Auto-generated catch block
    
97.                                 e.printStackTrace();
    
98.                         }
    
99.                 }
    
100.         }
     
101.         public static void copyPic_1(){
     
102.                 BufferedInputStream bufIn= null;
     
103.                 BufferedOutputStream bufOut = null;
     
104.                 try {
     
105.                         bufIn = new BufferedInputStream(new FileInputStream("1.jpg"));
     
106.                         bufOut = new BufferedOutputStream(new FileOutputStream("1_copy.jpg"));
     
107.                        
     
108.                         int len = 0;
     
109.                         while(len!=-1){
     
110.                                 try {
     
111.                                         len = bufIn.read();
     
112.                                         bufOut.write((char)len);
     
113.                                 } catch (IOException e) {
     
114.                                         // TODO Auto-generated catch block
     
115.                                         e.printStackTrace();
     
116.                                 }
     
117.                         }
     
118.                 } catch (FileNotFoundException e) {
     
119.                         // TODO Auto-generated catch block
     
120.                         e.printStackTrace();
     
121.                 }
     
122.                 finally{
     
123.                         try {
     
124.                                 if(bufIn!=null)
     
125.                                         bufIn.close();
     
126.                         } catch (IOException e) {
     
127.                                 // TODO Auto-generated catch block
     
128.                                 e.printStackTrace();
     
129.                         }
     
130.                         try {
     
131.                                 if(bufOut!=null)
     
132.                                         bufOut.close();
     
133.                         } catch (IOException e) {
     
134.                                 // TODO Auto-generated catch block
     
135.                                 e.printStackTrace();
     
136.                         }
     
137.                 }
     
138.         }
     
139. 
     
140. }
     

复制代码

我还是看看下面的回答吧不过byte by[] = new byte[1024*1024*200];  1024*1024*200  200M啊，这难道不内存溢出，你试试1024*2 试试啊

l763631191 发表于 2015-5-11 16:17
我还是看看下面的回答吧不过byte by[] = new byte[1024*1024*200];  1024*1024*200  200M啊，这难道不内存 ...

我试了，开始的时候写的是1024，后面又改了1024*2，1024*20，都不行

王小乖 发表于 2015-5-11 16:28
我试了，开始的时候写的是1024，后面又改了1024*2，1024*20，都不行

在使用缓冲字节流，你直接用read方法读就可以了 然后再直接写~~，不需要先读到一个数组中，这本身就是加强的流，里面的read（）方法就是加强的功能

l763631191 发表于 2015-5-11 16:38
在使用缓冲字节流，你直接用read方法读就可以了 然后再直接写~~，不需要先读到一个数组中，这本身就是加 ...

我只是想知道copyPic_2里面那个地方错了啊，为什么会报异常呢？