BufferedReader的源码——带有缓冲区的字符流装饰器类
  在计算机中，文本是最普遍、最基础的数据交换格式，从日志文件到 JSON API，从数据库查询结果到机器学习训练集，文本无处不在。然而，原始的字符输入流（如 FileReader 或 InputStreamReader）每次读取操作都可能触发一次底层的系统调用，这对于需要逐行或逐字符处理的场景来说，性能开销是灾难性的。BufferedReader是自 Java 1.1 起就存在的用于文本处理的装饰器类，其内置的缓冲区char cb[]数组（默认长度是8192，占16k内存）可以保证使用者在调用readLine() 函数、read()函数时可以减少底层 IO 的操作次数，而不用让JVM在进行IO时每次都切换到操作系统的内核态进行一次昂贵的磁盘或网络 I/O。因此，也可以把BufferedReader叫做带有缓冲区的字符流装饰器类。
  BufferedReader.class 的UML关系图，如下所示：
image

BufferedReader.class 的源码，如下所示：

package java.io;

import java.util.Iterator;
import java.util.NoSuchElementException;
import java.util.Spliterator;
import java.util.Spliterators;
import java.util.stream.Stream;
import java.util.stream.StreamSupport;

public class BufferedReader extends Reader {
//被装饰的字符输入流
private Reader in;
//缓冲区数组，默认长度为8192
private char cb[];
//nChars，右指针，表示从被装饰的字符输入流中顺序读取到char cb[]（缓冲区数组）中的所有有效字符中的最后一个字符在char[] cb（缓冲区数组）的索引位置
//nextChar，左指针，表示当前将要从char[] cb（缓冲区数组）中读取的字符所在的索引位置，0<=nextChar<=nChars
private int nChars, nextChar;

//-2表示markedChar为无效标记时的状态
private static final int INVALIDATED = -2;
//-1表示markedChar为未标记时的状态
private static final int UNMARKED = -1;
//在char cb[]（缓冲区数组）中标记1个索引位置，在mark()函数中，设置markedChar = nextChar，-1和-2都表示没有在char[] cb（缓冲区数组）中做过标记。
private int markedChar = UNMARKED;
// 只有当markedChar > 0时，才有用，具体作用待补充
private int readAheadLimit = 0; 

//换行符标志，在windows操作系统下（换行符是'\r''\n'这2个字符的组合），当左指针nextChar指向的char[] cb（缓冲区数组）中的字符为'\n'时，skipLF=true，否则skipLF=false
private boolean skipLF = false;

//当使用mark()和reset()功能时，才有用，在mark()函数中，设置markedSkipLF = skipLF
private boolean markedSkipLF = false;
// 默认缓冲区（char[]字符数组）大小为8192 字节（16KB）
private static int defaultCharBufferSize = 8192;
//StringBuffer默认的长度，当使用readLine()函数时，先给StringBuffer设置默认长度为80，然后再从char[] cb（缓冲区数组）中读取字符到StringBuffer中来构成字符串
private static int defaultExpectedLineLength = 80;

//构造函数，需要传入一个被装饰的字符输入流和缓冲区（char[] cb数组）的长度
public BufferedReader(Reader in, int sz) {
    super(in);//设置Reader.class::lock变量指向的对象（锁）就是当前这个被装饰的字符输入流
    if (sz <= 0)//校验，缓冲区（char[]字符数组）的长度必须>0
        throw new IllegalArgumentException("Buffer size <= 0");
    this.in = in;
    cb = new char[sz];
    nextChar = nChars = 0;//设置右指针nChars=0，左指针nextChar=0
}

//构造函数，需要传入一个被装饰的字符输入流，缓冲区（char cb[]数组）的长度是8192（默认值，16KB）
public BufferedReader(Reader in) {
    this(in, defaultCharBufferSize);
}

//检查被装饰的字符输入流是否关闭
private void ensureOpen() throws IOException {
    if (in == null)
        throw new IOException("Stream closed");
}

//从被装饰的字符输入流向缓冲区（char[]数组）的[nextChar,nChars)索引位置填充(nChars-nextChar)个字符
private void fill() throws IOException {
    int dst;
    if (markedChar <= UNMARKED) {//如果还没有调用过mark()函数，那么markedChar=-1
        dst = 0;//dst=0，可以从缓冲区（char[]数组）的索引0的位置开始写入字符了
    } else {//如果调用过mark()函数，那么markedChar>=0
        int delta = nextChar - markedChar;
        if (delta >= readAheadLimit) {
            /* Gone past read-ahead limit: Invalidate mark */
            markedChar = INVALIDATED;
            readAheadLimit = 0;
            dst = 0;
        } else {
            if (readAheadLimit <= cb.length) {
                /* Shuffle in the current buffer */
                System.arraycopy(cb, markedChar, cb, 0, delta);
                markedChar = 0;
                dst = delta;
            } else {
                /* Reallocate buffer to accommodate read-ahead limit */
                char ncb[] = new char[readAheadLimit];
                System.arraycopy(cb, markedChar, ncb, 0, delta);
                cb = ncb;
                markedChar = 0;
                dst = delta;
            }
            nextChar = nChars = delta;
        }
    }

    int n;//从被装饰的字符输入流向缓冲区（char[]数组）中读入的字符数量
    do {
        //直接调用被装饰的字符输入流向缓冲区（char[]数组）的[dst,cb.length)索引位置读取cb.length - dst个字符
        //默认情况下就是从被装饰的字符输入流向缓冲区（char[]数组）的[0,8192)索引位置读取8192个字符（如果被装饰的字符输入流有8192个字符的话），然后返回实际读入的字符总数量n，0<=n<=8192
        n = in.read(cb, dst, cb.length - dst);
    } while (n == 0);
    if (n > 0) {
        //设置右指针nChars=dst + n，默认情况下就是设置nChars=n
        nChars = dst + n;
        //设置左指针nextChar=dst，默认情况下就是设置nextChar=0
        nextChar = dst;
    }
}

//函数内部做了线程同步，从缓冲区（char[]数组）中读取1个字符
public int read() throws IOException {
    synchronized (lock) {//用当前这个被装饰的字符输入流作为锁对象来同步线程
        ensureOpen();//检查被装饰的字符输入流是否关闭
        for (;;) {
            // 左指针nextChar >= 右指针nChars有以下2种情况
            //场景一：缓冲区（char[]数组）为空（还没有从被装饰的字符输入流中填充任何字符进去），nextChar = nChars =0
            //场景二：从被装饰的字符输入流向缓冲区（char[]数组）缓存的字符（如果被装饰的字符输入流有8192个字符的话，默认情况下是8192个字符）已经被读完了，nextChar = nChars = 缓存的有效字符中的最后一个字符在char[] cb（缓冲区数组）的索引位置
            if (nextChar >= nChars) {
                //场景一的情况下执行fill()函数是第一次从被装饰的输入流中读取字符填充缓冲区（char[]数组）
                //场景二的情况下执行fill()函数是再次从被装饰的输入流中读取字符重新填充缓冲区（char[]数组）
                fill();
                if (nextChar >= nChars)
                    //如果执行完fill()函数后，nextChar = nChars =0或者nextChar = nChars = 有效字符中的最后一个字符在char[] cb（缓冲区数组）的索引位置
                    //那么就说明被装饰的字符输入流和缓冲区（char[]数组）中的有效字符都已经被读取完了，返回-1
                    return -1;
            }
            if (skipLF) {
                //如果换行符标志skipLF=true的话，说明在windows操作系统下，前一个字符读到了'\r'，此处设置换行符标志skipLF=false
                skipLF = false;
                if (cb[nextChar] == '\n') {
                    //在windows操作系统下（换行符是'\r''\n'这2个字符的组合），如果前一个字符读到了'\r'，这里肯定会读到'\n'，那么直接跳过'\n'这个字符，继续读取下一行的字符
                    nextChar++;
                    continue;
                }
            }
            return cb[nextChar++];//windows操作系统下，非换行符'\r''\n'的情况下，正常读取左指针nextChar指向的字符
        }
    }
}

//从缓冲区（char[]数组）或被装饰的字符输入流（优先从缓冲区）中读取len个字符到使用者指定的char[]数组cbuf中，这len个字符被放到char[]数组cbuf的[off,off+len)索引位置。
//该函数只被read()函数调用
private int read1(char[] cbuf, int off, int len) throws IOException {
    // 左指针nextChar >= 右指针nChars有以下2种情况
    //场景一：缓冲区（char[]数组）为空（还没有从被装饰的字符输入流中填充任何字符进去），nextChar = nChars =0
    //场景二：从被装饰的字符输入流向缓冲区（char[]数组）缓存的字符（如果被装饰的字符输入流有8192个字符的话，默认情况下是8192个字符）已经被读完了，nextChar = nChars = 缓存的有效字符中的最后一个字符在char[] cb（缓冲区数组）的索引位置
    if (nextChar >= nChars) {
        if (len >= cb.length && markedChar <= UNMARKED && !skipLF) {
            //如果同时满足以下3个条件的话，则直接从被装饰的字符输入流中读取len个字符到使用者指定的char[]数组cbuf中，并返回从被装饰的字符输入流中实际读到的字符数量：
            //条件1：读取到使用者指定的char[]数组cbuf中的len个字符>=缓冲区（char[]数组）的长度
            //条件2：markedChar<=-1
            //条件3：skipLF=false
            return in.read(cbuf, off, len);
        }
        fill();//不满足以上3个条件的话，执行fill()函数
    }
    //如果执行此时左指针nextChar >= 右指针nChars的话，说明缓冲区（char[]数组）和被装饰的字符输入流中都已经没有可以读取的字符了，此时返回-1
    if (nextChar >= nChars) return -1;
    //有换行符的情况下，不会把换行符读取到使用者指定的char[]数组cbuf中，在windows操作系统下（换行符是'\r''\n'这2个字符的组合）
    if (skipLF) {
        //如果换行符标志skipLF=true的话，说明在windows操作系统下，前一个字符读到了'\r'，此处设置换行符标志skipLF=false
        skipLF = false;
        if (cb[nextChar] == '\n') {
            //在windows操作系统下（换行符是'\r''\n'这2个字符的组合），如果前一个字符读到了'\r'，这里肯定会读到'\n'，那么直接跳过'\n'这个字符，继续读取下一行的字符
            nextChar++;
            if (nextChar >= nChars)
                //跳过换行符之后如果左指针nextChar >= 右指针nChars（左右指针相遇），执行fill()函数填充缓冲区（char[]数组）
                fill();
            if (nextChar >= nChars)
                //如果执行完fill()函数并填充完缓冲区（char[]数组）之后，左指针nextChar >= 右指针nChars（左右指针仍然在一起），说明缓冲区（char[]数组）和被装饰的字符输入流中都已经没有可以读取的字符了，此时返回-1
                return -1;
        }
    }
    //nChars - nextChar表示缓冲区（char[]数组）中可以被读取的字符数量
    int n = Math.min(len, nChars - nextChar);
    //从缓冲区（char[]数组）的左指针nextChar索引开始，读取len或者（nChars-nextChar）（2者取其小）个字符到使用者指定的char[]数组cbuf的[off,off+n)索引位置（n就是len或者（nChars-nextChar）中2者取其小的值）
    System.arraycopy(cb, nextChar, cbuf, off, n);
    nextChar += n;//左指针nextChar向前移动len或者（nChars-nextChar）（2者取其小）个索引位置
    return n;//返回len或者（nChars-nextChar）（2者取其小）
}

//函数内部做了线程同步，从缓冲区（char[]数组）或者被装饰的字符输入流（优先从缓冲区）中读取len个字符到使用者指定的char[]数组cbuf中，这len个字符被放到char[]数组cbuf的[off,off+len)索引位置。
public int read(char cbuf[], int off, int len) throws IOException {
    //用当前这个被装饰的字符输入流作为锁对象来同步线程
    synchronized (lock) {
        ensureOpen();//检查被装饰的字符输入流是否关闭
        //检查[off,off+len)索引是否在使用者指定的char[]数组cbuf中，因为要读取len个字符到char[]数组cbuf的[off,off+len)索引位置，所以，如果[off,off+len)索引位置不在使用者指定的char[]数组cbuf中的话，抛出一个IndexOutOfBoundsException异常
        if ((off < 0) || (off > cbuf.length) || (len < 0) ||
            ((off + len) > cbuf.length) || ((off + len) < 0)) {
            throw new IndexOutOfBoundsException();
        } else if (len == 0) {
            //如果要从缓冲区（char[]数组）中读取的len个字符==0时，返回0
            return 0;
        }
        //先从缓冲区（char[]数组）或者被装饰的字符输入流中读取len个字符到使用者指定的char[]数组cbuf中，如果从这2个地方读取不到任何字符到使用者指定的char[]数组cbuf中的话，返回-1，如果从这2个地方可以读取到字符的话，返回实际读取到的字符数量
        int n = read1(cbuf, off, len);
        //如果第一次就无法从缓冲区（char[]数组）中读取任何字符的话，则返回-1，在没有执行mark()函数和reset()函数的前提下，有以下2种情况：
        //场景一：左指针nextChar = 右指针nChars = 0，并且被装饰的字符输入流中已经没有任何可以读取的字符了
        //场景二：左指针nextChar = 右指针nChars = 有效字符中的最后一个字符在char[] cb（缓冲区数组）的索引位置，并且被装饰的字符输入流中已经没有任何可以读取的字符了
        if (n <= 0) return n;
        //如果第一次从缓冲区（char[]数组）或者被装饰的字符输入流中读取了n个字符到使用者指定的char[]数组cbuf中之后，并且n（第一次读取的字符数量） < len（要读取的目标字符数量）的话
        //继续从缓冲区（char[]数组）或者被装饰的字符输入流中读取字符，退出循环的条件有以下2个:
        //条件a、累计读取到了len（要读取的目标字符数量）个字符；
        //条件b、累计读取到了n（n<len）个字符，但是缓冲区（char[]数组）或者被装饰的字符输入流中已经没有可以被读取的字符了。
        while ((n < len) && in.ready()) {//从这里退出循环的话，符合条件a
            //每次从缓冲区（char[]数组）或者被装饰的字符输入流中读取的字符数量
            int n1 = read1(cbuf, off + n, len - n);
            if (n1 <= 0) break;//从这里退出循环的话符合条件b
            n += n1;
        }
        return n;//返回累计从缓冲区（char[]数组）或者被装饰的字符输入流中读取到使用者指定的char[]数组cbuf中的字符总数量
    }
}

//函数内部做了线程同步，从缓冲区（char[]数组）或者被装饰的字符输入流（优先从缓冲区）中读取一行字符，在windows操作系统下（换行符是'\r''\n'这2个字符的组合）
String readLine(boolean ignoreLF) throws IOException {
    //本次调用所读取的一行字符
    StringBuffer s = null;
    //本次将要读取的一行字符在缓冲区（char[]数组）中的起始索引位置
    int startChar;

    synchronized (lock) {//用当前这个被装饰的字符输入流作为锁对象来同步线程
        ensureOpen();//检查被装饰的字符输入流是否关闭
        //在windows操作系统上使用BufferedReader.class::readLine()函数时，ignoreLF永远=false，所以只有当换行符标志skipLF=true时，omitLF=true
        boolean omitLF = ignoreLF || skipLF;

    bufferLoop:
        for (;;) {
            // 左指针nextChar >= 右指针nChars有以下2种情况
            //场景一：缓冲区（char[]数组）为空（还没有从被装饰的字符输入流中填充任何字符进去），nextChar = nChars =0
            //场景二：从被装饰的字符输入流向缓冲区（char[]数组）缓存的字符（如果被装饰的字符输入流有8192个字符的话，默认情况下是8192个字符）已经被读完了，nextChar = nChars = 缓存的有效字符中的最后一个字符在char[] cb（缓冲区数组）的索引位置
            if (nextChar >= nChars)
                //场景一的情况下执行fill()函数是第一次从被装饰的输入流中读取字符填充缓冲区（char[]数组）
                //场景二的情况下执行fill()函数是再次从被装饰的输入流中读取字符重新填充缓冲区（char[]数组）
                fill();                
            if (nextChar >= nChars) { /* EOF */
                //标记点B
                //填充完缓冲区（char[]数组）之后，如果左指针nextChar >= 右指针nChars，则说明缓冲区（char[]数组）和被装饰的字符输入流中都已经没有可以读取的字符了，此时本次调用所读取的这一行StringBuffer对象有2中可能性
                //①、StringBuffer s != null 并且StringBuffer s中缓存了部分字符，将这个StringBuffer s对象通过toString()函数转换为字符串并返回
                //②、StringBuffer s == null 或者StringBuffer s中没有缓存任何字符，直接返回null
                if (s != null && s.length() > 0)
                    return s.toString();//满足条件①
                else
                    return null;//满足条件②
            }
            //读取一行字符时，这一行字符将要被读取结束的标志位（换行符）
            //true表示已经读取到了这一行的结束标志位（换行符），在windows操作系统下的换行符'\r''\n'，肯定是读到'\r'了
            //false表示还没有读取到了这一行的结束标志位（换行符）
            boolean eol = false;
            char c = 0;//在一行字符的读取过程中，当前读到的字符
            int i;//windows操作系统下用来找到换行符'\r'在缓冲区（char[]数组）中的索引位置

            /* Skip a leftover '\n', if necessary */
            if (omitLF && (cb[nextChar] == '\n'))//标记点A
                nextChar++;//windows操作系统下读到'\r'之后就要跳过'\n'（因为'\r''\n'合起来在windows操作系统中组成了换行符）
            skipLF = false;
            omitLF = false;

        charLoop:
            //在windows操作系统下开始找换行符'\r''\n'中的第1个字符'\r'在缓冲区（char[]数组）中的索引位置，这个索引位置用变量i表示，退出这个循环的条件有2个
            //条件a、找到第1个字符'\r'在缓冲区（char[]数组）中的索引位置之后；
            //条件b、当i（或者说左指针nextChar）==右指针nChars时。
            for (i = nextChar; i < nChars; i++) {
                c = cb[i];
                if ((c == '\n') || (c == '\r')) {
                    //找到第1个字符'\r'在缓冲区（char[]数组）中的索引位置之后，设置boolean eol = true，并结束循环
                    eol = true;
                    break charLoop;
                }
            }
            
            startChar = nextChar;//完整的一行字符在缓冲区（char[]数组）中的起始索引位置
            nextChar = i;//完整的一行字符的换行符'\r'在缓冲区（char[]数组）中的结束索引位置

            if (eol) {
                //读一个文件（被装饰的字符输入流）中非最后一行之前的其它所有行时，eol=true，会走下面的逻辑
                String str;
                if (s == null) {
                    //从缓冲区（char[]数组）中取出[startChar, i - startChar)索引位置的字符（一个文件（被装饰的字符输入流）中非最后一行之前的其它所有行）组成字符串
                    str = new String(cb, startChar, i - startChar);
                } else {
                    s.append(cb, startChar, i - startChar);
                    str = s.toString();
                }
                //将左指针nextChar+1，指向本次读取的一行字符中的第2个换行符'\n'（windows操作系统）在缓冲区（char[]数组）中的索引位置，以便下次在【标记点A】处直接跳过第2个换行符'\n'
                nextChar++;
                if (c == '\r') {
                    skipLF = true;//设置换行符标志skipLF=true，以便下次再【标记点A】处直接跳过第2个换行符'\n'
                }
                return str;//返回从缓冲区（char[]数组）中读取的这一行（非最后一行）字符
            }

            if (s == null)
                //读一个文件（被装饰的字符输入流）中的最后一行时，eol=false，会走下面的逻辑，构造一个默认长度为80的StringBuffer去拼接最后一行的所有字符
                s = new StringBuffer(defaultExpectedLineLength);
            //从缓冲区（char[]数组）中取出[startChar, i - startChar)索引位置的字符（一个文件（被装饰的字符输入流）中非最后一行）组成字符串，并且在上面的【标记点B】处的【条件①】中返回
            s.append(cb, startChar, i - startChar);
        }
    }
}

//windows操作系统下用BufferedReader对象从被装饰的字符输入流中读取一行字符的时候，一般只会用readLine()函数，而不会直接用readLine(boolean ignoreLF)函数
public String readLine() throws IOException {
    return readLine(false);
}

//函数内部做了线程同步，从缓冲区（char[]数组）或者被装饰的字符输入流（优先从缓冲区）中跳过n个字符，并返回实际从缓冲区（char[]数组）或者被装饰的字符输入流（优先从缓冲区）中跳过的字符数量
public long skip(long n) throws IOException {
    if (n < 0L) {
        throw new IllegalArgumentException("skip value is negative");
    }
    synchronized (lock) {//用当前这个被装饰的字符输入流作为锁对象来同步线程
        ensureOpen();//检查被装饰的字符输入流是否关闭
        //先将累计要从缓冲区（char[]数组）或者被装饰的字符输入流（优先从缓冲区）中跳过的字符数量进行一个备份，用来最后结算本次实际从缓冲区（char[]数组）或者被装饰的字符输入流（优先从缓冲区）中累计跳过的字符数量
        long r = n;
        while (r > 0) {//当备份的要从缓冲区（char[]数组）或者被装饰的字符输入流（优先从缓冲区）中跳过的字符数量>0时，才进入循环
            if (nextChar >= nChars)
                // 左指针nextChar >= 右指针nChars有以下2种情况
                //场景一：缓冲区（char[]数组）为空（还没有从被装饰的字符输入流中填充任何字符进去），nextChar = nChars =0；
                //场景二：已经从缓冲区（char[]数组）中跳过了(nChars-nextChar)个字符，但是(nChars-nextChar)<n（即已经跳过的字符数量不够n个），则接着从缓冲区（char[]数组）中跳过字符，但是需要从被装饰的字符输入流中继续向缓冲区（char[]数组）中填充字符。
                fill();
            if (nextChar >= nChars) /* EOF */
                //如果此时左指针nextChar >= 右指针nChars，说明缓冲区（char[]数组）或者被装饰的字符输入流中的所有字符都已经被跳过了，没有多余的字符可以继续跳过了（即文件和被装饰的字符输入流已经EOF了），那么，退出循环
                break;
            if (skipLF) {
                //windows操作系统下，如果这个时候刚好遇到了换行符'\n'（'\r'已经处理过了，因此这里的换行符标志skipLF=true），则先跳过这个换行符'\n'（这里的'\n'不计入将要跳过的字符总数量中，但是接下来windows操作系统的换行符'\r''\n'就要计入将要跳过的字符总数量中），并重新设置换行符标志skipLF=false
                skipLF = false;
                if (cb[nextChar] == '\n') {
                    nextChar++;//跳过这个换行符'\n'（这里的'\n'不计入将要跳过的字符总数量中，但是接下来windows操作系统的换行符'\r''\n'就要计入将要跳过的字符总数量中）
                }
            }
            //本次从缓冲区（char[]数组）中要跳过的(nChars-nextChar)个字符，这些被跳过的字符在缓冲区（char[]数组）的[nextChar,nChars)索引位置
            long d = nChars - nextChar;
            if (r <= d) {
                //如果r<=d，则将要跳过的n个字符都在缓冲区（char[]数组）中的[nextChar,nChars)索引位置，移动左指针nextChar=nextChar+r即可跳过这n个字符，完成本次skip()函数的调用
                nextChar += r;
                r = 0;//置备份的数量r=0，用来最后结算本次实际从缓冲区（char[]数组）或者被装饰的字符输入流（优先从缓冲区）中累计跳过的字符数量
                break;//并跳出循环
            }
            else {
                //如果r>d，则缓冲区（char[]数组）中的[nextChar,nChars)索引位置的(nChars-nextChar)个字符不够将要跳过的n个字符，则置备份的数量r=r-d；
                r -= d;
                //然后移动左指针nextChar=nChars，以便下次循环的时候满足【场景二】，可以从被装饰的字符输入流中继续向缓冲区（char[]数组）中填充字符，来继续跳过之前剩余还未跳过的(n-d)个字符
                nextChar = nChars;
            }
        }
        return n - r;//结算本次实际从缓冲区（char[]数组）或者被装饰的字符输入流（优先从缓冲区）中累计实际跳过的字符数量，并返回
    }
}

public boolean ready() throws IOException {
    synchronized (lock) {
        ensureOpen();

        /*
         * If newline needs to be skipped and the next char to be read
         * is a newline character, then just skip it right away.
         */
        if (skipLF) {
            /* Note that in.ready() will return true if and only if the next
             * read on the stream will not block.
             */
            if (nextChar >= nChars && in.ready()) {
                fill();
            }
            if (nextChar < nChars) {
                if (cb[nextChar] == '\n')
                    nextChar++;
                skipLF = false;
            }
        }
        return (nextChar < nChars) || in.ready();
    }
}

public boolean markSupported() {
    return true;
}

public void mark(int readAheadLimit) throws IOException {
    if (readAheadLimit < 0) {
        throw new IllegalArgumentException("Read-ahead limit < 0");
    }
    synchronized (lock) {
        ensureOpen();
        this.readAheadLimit = readAheadLimit;
        markedChar = nextChar;
        markedSkipLF = skipLF;
    }
}

public void reset() throws IOException {
    synchronized (lock) {
        ensureOpen();
        if (markedChar < 0)
            throw new IOException((markedChar == INVALIDATED)
                                  ? "Mark invalid"
                                  : "Stream not marked");
        nextChar = markedChar;
        skipLF = markedSkipLF;
    }
}

public void close() throws IOException {
    synchronized (lock) {
        if (in == null)
            return;
        try {
            in.close();
        } finally {
            in = null;
            cb = null;
        }
    }
}

//JDK8以后新增了流式编程的支持
public Stream<String> lines() {
    Iterator<String> iter = new Iterator<String>() {
        String nextLine = null;

        @Override
        public boolean hasNext() {
            if (nextLine != null) {
                return true;
            } else {
                try {
                    nextLine = readLine();
                    return (nextLine != null);
                } catch (IOException e) {
                    throw new UncheckedIOException(e);
                }
            }
        }

        @Override
        public String next() {
            if (nextLine != null || hasNext()) {
                String line = nextLine;
                nextLine = null;
                return line;
            } else {
                throw new NoSuchElementException();
            }
        }
    };
    return StreamSupport.stream(Spliterators.spliteratorUnknownSize(
            iter, Spliterator.ORDERED | Spliterator.NONNULL), false);
}

}