FileWriter 是使用“流”，直接将数据写入到具体物理设备中，那么为什么write方法后还要flush刷新该流的缓冲？
既然“流”就是缓冲，那么BufferedWriter缓冲有什么不一样吗？BufferedWriter是怎么提高效率的？

write方法并不是直接将数据写入到存储介质中 而是写入到内存中的缓冲区中 使用flush方法后 才会将内存缓冲区中的数据写进存储介质
filewrite写入文件的方式是从源文件中读取一个字节 再向内存写入一个字节
bufferedwriter是从源文件读取一定的字节到字节数组中 当该数组的容量满了以后 才将数组中的数据写入到内存的缓冲区里。
打个比方 这是毕姥爷的教程里的比方：
你i想喝水 饮水机坏了 只能一滴一滴的滴水 如果没有缓冲区 只能饮水机滴一滴 你喝一滴
而有了缓冲区 就相当于拿了个杯子放在饮水机的出水口那 等杯子的水满了 你才去喝杯子里的水

同学，首先“流”不一定都带缓冲区的，不能认为“流”就是缓冲。只有字符流，也就是Reader和Writer才带缓冲区的,字节流steam直接就写入、读取，不带缓冲区的。其二，FileWriter既然是字符流，自然是有缓冲区的，查API，FileWriter是OutputStreamWriter的子类，该类是有缓冲区的，实现了flush。
查阅OutputStreamWriter的描述：我们找到这样一段话：
每次调用 write() 方法都会导致在给定字符（或字符集）上调用编码转换器。在写入底层输出流之前，得到的这些字节将在缓冲区中累积。可以指定此缓冲区的大小，不过，默认的缓冲区对多数用途来说已足够大。注意，传递给 write() 方法的字符没有缓冲。
为了获得最高效率，可考虑将 OutputStreamWriter 包装到 BufferedWriter 中，以避免频繁调用转换器

是不是可以这么理解，缓冲是分为两个阶段的，OutputStreamWriter在write 和底层的字节输出之间建立了缓冲，而BufferedWriter 则在调用write之前就建立了缓冲，从而避免了频繁调用write，而是攒够数据一次性的write。恩，我就能理解到这里了，坐等高手全面解答。

1. package cn04;
   
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. /**
    
11. * 需求：把d:\\爸爸去哪儿.mp3复制到项目路径下x.mp3(x=1,2,3,4)
    
12. *
    
13. * @author Administrator
    
14. *
    
15. *         基本字节流一次读写一个字节：耗时:52194毫秒
    
16. *         基本字节流一次读写一个字节数组：耗时:177毫秒
    
17. *         高效字节流一次读写一个字节：耗时:27985毫秒
    
18. *         高效字节流一次读写一个字节数组：耗时:53毫秒
    
19. */
    
20. public class copyMp3Test {
    
21.         public static void main(String[] args) throws IOException {
    
22.                 long start = System.currentTimeMillis();
    
23.                 // show1();
    
24.                 // show2();
    
25.                 // show3();
    
26.                 show4();
    
27.                 long end = System.currentTimeMillis();
    
28.                 System.out.println("耗时:" + (end - start) + "毫秒");
    
29.         }
    
30. 
    
31.         private static void show4() throws IOException {
    
32.                 // 高效字节流一次读写一个字节数组
    
33.                 BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
    
34.                                 "d:\\爸爸去哪儿.mp3"));
    
35.                 BufferedOutputStream bos = new BufferedOutputStream(
    
36.                                 new FileOutputStream("4.mp3"));
    
37.                 byte[] bys = new byte[1024];
    
38.                 int len = 0;
    
39.                 while ((len = bis.read(bys)) != -1) {
    
40.                         bos.write(bys, 0, len);
    
41.                         bos.flush();
    
42.                 }
    
43.                 // 释放资源
    
44.                 bos.close();
    
45.                 bis.close();
    
46. 
    
47.         }
    
48. 
    
49.         private static void show3() throws IOException {
    
50.                 // 高效字节流一次读写一个字节
    
51.                 BufferedInputStream bis = new BufferedInputStream(new FileInputStream(
    
52.                                 "d:\\爸爸去哪儿.mp3"));
    
53.                 BufferedOutputStream bos = new BufferedOutputStream(
    
54.                                 new FileOutputStream("3.mp3"));
    
55.                 int by = 0;
    
56.                 while ((by = bis.read()) != -1) {
    
57.                         bos.write(by);
    
58.                         bos.flush();
    
59.                 }
    
60.                 // 释放资源
    
61.                 bos.close();
    
62.                 bis.close();
    
63. 
    
64.         }
    
65. 
    
66.         private static void show2() throws IOException {
    
67.                 // 基本字节流一次读写一个字节数组
    
68.                 FileInputStream fis = new FileInputStream("d:\\爸爸去哪儿.mp3");
    
69.                 FileOutputStream fos = new FileOutputStream("2.mp3");
    
70.                 byte[] bys = new byte[1024];
    
71.                 int len = 0;
    
72.                 while ((len = fis.read(bys)) != -1) {
    
73.                         fos.write(bys, 0, len);
    
74.                         fos.flush();
    
75.                 }
    
76.                 // 释放资源
    
77.                 fos.close();
    
78.                 fis.close();
    
79.         }
    
80. 
    
81.         private static void show1() throws IOException {
    
82.                 // 基本字节流一次读写一个字节
    
83.                 FileInputStream fis = new FileInputStream("d:\\爸爸去哪儿.mp3");
    
84.                 FileOutputStream fos = new FileOutputStream("1.mp3");
    
85.                 int by = 0;
    
86.                 while ((by = fis.read()) != -1) {
    
87.                         fos.write(by);
    
88.                         fos.flush();
    
89.                 }
    
90.                 // 释放资源
    
91.                 fos.close();
    
92.                 fis.close();
    
93.         }
    
94. }
    
95. BufferedWriter   将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。  可以指定缓冲区的大小，或者接受默认的大小。在大多数情况下，默认值就足够大了。  该类提供了 newLine() 方法，它使用平台自己的行分隔符概念，此概念由系统属性 line.separator 定义。

复制代码