先帮我分析一下缓冲区的概念吧？
然后下面还有一点我弄不懂的地方。。

1. 
   
2. BufferedReader bufr = new BufferedReader(new FileReader(""));
   
3. BufferedWriter bufw = new BufferedWriter(new FileWriter(""));
   
4. String line = null;
   
5. while ((line = bufr.readLine()) != null) {
   
6. bufw.write(line);
   
7. bufw.newLine();
   
8. bufw.flush();
   
9. =======================
   
10. FileWriter fw = new FileWriter("");
    
11. FileReader  fr = new FileReader("");
    
12.    char[] buf = new char[1024];
    
13.    int len = 0;
    
14.    while ((len = fr.read(buf)) != -1) {
    
15.     fw.write(buf, 0, len);
    
16.    }
    

复制代码

这两段代码应该是都提高了效率，我觉得还是下面的好一点，缓冲到底是神马东西！！

在IO流中用缓冲区可以降低读写文件的开销，
用了缓冲区，其实也就是可以直接从缓冲区中将指定文件读写，可以提高读写效率
通常 Reader 所作的每个读取请求都会导致对底层字符或字节流进行相应的读取请求
建议用 BufferedReader 包装所有其 read() 操作可能开销很高的 Reader，如 FileReader
所以是上面的那个程序效率比较高

上面那段代码，是java自己给封装好的带缓冲区的字符读取和写入流对象，既然是自己封装好的提供的对象肯定比我们自己写的好的多。下面是将一个字符数组作为一个缓冲区。你从文件中每读取1024个字符就存到这个字符数组中，存完后，再将数组中的数据写入到写入流中去，如果有一大段的文字，每次转1024个字符进去，再将这个字符写入。while循环只需循环几次就可以将数据写完。但是如果不用缓冲那就是每次读取一个字符再写，要循环很多次。很占用资源的。缓冲区就像一个中转站一样。先讲一大把数据放进去，再将中转站中的东西写如到流中。而不是直接每次将写入单个字符。很明显提高了效率

//以前,我们读写文件,是从硬盘--读到内存----再写到硬盘里的
//Buffered(缓冲区)是:从硬盘---读到缓冲区----再读到内存里---再写到缓冲区里----再写到硬盘里.只是起到一个过度的作用,只是是觉得很麻烦,呵呵.
//是这样的,因为,从硬盘直接读取到内存很慢,而从缓冲区读到内存很快.
//或许你又会问,不还是要从硬盘读到缓冲区么?不也慢么?是这样的,缓冲区,一次性就从硬盘读取8192个字节,所以....
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileNotFoundException;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class Demo12 {
        public static void main(String[] args) throws IOException {
                demo1();
                BufferedReader br = new BufferedReader(new FileReader("a.txt"));                       
                BufferedWriter bw = new BufferedWriter(new FileWriter("c.txt"));
                String  line = null;
                while((line = br.readLine()) != null) {
                        bw.write(line);
                        bw.flush();
                        bw.newLine();
                }
                br.close();                                                                                                                                        //看到你的代码没有关流,记得要关流哦,很重要的,呵呵,因为会占用系统资源的
                bw.close();
        }

        private static void demo1() throws FileNotFoundException, IOException {
                FileReader fr = new FileReader("a.txt");
                FileWriter fw = new FileWriter("b.txt");
                char[] buffer = new char[1024];
                int len;
                while((len = fr.read(buffer)) != -1)
                        fw.write(buffer,0, len);
                fr.close();
                fw.close();
        }

}

缓冲，你可以当一个篮子。你现在要从教室往宿舍搬东西，但是你可以一样一样从教室拿到宿舍。就是我们说的一个一个读。也可以用篮子将东西全部装了拿回宿舍。这就是我们所说的用缓冲区来存储，然后一次写入。

付鑫鑫 发表于 2013-4-29 13:58
//以前,我们读写文件,是从硬盘--读到内存----再写到硬盘里的
//Buffered(缓冲区)是:从硬盘---读到缓冲区--- ...

。。谢谢   不是没有关流 是没有粘过来。

谭威 发表于 2013-4-29 13:11
上面那段代码，是java自己给封装好的带缓冲区的字符读取和写入流对象，既然是自己封装好的提供的对象肯定比 ...

那是不是 其实我上面写的2个代码都是起到了缓冲的作用，而buffered~什么的方法的底层其实就像我下面写的那么字符数组那样类似的起到了缓冲的作用啊

pthuakai 发表于 2013-4-29 15:20
缓冲，你可以当一个篮子。你现在要从教室往宿舍搬东西，但是你可以一样一样从教室拿到宿舍。就是我们说的一 ...

我下面写的那个没有buffered~的方法是不是也起到了缓冲的作用？用数组充当那个篮子？:)

本人已死 发表于 2013-4-29 15:49
那是不是 其实我上面写的2个代码都是起到了缓冲的作用，而buffered~什么的方法的底层其实就像我下面写的 ...

相当与把你下面写大那段包装了一下。这个是java里面的装饰模式。但是他提供的Buffered。。效率要高，而且还有特有的方法，比如BufferedReader的readLine()；一次读取一行数据，底层也是调用Reader的read方法，只是判断了是否有换行符号，有换行符号的话就一次写入。还有BufferedWriter的newLine()方法，可以写入数据的时候，调用这个方法空行。其实也就是所使用System.getProperty("line.speorator").这个方法，他给你封装好了。所以使用Buffered..要好些。

谭威 发表于 2013-4-29 15:57
相当与把你下面写大那段包装了一下。这个是java里面的装饰模式。但是他提供的Buffered。。效率要高，而且 ...

哎  什么破东西 这么简单点东西 他还给弄一个子类搞这么神秘  谢谢咧~万分感谢