BufferedWriter与BufferedReader

最新推荐文章于 2021-02-02 23:15:25 发布

weixin_34009794

最新推荐文章于 2021-02-02 23:15:25 发布

阅读量64

点赞数

原文链接：http://www.cnblogs.com/feiZhou/p/9344470.html

版权

    |--字符流（ 字符流 = 字节流 +编码表。）
            |--字符输入流
                Reader                                   ------抽象类 
                    int read():一次读取一个字符
                    int read(char[] chs):一次读取一个字符数组

                    |--InputStreamReader                 ------extends  Reader
                        InputStreamReader = FileInputStream + 编码表(GBK)
                        |--FileReader                    ------extends InputStreamReader
                            FileReader = FileInputStream + 编码表(GBK)


                    |--BufferedReader                    ------extends  Reader
                        String readLine():一次读取一个字符串

                    |--StringReader                      ------extends  Reader

            |--字符输出流
                Writer                                   ------抽象类 
                    void write(int ch):一次写一个字符
                    void write(char[] chs,int index,int len):一次写一个字符数组的一部分

                    |--OutputStreamWriter                ------extends Writer
                            OutputStreamWriter = FileOutputStream + 编码表(GBK)
                        |--FileWriter                    ------extends OutputStreamWriter
                            FileWriter = FileOutputStream + 编码表(GBK)

                    |--BufferedWriter                    ------extends Writer
                        void newLine():写一个换行符
                        void write(String line):一次写一个字符串

                    |--PrintWriter                       ------extends Writer
                    |--StringWriter                      ------extends Writer

BufferedWriter
将文本写入字符输出流，缓冲各个字符，从而提供单个字符、数组和字符串的高效写入。

可以指定缓冲区的大小，或者接受默认的大小。在大多数情况下，默认值就足够大了。

该类提供了 newLine() 方法，它使用平台自己的行分隔符概念，此概念由系统属性 line.separator 定义。并非所有平台都使用新行符 (‘\n’) 来终止各行。因此调用此方法来终止每个输出行要优于直接写入新行符。

通常 Writer 将其输出立即发送到底层字符或字节流。除非要求提示输出，否则建议用 BufferedWriter 包装所有其 write() 操作可能开销很高的 Writer（如 FileWriters 和 OutputStreamWriters）。例如，

PrintWriter out
= new PrintWriter(new BufferedWriter(new FileWriter(“foo.out”)));
将缓冲 PrintWriter 对文件的输出。如果没有缓冲，则每次调用 print() 方法会导致将字符转换为字节，然后立即写入到文件，而这是极其低效的。

构造方法：
BufferedWriter(Writer out) 创建一个使用默认大小输出缓冲区的缓冲字符输出流。
BufferedWriter(Writer out, int sz) 创建一个使用给定大小输出缓冲区的新缓冲字符输出流。

常用方法：

void close() 关闭此流，但要先刷新它。
void flush() 刷新该流的缓冲。
void newLine() 写入一个行分隔符。
void write(char[] cbuf) 写入字符数组。
void write(char[] cbuf, int off, int len) 写入字符数组的某一部分。
void write(int c) 写入单个字符。
void write(String s) 写入字符串。
void write(String s, int off, int len) 写入字符串的某一部分。

        BufferedWriter bw = new BufferedWriter(new FileWriter("test.txt"));
        char[] arr=new char[]{'q','w','e'};
        //单个字符
        bw.write("a");
        bw.newLine();
        //单个字符
        bw.write(98);
        bw.newLine();
        //写入字符数组的某一部分
        bw.write(arr,0,2);
        bw.newLine();
        //写入字符串
        bw.write("fff");
        bw.newLine();
        //写入字符串的某一部分
        bw.write("fff",0,2);
        bw.newLine();

        bw.flush();
        bw.close();
输出：test.txt
a
b
qw
fff
ff

BufferedReader:

从字符输入流中读取文本，缓冲各个字符，从而实现字符、数组和行的高效读取。

可以指定缓冲区的大小，或者可使用默认的大小。大多数情况下，默认值就足够大了。

通常，Reader 所作的每个读取请求都会导致对底层字符或字节流进行相应的读取请求。因此，建议用 BufferedReader 包装所有其 read() 操作可能开销很高的 Reader（如 FileReader 和 InputStreamReader）。
例如，
BufferedReader in = new BufferedReader(new FileReader(“foo.in”));
将缓冲指定文件的输入。如果没有缓冲，则每次调用 read() 或 readLine() 都会导致从文件中读取字节，并将其转换为字符后返回，而这是极其低效的。
通过用合适的 BufferedReader 替代每个 DataInputStream，可以对将 DataInputStream 用于文字输入的程序进行本地化。

构造方法
BufferedReader(Reader in) 创建一个使用默认大小输入缓冲区的缓冲字符输入流。
BufferedReader(Reader in, int sz) 创建一个使用指定大小输入缓冲区的缓冲字符输入流。

常用方法

void close() 关闭该流并释放与之关联的所有资源。
int read() 读取单个字符。
int read(char[] cbuf, int off, int len) 将字符读入数组的某一部分。
String readLine() 一次读取一行数据包含该行内容的字符串，不包含任何行终止符，如果已到达流末尾，则返回 null
void mark(int readAheadLimit) 标记流中的当前位置。
boolean markSupported() 判断此流是否支持 mark() 操作（它一定支持）。
boolean ready() 判断此流是否已准备好被读取。
void reset() 将流重置到最新的标记。
long skip(long n) 跳过字符。

    // 创建字符缓冲输入流对象
        BufferedReader br = new BufferedReader(new FileReader("test.txt"));

         //方式1
        System.out.println("------------方式1-------------");
         int ch = 0;
         while ((ch = br.read()) != -1) {
         System.out.print((char) ch);
         }

        // 方式2 效率比方式1高
         System.out.println();
         System.out.println("------------方式2-------------");
         BufferedReader br2 = new BufferedReader(new FileReader("test.txt"));
        char[] chs = new char[1024];
        int len = 0;
        while ((len = br2.read(chs)) != -1) {
            System.out.print(new String(chs, 0, len));
        }
        // 方式3  效率比方式2高
        System.out.println("------------方式3-------------");
        BufferedReader br3 = new BufferedReader(new FileReader("test.txt"));
        String line = null;
        while ((line = br3.readLine()) != null) {
            System.out.println(line);
        }
        // 释放资源
        br.close();
        br2.close();
        br3.close();
输出：
------------方式1-------------
a
b
qw
fff
ff

------------方式2-------------
a
b
qw
fff
ff
------------方式3-------------
a
b
qw
fff
ff