黑马程序员技术交流社区

标题: 有关于IO的提问，求大神解答 [打印本页]
作者: 王小乖    时间: 2015-5-11 16:07
标题: 有关于IO的提问，求大神解答
代码中copyPic_2和copyPic_3中的while的读取数据部分有什么区别吗？copyPic_2那个为什么会报java.lang.ArrayIndexOutOfBoundsException
代码如下，求大神解答
  1. package FileStreamDemo;

  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;

  10. public class FileStreamDemo {

  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.         }

  140. }
复制代码
作者: l763631191    时间: 2015-5-11 16:17
本帖最后由 l763631191 于 2015-5-11 16:26 编辑

我还是看看下面的回答吧不过byte by[] = new byte[1024*1024*200];  1024*1024*200  200M啊，这难道不内存溢出，你试试1024*2 试试啊
作者: 王小乖    时间: 2015-5-11 16:28
l763631191 发表于 2015-5-11 16:17
我还是看看下面的回答吧不过byte by[] = new byte[1024*1024*200];  1024*1024*200  200M啊，这难道不内存 ...

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

在使用缓冲字节流，你直接用read方法读就可以了 然后再直接写~~，不需要先读到一个数组中，这本身就是加强的流，里面的read（）方法就是加强的功能
作者: 王小乖    时间: 2015-5-11 16:50
l763631191 发表于 2015-5-11 16:38
在使用缓冲字节流，你直接用read方法读就可以了 然后再直接写~~，不需要先读到一个数组中，这本身就是加 ...

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



欢迎光临 黑马程序员技术交流社区 (http://bbs.itheima.com/) 黑马程序员IT技术论坛 X3.2