JAVA基础 | IO之BufferedReader与BufferedWriter

IO系列文章目录

前言

当我们明确了要操作的是数据是字符，Reader与Writer就是称为我们一个很好的选择，如果我们需要高效性，引入缓存区，那我们就可以选择BufferedReader与BufferedWriter，接下来我们来看一下他们的区别与使用

提示：以下是本篇文章正文内容

一、BufferedWriter

1. 简介

将文本写入字符输出流，缓存字符以便有效的写入单个字符，数组和字符串

2. 构造方法

 /**
     * Creates a buffered character-output stream that uses a default-sized
     * output buffer.
     * 创建一个缓存字符输出流，使用默认大小的输出。
     * @param  out  A Writer
     */
    public BufferedWriter(Writer out) {
        this(out, defaultCharBufferSize);
    }
    
    /**
     * Creates a new buffered character-output stream that uses an output
     * buffer of the given size.
     *  创建一个新的缓存字符输出流
     * @param  out  A Writer
     * @param  sz   Output-buffer size, a positive integer
     *
     * @exception  IllegalArgumentException  If {@code sz <= 0}
     */
    public BufferedWriter(Writer out, int sz) {
        super(out);
        if (sz <= 0)
            throw new IllegalArgumentException("Buffer size <= 0");
        this.out = out;
        cb = new char[sz];
        nChars = sz;
        nextChar = 0;

        lineSeparator = java.security.AccessController.doPrivileged(
            new sun.security.action.GetPropertyAction("line.separator"));
    }

3. 涉及变量

private Writer out;
//传入的字符数组
private char cb[];
private int nChars, nextChar;
//默认输出大小
private static int defaultCharBufferSize = 8192;
//行分隔符字符串
private String lineSeparator;

4. 涉及方法

 /** Checks to make sure that the stream has not been closed 
    检查确认流已经被关闭
    */
    private void ensureOpen() throws IOException {
        if (out == null)
            throw new IOException("Stream closed");
    }
        
    
    /**
     * Flushes the output buffer to the underlying character stream, without
     * flushing the stream itself.  This method is non-private only so that it
     * may be invoked by PrintStream.
     * 将输出缓冲区刷新到底层字符流，无需冲洗洗* 流本身。这个方法是非私有的可由PrintStrea* m调用
     */
    void flushBuffer() throws IOException {
        synchronized (lock) {
            ensureOpen();
            if (nextChar == 0)
                return;
            out.write(cb, 0, nextChar);
            nextChar = 0;
        }
    }
    
    /**
     * Writes a single character.
     * 写入单个字符
     * @exception  IOException  If an I/O error occurs
     */
    public void write(int c) throws IOException {
        synchronized (lock) {
            ensureOpen();
            if (nextChar >= nChars)
                flushBuffer();
            cb[nextChar++] = (char) c;
        }
    }
    
    /**
     * Writes a portion of an array of characters.
     * 写入一个数组
     */
    public void write(char cbuf[], int off, int len) throws IOException {
        synchronized (lock) {
            ensureOpen();
            if ((off < 0) || (off > cbuf.length) || (len < 0) ||
                ((off + len) > cbuf.length) || ((off + len) < 0)) {
                throw new IndexOutOfBoundsException();
            } else if (len == 0) {
                return;
            }

            if (len >= nChars) {
                /* If the request length exceeds the size of the output buffer,
                   flush the buffer and then write the data directly.  In this
                   way buffered streams will cascade harmlessly. */
                flushBuffer();
                out.write(cbuf, off, len);
                return;
            }

            int b = off, t = off + len;
            while (b < t) {
                int d = min(nChars - nextChar, t - b);
                System.arraycopy(cbuf, b, cb, nextChar, d);
                b += d;
                nextChar += d;
                if (nextChar >= nChars)
                    flushBuffer();
            }
        }
    }
    
    /**
     * Writes a portion of a String.
     * 写入一个字符串
     */
    public void write(String s, int off, int len) throws IOException {
        synchronized (lock) {
            ensureOpen();

            int b = off, t = off + len;
            while (b < t) {
                int d = min(nChars - nextChar, t - b);
                s.getChars(b, b + d, cb, nextChar);
                b += d;
                nextChar += d;
                if (nextChar >= nChars)
                    flushBuffer();
            }
        }
    }
    /**
     * 换行符
     **/
    public void newLine() throws IOException {
        write(lineSeparator);
    }
    
    /**
     * Flushes the stream.
     * 刷新流
     * @exception  IOException  If an I/O error occurs
     */
    public void flush() throws IOException {
        synchronized (lock) {
            flushBuffer();
            out.flush();
        }
    }
    
    public void close() throws IOException {
        synchronized (lock) {
            if (out == null) {
                return;
            }
            try (Writer w = out) {
                flushBuffer();
            } finally {
                out = null;
                cb = null;
            }
        }
    }

二、 BufferedReader

1. 简介

Reads text from a character-input stream, buffering characters so as to provide for the efficient reading of characters, arrays, and lines.

将字符输出流中读取文本，缓存字符读出，以便有效的读出单个字符，数组和字符串

2. 构造方法

//默认缓冲字符大小8192
private static int defaultCharBufferSize = 8192;

//创建一个使用指定大小输入缓冲区的缓冲字符输入流。
public BufferedReader(Reader in, int sz) {
        super(in);
        if (sz <= 0)
            throw new IllegalArgumentException("Buffer size <= 0");
        this.in = in;
        cb = new char[sz];
        nextChar = nChars = 0;
    }
    
public BufferedReader(Reader in) {
        this(in, defaultCharBufferSize);
    }    

3. 涉及变量

    private Reader in;

    private char cb[];
    private int nChars, nextChar;

    private static final int INVALIDATED = -2;
    private static final int UNMARKED = -1;
    private int markedChar = UNMARKED;
    private int readAheadLimit = 0; /* Valid only when markedChar > 0 */

    /** If the next character is a line feed, skip it */
    private boolean skipLF = false;

    /** The skipLF flag when the mark was set */
    private boolean markedSkipLF = false;

    private static int defaultCharBufferSize = 8192;
    private static int defaultExpectedLineLength = 80;

4. 涉及方法

  //读取单字符
public int read() throws IOException {
        synchronized (lock) {
            ensureOpen();
            for (;;) {
                if (nextChar >= nChars) {
                    fill();
                    if (nextChar >= nChars)
                        return -1;
                }
                if (skipLF) {
                    skipLF = false;
                    if (cb[nextChar] == '\n') {
                        nextChar++;
                        continue;
                    }
                }
                return cb[nextChar++];
            }
        }
    }
//读取数组
int read1(char[] cbuf, int off, int len){
    ...
}

//读取一个文本行，默认false
String readLine(boolean ignoreLF) throws IOException {
    ...
}

//跳过几个
long skip(long n)

//判断该流是否确认被读取
boolean ready()

//标记流中当前位置
mark

//重置当前流
void reset()

三、举例

private static void systemIn(File file) throws IOException {
        //接受键盘输入的数据，以缓存字节读取方式从标准IO（键盘）中读取数据，所以要先把标准IO（System.in）转换成字符导向的stream
        Reader reader = new InputStreamReader(System.in);
        BufferedReader bufferedReader = new BufferedReader(reader);
        System.out.println("请输入：");
        String str = bufferedReader.readLine();;
        System.out.println("SystemIn:"+str);
        System.out.println("输入q结束");
        int ff;
        do{
            ff = bufferedReader.read();
            System.out.println((char)ff);
        }while (ff != 'q');

        //从String中读取对象
        StringReader in2 = new StringReader(str);
        int c;
        StringBuilder string = new StringBuilder();
        while ((c = in2.read()) != -1){
            string.append((char) c + "\n");
            System.out.println("String:"+(char)c);
        }

        //读取单个字节
        InputStreamReader inputStreamReader = new FileReader(file);
        BufferedReader bufferedReader1 = new BufferedReader(inputStreamReader);
        char[] chars = new char[5];
        while (bufferedReader1.read(chars,0,chars.length) != -1){
            string.append(String.valueOf(chars)).append("\n");
            System.out.println("chars:"+String.valueOf(chars));
        }

        reader.close();
        bufferedReader.close();

        Writer writer = new OutputStreamWriter(new FileOutputStream(file));
        BufferedWriter bufferedWriter = new BufferedWriter(writer);
        bufferedWriter.write(str);
        bufferedWriter.write(string.toString());
        bufferedWriter.write(str);
        bufferedWriter.close();

    }