//关于这个使用带缓冲功能的字节流复制文件的小问题，有点错误想请教一下高手修改并提示一下错误的位置及原因，谢谢！

package jichu;
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.IOException;
//使用带缓冲功能的字节流复制文件
public class CopyFile {
  public static void main(String[] args) {
   BufferedReader bfr  =null;         
   BufferedWriter bfw  =null;
   try{
   bfr = new BufferedReader(new InputStreamReader(new FileInputStream(new File("c:\\2.txt")))) ;   
   bfw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("D:\\3.txt"))) ;
   byte[] bytes = new byte[1024];
   String length = null;
   while((length=bfr.readLine(bytes))!=null){
    bfw.write(bytes,0,length);
    bfw.flush();
   }
   }catch(IOException e){
    e.printStackTrace();
    throw new RuntimeException();
   }finally{
    if(bfr!=null)
     bfr.close();
     
   }finally{
    if (bfw!=null) {
     bfw.close();
    }
   }  
  }
}

已经学习,谢谢

都是高手啊！

好1111111111111111111

学习了！！！！

package exam;
//使用带缓冲功能的字节流复制文件。
import java.io.BufferedInputStream;  
import java.io.BufferedOutputStream;  
import java.io.File;  
import java.io.FileInputStream;  
import java.io.FileOutputStream;  
import java.io.IOException;  
import java.text.DecimalFormat;
public class Test7
{  
        public static void copyFile(String file,String path){  
                BufferedInputStream bis = null;  
        BufferedOutputStream bos = null;  
        try
        {  
            File copyFile = new File(file);   
            File savePath = new File(path);  
            
            //如果要复制的文件不存在或者不是文件，发出提示并退出程序  
            if (!(copyFile.exists() && copyFile.isFile()))
            {  
                System.out.println("无效的文件，请检查");  
               System.exit(0);  
            }  
            //如果要保存到的目录不存在，则创建该目录   
            if (!(savePath.isDirectory())){  
                System.out.println("你指定的目录不存在，将自动创建！");  
                savePath.mkdirs();  
            }     
            //创建目标文件完整路径。  
           File saveFile = new File(savePath+"\\"+copyFile.getName());  
            //如果saveFile是一个文件，说明有同名文件存在，则提示并退出程序，避免覆盖同名文件。  
            if (saveFile.isFile())
            {  
                System.out.println("注意！该目录下有同名文件。");  
                System.exit(0);  
            }
          //创建输入流和输出流。  
           bis = new BufferedInputStream(new FileInputStream(copyFile));  
           bos = new BufferedOutputStream(new FileOutputStream(saveFile));  
            //获取输入流中的的字节数。  
            long len = bis.available();  
              
            //格式化显示文件大小，保留1位小数  
            DecimalFormat df = new DecimalFormat(".0");  
            String size = null;  
           if(len > 1024*1024*200){  
                System.out.println("要复制的文件超过200MB，不能复制！");  
            }else if(len > 1024*1024){  
                size = df.format(len/1024/1024) + " MB";  
             }else if(len > 1024){  
                size = df.format(len/1024) + " KB";  
            }else{  
                size = len + " 字节";  
            }  
            System.out.println("文件大小：" + size);  
            System.out.println("复制中...");  
              
            //记录复制开始时毫秒值  
            long start = System.currentTimeMillis();  
            
            //如果文件大于200MB，用一次读一个字节方式  
            //否则就用数组一次性读取方式复制  
            if(len > 1024*1024*200){  
               int by;  
                while((by=bis.read())!=-1){  
                    bos.write(by);  
                }  
            }else{  
               //创建数组缓冲区，指定大小为输入流中的的字节数len。  
                byte[] bytes = new byte[(int)len];        
               bis.read(bytes);    //从输入流中读取所有数据存储到数组中。  
                 bos.write(bytes);   //将数组中的所有数据写入的输出流缓冲区中。  
             }  
            //记录复制结束精辟时毫秒值  
              long end = System.currentTimeMillis();  
              
            System.out.println("复制完成");  
            System.out.println("耗时："+(end-start)+"毫秒");  
        }  
        catch(IOException e){  
             throw new RuntimeException("复制文件失败");  
         }
        finally{  
                            try{  
                        if (bis!=null){  
                    bis.close();  
               }  
           }  
            catch(IOException e){  
               throw new RuntimeException("输出流关闭失败");  
           }  
            try{  
                if (bos!=null){  
                    bos.close();  
               }  
            }  

        

            catch(IOException e)
            {  
               throw new RuntimeException("输出流关闭失败");  
            }  
        }  
   }      
    public static void main(String[] args){  
        //源文件                    
            String copyFile = "D:\\新建文件夹\\刘熙峥\\I Love You.mpg";
            //指定目标路径，没有责创建
        String savePath = "E:\\黑马程序员";            
       copyFile(copyFile,savePath);  
    }  
}  

1. package com.itheima;
   
2. 
   
3. import java.io.*;
   
4. 
   
5. //使用带缓冲功能的字节流复制文件
   
6. public class CopyFile
   
7. {
   
8.         public static void main(String[] args)
   
9.         {
   
10.                 BufferedInputStream bis = null;
    
11.                 BufferedOutputStream bos = null;
    
12.                 try
    
13.                 {
    
14.                         FileInputStream fis = new FileInputStream("c:\\2.txt");
    
15.                         bis = new BufferedInputStream(fis);
    
16.                         FileOutputStream fos = new FileOutputStream("D:\\3.txt");
    
17.                         bos = new BufferedOutputStream(fos);
    
18.                         
    
19.                         long len = bis.available();
    
20.                         if(len > 1024*1024*200)
    
21.                         {  
    
22.                         int b;  
    
23.                         while((b=bis.read()) != -1)
    
24.                         {  
    
25.                             bos.write(b);  
    
26.                         }                     
    
27.                         }
    
28.                         else
    
29.                         {  
    
30.                         byte[] bytes = new byte[(int)len];        
    
31.                         bis.read(bytes);  
    
32.                         bos.write(bytes);
    
33.                 }
    
34.                 System.out.println("文件复制已经完成！");
    
35.                 }
    
36.                 catch (Exception e)
    
37.                 {
    
38.                         e.printStackTrace();
    
39.                 }
    
40.                 finally
    
41.                 {
    
42.                         if(bis != null)
    
43.                         try
    
44.                         {
    
45.                                 bis.close();
    
46.                         }
    
47.                         catch (IOException e)
    
48.                         {                        
    
49.                                 e.printStackTrace();
    
50.                         }
    
51.                         
    
52.                         if(bos != null)
    
53.                         try
    
54.                         {
    
55.                                 bos.close();
    
56.                         }
    
57.                         catch (IOException e)
    
58.                         {
    
59.                                 e.printStackTrace();
    
60.                         }
    
61.                 }
    
62.             
    
63.         }
    
64. }

复制代码

首先要分清字节流和字符流的区别?你的题目需求是说用字节流复制文件，而代码里面却使用字符流的相关方法在操作，这是其一。
其二，你所用字符流中的BufferedReader.readLine()方法，方法定义是读一行数据并存储在输入流缓冲区的字符数组中，所以不用你再去定义数组。
如果需要定义一个数组去保存读到的数据，那么对应的方法应该用read()方法。
其三，你定义的数组类型是字节数组，所用的流对象是字符流，题目是用字节流复制文件。所以前提还是搞清楚字节流、字符流的本质区别。
如果想把这个程序写得完美一些，应该把复制文件抽取成一个功能定义，而不是一股脑儿的写在主函数里面。
并且在复制前，需要进行一系列的判断：源文件是否存在?目标目录是否存在?目标目录下是否有同名文件?
自己补充上去吧！

1. import java.io.BufferedReader;
   
2. import java.io.BufferedWriter;
   
3. import java.io.File;
   
4. import java.io.FileOutputStream;
   
5. import java.io.FileReader;
   
6. import java.io.IOException;
   
7. import java.io.OutputStreamWriter;
   
8. //使用带缓冲功能的字节流复制文件
   
9. public class CopyFile {
   
10.   public static void main(String[] args) {
    
11.    BufferedReader bfr  =null;         
    
12.    BufferedWriter bfw  =null;
    
13.    try{
    
14.    bfr = new BufferedReader(new FileReader(new File("c:\\2.txt"))) ;   
    
15.    bfw = new BufferedWriter(new OutputStreamWriter(new FileOutputStream("D:\\3.txt"))) ;
    
16.    char bytes[] = new char[1024];
    
17.    int length = 0;
    
18.    while((length=bfr.read(bytes))>0){
    
19.     bfw.write(bytes,0,length);
    
20.     bfw.flush();
    
21.    }
    
22.    }catch(IOException e){
    
23.     e.printStackTrace();
    
24.     throw new RuntimeException();
    
25.    }finally{
    
26.     if(bfr!=null)
    
27.                 try {
    
28.                         bfr.close();
    
29.                 } catch (IOException e) {
    
30.                         // TODO Auto-generated catch block
    
31.                         e.printStackTrace();
    
32.                 }
    
33.     if (bfw!=null) {
    
34.         try {
    
35.                         bfw.close();
    
36.                 } catch (IOException e) {
    
37.                         // TODO Auto-generated catch block
    
38.                         e.printStackTrace();
    
39.                 }
    
40.        }
    
41.    }
    
42.   }
    
43. }

复制代码

已修改，请查收~