java.io 中， BufferedReader除了多出一个 readLine()函数， 还有什么区别吗？ 好像FileReader也可以把输入流读取到一个缓冲区中间。

1. import java.io.*;
   
2. 
   
3. public class InputOutPutDemo {
   
4.         static String srcPath = "src/InputOutPutDemo.java";
   
5.         static String destPath = "C:/testDemo.java";
   
6. 
   
7.         public static void main(String[] args) {
   
8.                 copyFile3();
   
9.         }
   
10.         
    
11. 
    
12.         //BufferedReader BufferedWriter
    
13.         static void copyFile2() {
    
14.                 BufferedReader br = null;
    
15.                 BufferedWriter bw = null;
    
16.                 try {
    
17.                         br = new BufferedReader(new FileReader(srcPath));
    
18.                         bw = new BufferedWriter(new FileWriter(destPath));
    
19.                         char[] buf = new char[1024];
    
20.                         int num = 0;
    
21.                         while((num = br.read(buf)) != -1) {
    
22.                                 bw.write(buf, 0, num);
    
23.                                 bw.flush();
    
24.                         }
    
25.                 } catch(IOException e) {
    
26.                         e.printStackTrace();
    
27.                 } finally {
    
28.                         try {
    
29.                                 if(br != null)
    
30.                                         br.close();
    
31.                                 if(bw != null)
    
32.                                         bw.close();
    
33.                         } catch(IOException e) {
    
34.                                 e.printStackTrace();
    
35.                         }
    
36.                 }
    
37.         }
    
38.         
    
39.         //FileReader FileWriter
    
40.         static void copyFile() {
    
41.                 FileReader fr = null;
    
42.                 FileWriter fw = null;
    
43.                
    
44.                 try {
    
45.                         fr = new FileReader(srcPath);
    
46.                         fw = new FileWriter(destPath);
    
47.                         char[] buf = new char[10];
    
48.                         int num = 0;
    
49.                         
    
50.                         while((num = fr.read(buf)) != -1) {
    
51.                                 fw.write(buf, 0, num);
    
52.                                 fw.flush();
    
53. 
    
54.                         }
    
55.                 } catch(FileNotFoundException e) {
    
56.                         e.printStackTrace();
    
57.                 } catch(IOException e) {
    
58.                         e.printStackTrace();
    
59.                 } finally {
    
60.                         try {
    
61.                                 if(fr != null)
    
62.                                         fr.close();
    
63.                                 if(fw != null)
    
64.                                         fw.close();
    
65.                         } catch(IOException e) {
    
66.                                 e.printStackTrace();
    
67.                         }
    
68.                 }
    
69.         }
    
70. }
    
71.         

复制代码

就像上面的代码， FileReader不是也用了缓冲区buf吗， 为什么还要另外有一个类BufferedReader?

即使用了缓冲区，他俩的基本原理都一个一个字节的读入，这个缓冲跟那个缓冲不是一个缓冲。应该是这样

FileReader是字符输入流，BufferedReader是高效字符输入流，听名字就知道BufferedReader的速度更快啊，