如题：很多流有对应的缓冲流。一般写程序没有注意到。直接输入输出了。那么什么时候。用缓冲流呢？

BufferedWriter：是给字符输出流提高效率用的，那就意味着，缓冲区对象建立时，必须要先有流对象。明确要提高具体的流对象的效率。
FileWriterfw=newFileWriter("bufdemo.txt");
BufferedWriterbufw=newBufferedWriter(fw);//让缓冲区和指定流相关联。
for(intx=0;x<4;x++){
bufw.write(x+"abc");
bufw.newLine();//写入一个换行符，这个换行符可以依据平台的不同写入不同的换行符。
bufw.flush();//对缓冲区进行刷新，可以让数据到目的地中。
}
bufw.close();//关闭缓冲区，其实就是在关闭具体的流。

--------------------------------------------------------------------------------
BufferedReader：
FileReaderfr=newFileReader("bufdemo.txt");
BufferedReaderbufr=newBufferedReader(fr);
Stringline=null;
while((line=bufr.readLine())!=null){//readLine方法返回的时候是不带换行符的。
System.out.println(line);
}
bufr.close();

缓冲流主要是为了提高效率用的，比如你要读写一个较大的文本文件，如果直接输入输出的话，会造成频繁的读写，效率较低；若使用缓冲流，则就在内存中开辟了一个字节数组，可把较多的数据读入这个数组，然后一次性进行写的操作，降低了写的频率，从而提高了效率；
当然，若你读写的数据较少的话，可以不用考虑效率的问题，也就不需要用缓冲流；
例子就不举了，见楼上；

BufferedWriter和BufferedReader：字符流缓冲区
1、缓冲区的出现：提高了流的读写效率，所以在缓冲区创建前，要先创建流对象，即先将流对象初始化到构造函数中。
2、缓冲技术原理：此对象中封装了数组，将数据存入，在一次性取出。
3、写入流缓冲区BufferedWriter的步骤：
1）创建一个字符写入流对象
2）为提高字符写入流效率，加入缓冲技术，只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可。
      注意，只要用到缓冲去就需要刷新。
3）其实关闭缓冲区就是在关闭缓冲区中的流对象。
      该缓冲区中提供了一个跨平台的换行符：newLine()。
4、读取流缓冲区BufferedReader的步骤：
1）创建一个读取流对象和文件关联
2）为提高效率，加入缓冲技术，将字符读取流对象作为参数传递给缓冲对象的构造函数。
3）该缓冲区提供了一个一次读一行的方法readLine()，方便与对文本数据的获取，当返回null时，表示读到文件末尾。
      readLine()方法返回的时只返回回车符之前的数据内容，并不返回回车符，即读取的内容中不包含任何行终止符（回车符和换行符）。
--->readLine()方法原理：无论是读一行，或读取多个字符，其实最终都是在硬盘上一个一个读取。所以最终使用的还是read方法一次读一个。
5、使用缓冲技术拷贝文件，提高效率：

1. /*
   
2. 缓冲区的出现是为了提高流的操作效率而出现的
   
3. 
   
4. 所以在创建缓冲区之前，必须要先有流对象
   
5. 
   
6. \r\n是在windows下换行 \n在linux是换行
   
7. 
   
8. 该缓冲区中提供了一个跨平台的换行符
   
9. newLine();
   
10. */
    
11. import java.io.*;
    
12. 
    
13. class BufferedWriterDemo
    
14. {
    
15.    public static void main(String []args) throws IOException
    
16.    {
    
17.      //创建一个字符写入流流对象
    
18.          FileWriter fw=new FileWriter("buf.txt");
    
19.          
    
20.          //为了提高字符写入流的效率，加入缓冲技术（原理就是这个对象里面封装了数组）
    
21.          //只要将需要被提高效率的流对象作为参数传递给缓冲区的构造函数即可
    
22.          BufferedWriter  bufw=new BufferedWriter(fw);
    
23.        
    
24.         for(int x=1;x<5;x++)
    
25.         {
    
26.            bufw.write("abcd"+x);
    
27.             bufw.newLine();
    
28.                 bufw.flush();
    
29.         }
    
30.      //bufw.write("abcde");
    
31.      //bufw .write("\r\n");
    
32.          //newLine()在任何系统平台下都是换行
    
33.         // bufw.newLine();
    
34.          
    
35.          //记住，只要用到缓冲区，就要记得刷新
    
36.          //bufw.flush();
    
37.          
    
38.          //其实关闭缓冲区，就是在关闭缓冲区中的流对象
    
39.          bufw.close();
    
40.          
    
41.    }
    
42. }

复制代码

1. /*
   
2. 字符读取流缓冲区：
   
3. 
   
4. 该缓冲区提供了一个一次读一行的方法readLine，方便于对文本数据的获取。
   
5. 当返回null时，表示读到文件末尾。
   
6. */
   
7. import java.io.*;
   
8. class BufferedReaderDemo
   
9. {
   
10.    public static void main(String []args) throws IOException
    
11.    {
    
12.      //创建一个读取流对象和文件相关联
    
13.          FileReader fr=new FileReader("buf.txt");
    
14.          //为了提高效率，加入缓冲技术。将字符读取流对象作为参数传递给缓冲对象的构造函数
    
15.          BufferedReader bufr=new BufferedReader(fr);
    
16.          
    
17.          String line=null;
    
18.          while((line=bufr.readLine())!=null)
    
19.          {
    
20.             System.out.println(line);
    
21.          }
    
22.          /*
    
23.         String s1=bufr.readLine();
    
24.          
    
25.         System.out.println("s1:"+s1);
    
26.        
    
27.         String s2=bufr.readLine();
    
28.          
    
29.         System.out.println("s2:"+s2);
    
30.         */
    
31.         bufr.close();
    
32.    }
    
33.    
    
34. }

复制代码

代码和注释已经给出，希望能对你有所帮助

缓冲就是提高效率用的，若不用缓冲相当于读一个写一个，用个缓冲相当于读一堆写一堆。

通常见到的读写流的基类中都定义了自己的缓冲子类，目的就是为了增加效率的。

其实如果模拟一下缓冲的源代码你就会很清晰了，这面是一段一次读一行的代码
// readLine()原理，自定义一个功能和readLine一致的方法，模仿bufferedReader

class MybufferedReader extends Reader {
        private static FileReader r;

        MybufferedReader(FileReader r) {
                this.r = r;
        }

        // 可以一次多一行数据的方法
        public String myReadLine() throws IOException {
                // 定义一个临时容器，原BufferedReader封装的是一个字符数组
                // 为了演示方便，定义一个StringBuilder容器，因为最终还是要将数据变成字符串
                StringBuilder sb = new StringBuilder();
                int ch = 0;
                while ((ch = r.read()) != -1) {
                        if (ch == '\r')
                                continue;
                        if (ch == '\n')
                                return sb.toString();
                        else
                                sb.append((char) ch);
                }
                if (sb.length() != 0)
                        return sb.toString();
                return null;
        }

        // 覆盖方法
        public void close() throws IOException {
                r.close();
        }

        public int read(char[] cbuf, int off, int len) throws IOException {
                // TODO Auto-generated method stub
                return r.read(cbuf, off, len);
        }
}

简单概括，一般操作文件或数据稍微大一些的时候就可以添加缓冲流。(缓冲流可以提高效率，特别是数据越大越明显)
缓冲区其实就是一个数组，字节流是Byte[]类型数组，而字符流是char[]类型数组，也因此可以自己在读写时自定义数组，用来存储数据，原理跟缓冲区差不多。
使用缓冲区的优点就是（缓冲区/流是一个装饰类，就是将存储数据数组进行封装并加强的类）： 你要读写数据时最好是用存储数据的容器(也就是数组或StringBuffer等)来装，减少磁盘的来回读写，而缓冲流提供的功能就是创建一个我(缓冲流)，我给你一个容器(有默认大小，我记得BufferedOutputStream用的是是8KB，但也可指定大小)，所以使用缓冲流就可以不用自己自定义数组。

OK，谢谢大家

请及时修改帖子分类，问题以解决请更改标签为以解决。否则继续提问，谢谢合作。

如果问题未解决，请继续追问，如果问题解决了，请将分类改为“已解决”，谢谢合作！

Sword 发表于 2013-5-7 14:16
BufferedWriter和BufferedReader：字符流缓冲区
1、缓冲区的出现：提高了流的读写效率，所以在缓冲区创建前 ...

你这个代码怎么复制的啊, 为什么我从EditPlus里边复制出来的代码就没有行数?

葛杨杨 发表于 2013-5-8 02:55
你这个代码怎么复制的啊, 为什么我从EditPlus里边复制出来的代码就没有行数?  ...

插入的时候点击工具栏上的“<>”按钮即可，在里面添加代码