BufferedWriter 和 BufferedReader 的基本用法

BufferedWriter 和 BufferedReader 为带有默认缓冲的字符输出输入流，因为有缓冲区所以很效率比没有缓冲区的很高。

一、BufferedWriter 类

构造方法：bufferedWriter bf = new bufferedWriter(Writer out );

主要方法：void write(char ch);//写入单个字符。

                  void write(char []cbuf,int off,int len)//写入字符数据的某一部分。

                  void write(String s,int off,int len)//写入字符串的某一部分。

                  void newLine()//写入一个行分隔符。

                  void flush();//刷新该流中的缓冲。将缓冲数据写到目的文件中去。

                  void close();//关闭此流，再关闭前会先刷新他。

[java]
view plain
copy

print
?

1. package Buffered;  
2.   
3. import java.io.BufferedWriter;  
4. import java.io.FileWriter;  
5. import java.io.IOException;  
6.   
7. public class BufferedWriterDemo {  
8.     public static void main(String[] args) throws IOException {  
9.         FileWriter fw = new FileWriter(“Buffered.txt”);  
10. //      fw.write(“ok168”);  
11. //      fw.close();  
12.         /** 
13.          * 为了提高写入的效率，使用了字符流的缓冲区。 
14.          * 创建了一个字符写入流的缓冲区对象，并和指定要被缓冲的流对象相关联。 
15.          */  
16.         BufferedWriter bufw = new BufferedWriter(fw);  
17.           
18.         //使用缓冲区中的方法将数据写入到缓冲区中。  
19.         bufw.write(”hello world !”);  
20.         bufw.newLine();  
21.         bufw.newLine();  
22.         bufw.write(”!hello world !”);  
23.         bufw.write(”!hello world !”);  
24.         //使用缓冲区中的方法，将数据刷新到目的地文件中去。  
25.         bufw.flush();  
26.         //关闭缓冲区,同时关闭了fw流对象  
27.         bufw.close();     
28.     }  
29. }  

package Buffered;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedWriterDemo {
    public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("Buffered.txt");
//      fw.write("ok168");
//      fw.close();
        /**
         * 为了提高写入的效率，使用了字符流的缓冲区。
         * 创建了一个字符写入流的缓冲区对象，并和指定要被缓冲的流对象相关联。
         */
        BufferedWriter bufw = new BufferedWriter(fw);

        //使用缓冲区中的方法将数据写入到缓冲区中。
        bufw.write("hello world !");
        bufw.newLine();
        bufw.newLine();
        bufw.write("!hello world !");
        bufw.write("!hello world !");
        //使用缓冲区中的方法，将数据刷新到目的地文件中去。
        bufw.flush();
        //关闭缓冲区,同时关闭了fw流对象
        bufw.close();   
    }
}

二、BufferedReader类。

构造方法：BufferedReader br = new BufferReader(Reader in);

主要方法：int read();//读取单个字符。

                  int read(char[] cbuf,int off,int len);//将字符读入到数组的某一部分。返回读取的字符数。达到尾部 ，返回-1。

                  String readLine();                        //读取一个文本行。

                  void close();                                //关闭该流。并释放与该流相关的所有资源。

[java]
view plain
copy

print
?

1. package Buffered;  
2.   
3. import java.io.BufferedWriter;  
4. import java.io.FileWriter;  
5. import java.io.IOException;  
6.   
7. public class BufferedWriterDemo {  
8.     public static void main(String[] args) throws IOException {  
9.         FileWriter fw = new FileWriter(“Buffered.txt”);  
10. //      fw.write(“ok168”);  
11. //      fw.close();  
12.         /** 
13.          * 为了提高写入的效率，使用了字符流的缓冲区。 
14.          * 创建了一个字符写入流的缓冲区对象，并和指定要被缓冲的流对象相关联。 
15.          */  
16.         BufferedWriter bufw = new BufferedWriter(fw);  
17.           
18.         //使用缓冲区中的方法将数据写入到缓冲区中。  
19.         bufw.write(”hello world !”);  
20.         bufw.newLine();  
21.         bufw.newLine();  
22.         bufw.write(”!hello world !”);  
23.         bufw.write(”!hello world !”);  
24.         //使用缓冲区中的方法，将数据刷新到目的地文件中去。  
25.         bufw.flush();  
26.         //关闭缓冲区,同时关闭了fw流对象  
27.         bufw.close();     
28.     }  
29. }  

package Buffered;

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedWriterDemo {
    public static void main(String[] args) throws IOException {
        FileWriter fw = new FileWriter("Buffered.txt");
//      fw.write("ok168");
//      fw.close();
        /**
         * 为了提高写入的效率，使用了字符流的缓冲区。
         * 创建了一个字符写入流的缓冲区对象，并和指定要被缓冲的流对象相关联。
         */
        BufferedWriter bufw = new BufferedWriter(fw);

        //使用缓冲区中的方法将数据写入到缓冲区中。
        bufw.write("hello world !");
        bufw.newLine();
        bufw.newLine();
        bufw.write("!hello world !");
        bufw.write("!hello world !");
        //使用缓冲区中的方法，将数据刷新到目的地文件中去。
        bufw.flush();
        //关闭缓冲区,同时关闭了fw流对象
        bufw.close();   
    }
}

自定义的一个myBufferedReader类。

[java]
view plain
copy

print
?

1. package Buffered;  
2.   
3. import java.io.FileReader;  
4. import java.io.IOException;  
5.   
6. public class MyBufferedReader {  
7.       
8.     private FileReader fr;  
9.     private char []buf = new char[1024];  
10.     private int count = 0;  
11.     private int pos = 0;  
12.     public MyBufferedReader(FileReader f){  
13.         this.fr = f;          
14.     }  
15.     public int myRead() throws IOException{  
16.         if(count == 0){  
17.             count = fr.read(buf);  
18.             pos = 0;  
19.         }  
20.         if(count<0)  
21.             return –1;  
22.         int ch = buf[pos++];  
23.         count–;  
24.         return ch;   
25.     }  
26.       
27.     public String myReadLine() throws IOException{  
28.         StringBuilder sb = new StringBuilder();  
29.         int ch = 0;  
30.         while ((ch = myRead()) != –1) {  
31.             if (ch == ‘\r’)  
32.                 continue;  
33.             if (ch == ‘\n’)  
34.                 return sb.toString();  
35.             sb.append((char) ch);  
36.             if(count == 0)  
37.                 return sb.toString();             
38.         }  
39.         return null;  
40.     }  
41.     public void myClose() throws IOException {  
42.         fr.close();  
43.     }  
44. }  

package Buffered;

import java.io.FileReader;
import java.io.IOException;

public class MyBufferedReader {

    private FileReader fr;
    private char []buf = new char[1024];
    private int count = 0;
    private int pos = 0;
    public MyBufferedReader(FileReader f){
        this.fr = f;        
    }
    public int myRead() throws IOException{
        if(count == 0){
            count = fr.read(buf);
            pos = 0;
        }
        if(count<0)
            return -1;
        int ch = buf[pos++];
        count--;
        return ch; 
    }

    public String myReadLine() throws IOException{
        StringBuilder sb = new StringBuilder();
        int ch = 0;
        while ((ch = myRead()) != -1) {
            if (ch == '\r')
                continue;
            if (ch == '\n')
                return sb.toString();
            sb.append((char) ch);
            if(count == 0)
                return sb.toString();           
        }
        return null;
    }
    public void myClose() throws IOException {
        fr.close();
    }
}

使用bufferedReader 和bufferWriter方法写的一个复制文本的小程序。

[java]
view plain
copy

print
?

1. package IOtest;  
2.   
3. import java.io.BufferedReader;  
4. import java.io.BufferedWriter;  
5. import java.io.FileReader;  
6. import java.io.FileWriter;  
7. import java.io.IOException;  
8.   
9. public class TextCopyByBuf {  
10.   
11.     /** 
12.      * 首先创建读取字符数据流对象关联所要复制的文件。 
13.      * 创建缓冲区对象关联流对象。 
14.      * 从缓冲区中将字符创建并写入到要目的文件中。 
15.      * @throws IOException  
16.      */  
17.     public static void main(String[] args) throws IOException {  
18.         FileReader fr = new FileReader(“C:\\demo.txt”);  
19.         FileWriter fw = new FileWriter(“D:\\love.txt”);  
20.         BufferedReader bufr = new BufferedReader(fr);  
21.         BufferedWriter bufw = new BufferedWriter(fw);  
22.         //一行一行的寫。  
23.         String line = null;  
24.         while((line = bufr.readLine()) != null){  
25.             bufw.write(line);  
26.             bufw.newLine();  
27.             bufw.flush();  
28.         }  
29.     /*  一個字節一個字節的寫。 
30.         int ch = 0; 
31.         while((ch = bufr.read())!=-1){
     
32.             bufw.write(ch); 
33.         }*/  
34.         bufr.close();  
35.         bufw.close();  
36.     }  
37. }  

package IOtest;

import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileReader;
import java.io.FileWriter;
import java.io.IOException;

public class TextCopyByBuf {

    /**
     * 首先创建读取字符数据流对象关联所要复制的文件。
     * 创建缓冲区对象关联流对象。
     * 从缓冲区中将字符创建并写入到要目的文件中。
     * @throws IOException 
     */
    public static void main(String[] args) throws IOException {
        FileReader fr = new FileReader("C:\\demo.txt");
        FileWriter fw = new FileWriter("D:\\love.txt");
        BufferedReader bufr = new BufferedReader(fr);
        BufferedWriter bufw = new BufferedWriter(fw);
        //一行一行的寫。
        String line = null;
        while((line = bufr.readLine()) != null){
            bufw.write(line);
            bufw.newLine();
            bufw.flush();
        }
    /*  一個字節一個字節的寫。
        int ch = 0;
        while((ch = bufr.read())!=-1){
            bufw.write(ch);
        }*/
        bufr.close();
        bufw.close();
    }
}