、Reader.class源码
Reader 是用来读取字符流的装饰器模式中顶层的抽象类，与 InputStream（字节流）不同的是，Reader 专门处理字符char（字符char在JVM中使用Unicode编码占2个byte），主要用于读取和写入中文文本。
windows操作系统的JDK8版本中，所有的Reader的子类如下（此处只展示部分）：
常用的Reader子类有以下5个：
①、InputStreamReader：处理文件的字符输入流，在进行文件读操作时，如果遇到不同编码格式，可以使用 InputStreamReader 进行处理。
②、BufferedReader ：类似于 BufferedInputStream ，不同点在于BufferedReader 读取的是字符char，BufferedInputStream读取的是字节byte，其内部也带有一个缓冲区（1个char[]数组），一般用BufferedReader来配合其它字符输入流一起使用来减少IO次数，也可以使用mark()函数和 reset()函数重复从缓冲区（1个char[]数组）中读取字符。
③、PushbackReader：以将已读取的字符（char）重新推回输入流中。这样，下次调用read()函数时，这些字符（char）就会再次被读取。因此，PushbackReader可以从输入流中解析字符（char）数据。
④、StringReader：如果输入源是一个字符串的，可以使用 StringReader 来将一个字符串转换为字符流。
以上4个子类的使用方式请参照：
1、Java的IO概览（一）
2、Java的IO概览（二）
Reader.class的源码如下：
package java.io; public abstract class Reader implements Readable, Closeable { //当这个字符输入流进行read操作、skip操作的时候，用这个对象（锁）来同步线程，来保证多线程场景下操作这个字符输入流时的线程安全性。 //这个锁对象既可以是Reader.class类型对象本身，也可以是其它类型的对象，但是最有效的同步方式是，在使用synchronized锁定同步代码块的时候，一定要用lock变量指向的锁对象，而不是将synchronized加到函数上面或者用this关键字同步，推荐的用法详情请看skip()函数 //推荐的同步方式如下： /** * public long skip(long n) throws IOException { * ...省略部分代码... * synchronized (lock) { * if ((skipBuffer == null) || (skipBuffer.length < nn)) * skipBuffer = new char[nn]; * long r = n; * while (r > 0) { * int nc = read(skipBuffer, 0, (int)Math.min(r, nn)); * if (nc == -1) * break; * r -= nc; * } * return n - r; * } *} * */ //以下2种方式不推荐 //不推荐的同步方式①：将synchronized关键字加到函数上面 /** * public synchronized long skip(long n) throws IOException { * ...省略部分代码... * */ //不推荐的同步方式②：将lock改成this关键字 /** * public long skip(long n) throws IOException { * ...省略部分代码... * synchronized (this) { * if ((skipBuffer == null) || (skipBuffer.length < nn)) * skipBuffer = new char[nn]; * long r = n; * while (r > 0) { * int nc = read(skipBuffer, 0, (int)Math.min(r, nn)); * if (nc == -1) * break; * r -= nc; * } * return n - r; * } *} * */ protected Object lock; //构造函数，并将用于多线程场景下线程同步的lock变量指向this（当前这个字符输入流对象）本身 protected Reader() { this.lock = this; } //构造函数，并将用于多线程场景下线程同步的lock变量指向其它对象而不是this（当前这个字符输入流对象）本身 protected Reader(Object lock) { if (lock == null) { throw new NullPointerException(); } this.lock = lock; } //将从字符输入流中读取n个字符放入到NIO中的CharBuffer对象（字符缓冲区对象）里面 //当CharBuffer对象（字符缓冲区对象）中可用的空间>0时，这个函数是阻塞的，直到读取到数据或者抛出异常。 public int read(java.nio.CharBuffer target) throws IOException { int len = target.remaining();//计算NIO中的CharBuffer对象（字符缓冲区对象）中还可以放多少个字符（可用的空间） char[] cbuf = new char[len];//构建一个长度为len的字符数组char[]，len表示CharBuffer对象（字符缓冲区对象）中还可以放的字符数量 int n = read(cbuf, 0, len);//从字符输入流中读取len个字符放到字符数组char[] cbuf的[0,len)索引位置，并返回从字符输入流中读取到的字符数量 if (n > 0) //如果从字符输入流中读取到的字符数量>0，则将这些字符（假设有n个字符，0<n<=len）都放入到CharBuffer对象（字符缓冲区对象）中 target.put(cbuf, 0, n); return n;//返回n，这里的n取值范围为0<=n<=len，或者[0,len] } //将从字符输入流中读取1个字符 //和InputStream一样，在读取到数据或者抛出异常前，这个函数是阻塞的。 public int read() throws IOException { char cb[] = new char[1];//构建一个长度为1的字符数组char[] cb //将从字符输入流中读取1个字符放入到字符数组char[] cb的[0,1)索引位置，如果字符输入流已经读完了（即已经读取到了文件的EOF符号），则会返回-1，read(cb, 0, 1)函数是留给子类实现的 if (read(cb, 0, 1) == -1) return -1;//如果字符输入流已经读完了（即已经读取到了文件的EOF符号），则返回-1 else return cb[0];//否则，返回读取到的字符 } //将从字符输入流中读取length个字符到字符数组char[] cbuf中，length表示字符数组char[] cbuf的长度 //和InputStream一样，在读取到数据或者抛出异常前，这个函数是阻塞的。 public int read(char cbuf[]) throws IOException { return read(cbuf, 0, cbuf.length); } //留给子类实现，如果读到了字符输入流的末尾（即已经读取到了文件的EOF符号）则会返回-1 abstract public int read(char cbuf[], int off, int len) throws IOException; //每一次从字符输入流中最多跳过的字符数量 private static final int maxSkipBufferSize = 8192; //执行skip()函数时才会用到，用来跳过指定的字符数量时需要借助字符数组char[]来完成 private char skipBuffer[] = null; //将从字符输入流中跳过n个字符 public long skip(long n) throws IOException { if (n < 0L) //校验，如果n<0，则抛出一个IllegalArgumentException throw new IllegalArgumentException("skip value is negative"); //每次跳过的字符最多为8192个 int nn = (int) Math.min(n, maxSkipBufferSize); synchronized (lock) {//后续的代码片段只允许单线程执行 if ((skipBuffer == null) || (skipBuffer.length < nn)) skipBuffer = new char[nn];//用于每次跳过指定数量字符（每次最多为8192个）的字符数组 long r = n;//r表示当前线程还没(或者还需要)跳过的字符的总数量 while (r > 0) { //当前线程还没(或者还需要)跳过的字符的总数量>0时，每次执行read()函数从字符输入流中跳过0~8192个字符 //当前线程读到了字符输入流的末尾（即已经读取到了文件的EOF符号）则会返回-1 int nc = read(skipBuffer, 0, (int)Math.min(r, nn)); if (nc == -1) break;//中断while循环 r -= nc;//将本次从字符输入流中跳过的字符递减就是接下来还没(或者还需要)跳过的字符的总数量 } return n - r;//返回已经从字符输入流中跳过的字符总数量（n-r） } } //具体逻辑需要子类来重写，JDK给这个函数的定义如下： //①、如果返回 true，则表示下一次调用read()函数时保证不会阻塞，否则返回 false。 //②、即使返回 false 也不能保证下一次调用read()函数时一定会阻塞。 public boolean ready() throws IOException { return false; } //具体逻辑需要子类来重写，JDK给这个函数的定义如下： //①、如果返回true，表示子类支持mark()函数； //②、如果返回false，表示子类不支持mark()函数 public boolean markSupported() { return false; } //标记此字符输入流中的当前位置。随后调用reset()函数时会将此字符输入流重新定位到上次标记的位置，从而使得后续的读取操作能够再次读取相同的字符。 //ASCIIReader、BufferedReader、CharArrayReader、FilterReader、Latin1Reader、LineNumberReader、StringReader、UCSReader会重写这个mark()函数，其余Reader.class的子类不会重写这个函数。 public void mark(int readAheadLimit) throws IOException { throw new IOException("mark() not supported"); } //reset()函数会将此字符输入流重新定位到上次执行mark()函数标记的位置，从而使得后续的读取操作能够再次读取相同的字符。 //ASCIIReader、BufferedReader、CharArrayReader、FilterReader、Latin1Reader、LineNumberReader、StringReader、UCSReader会重写这个reset()函数，其余Reader.class的子类不会重写这个函数。 public void reset() throws IOException { throw new IOException("reset() not supported"); } /** * Closes the stream and releases any system resources associated with * it. Once the stream has been closed, further read(), ready(), * mark(), reset(), or skip() invocations will throw an IOException. * Closing a previously closed stream has no effect. * * @exception IOException If an I/O error occurs */ //留给子类实现，子类必须遵守以下规则： //①、关闭这个字符输入流，并释放与该流相关的系统资源 //②、关闭的字符输入流对象在执行read()函数, ready()函数, mark()函数, reset()函数, 或者 skip()函数 时将抛出一个 IOException. abstract public void close() throws IOException; }1.1、Reader的skip()函数
//将从字符输入流中跳过n个字符 public long skip(long n) throws IOException { if (n < 0L) //校验，如果n<0，则抛出一个IllegalArgumentException throw new IllegalArgumentException("skip value is negative"); //每次跳过的字符最多为8192个 int nn = (int) Math.min(n, maxSkipBufferSize); synchronized (lock) {//后续的代码片段只允许单线程执行 if ((skipBuffer == null) || (skipBuffer.length < nn)) skipBuffer = new char[nn];//用于每次跳过指定数量字符（每次最多为8192个）的字符数组 long r = n;//r表示当前线程还没(或者还需要)跳过的字符的总数量 while (r > 0) { //当前线程还没(或者还需要)跳过的字符的总数量>0时，每次执行read()函数从字符输入流中跳过0~8192个字符 //当前线程读到了字符输入流的末尾（即已经读取到了文件的EOF符号）则会返回-1 int nc = read(skipBuffer, 0, (int)Math.min(r, nn)); if (nc == -1) break;//中断while循环 r -= nc;//将本次从字符输入流中跳过的字符递减就是接下来还没(或者还需要)跳过的字符的总数量 } return n - r;//返回已经从字符输入流中跳过的字符总数量（n-r） } }如果一个字符输入流中有20000个字符，并且此时有多个线程（此处假设有2个线程，分别为ThreadA和ThreadB）要执行此字符输入流的skip()函数，ThreadA执行了skip(8000)表示要从这个字符输入流中跳过8000个字符，ThreadB执行了skip(10000)表示要从这个字符输入流中跳过10000个字符，此时，这2个线程同时执行skip()函数的过程如下所示：
①、ThreadA和ThreadB分别在各自的线程栈中压入skip()函数，如下所示：
②、假如ThreadA在执行下面的代码时先获取到了锁，先进入到了Monitor监控（synchronized底层是基于操作系统的Monitor来实现的）的代码片段
synchronized (lock) {//后续的代码片段只允许单线程执行那么ThreadA在进入while循环之前，会进行初始化char[]数组的长度为8000和临时变量long r的操作，如下所示：
③、ThreadA只会进入一次while循环，ThreadA在进入while循环之后，会从字符输入流中读取8000个字符到字符数组char[] skipBuffer中，然后就结束while循环，并且释放掉获取到的锁对象Object lock，并且将从字符输入流中跳过的字符总数量（这里是8000）返回给该函数的调用者，如下所示：
④、然后ThreadB在执行下面的代码时也获取到了锁，进入到了Monitor监控（synchronized底层是基于操作系统的Monitor来实现的）的代码片段
synchronized (lock) {//后续的代码片段只允许单线程执行那么ThreadB在进入while循环之前，会重新初始化char[]数组的长度为8192和临时变量long r的操作，如下所示：
⑤、ThreadB第1次进入while循环之后，会从字符输入流中读取8192个字符到字符数组char[] skipBuffer中，然后更新long r = 1808，如下所示：
⑥、ThreadB第2次进入while循环之后，会从字符输入流中读取1808个字符到字符数组char[] skipBuffer中，然后更新long r = 0，如下所示：
⑦、最后，ThreadB结束while循环，并且释放掉获取到的锁对象Object lock，并且将从字符输入流中跳过的字符总数量（这里是10000）返回给该函数的调用者，如下所示：
二、FilterReader.class源码——字符流的装饰器基类
FilterReader 的UML关系图，如下所示：
FilterReader.class的源码，如下所示：
package java.io; /** * Abstract class for reading filtered character streams. * The abstract class <code>FilterReader</code> itself * provides default methods that pass all requests to * the contained stream. Subclasses of <code>FilterReader</code> * should override some of these methods and may also provide * additional methods and fields. * * @author Mark Reinhold * @since JDK1.1 */ public abstract class FilterReader extends Reader { //实际被装饰的字符输入流 protected Reader in; //当用构造函数创建这个装饰器时，传入一个被装饰者的字符输入流 protected FilterReader(Reader in) { super(in); this.in = in; } //调用实际被装饰的字符输入流的read() 函数 public int read() throws IOException { return in.read(); } //调用实际被装饰的字符输入流的read(char cbuf[], int off, int len) 函数 public int read(char cbuf[], int off, int len) throws IOException { return in.read(cbuf, off, len); } //调用实际被装饰的字符输入流的skip(long n) 函数 public long skip(long n) throws IOException { return in.skip(n); } //调用实际被装饰的字符输入流的ready() 函数 public boolean ready() throws IOException { return in.ready(); } //调用实际被装饰的字符输入流的markSupported() 函数 public boolean markSupported() { return in.markSupported(); } //调用实际被装饰的字符输入流的mark(int readAheadLimit) 函数 public void mark(int readAheadLimit) throws IOException { in.mark(readAheadLimit); } //调用实际被装饰的字符输入流的reset() 函数 public void reset() throws IOException { in.reset(); } //调用实际被装饰的字符输入流的close() 函数 public void close() throws IOException { in.close(); } }三、PushbackReader.class源码——可以回退字符到被读取的字符流中的字符流装饰器类
PushbackReader与PushbackInputStream类似，只不过PushbackReader提供了有限字符（内部定义了一个默认长度为1的char[] buf字符数组）的缓冲式回退能力，具体过程如下：
①、当调用unread()函数时会将任意字符（可以是从被装饰的输入流中读取的字节，也可以是自己定义的字符）压入char[] buf字符数组的尾部（pos-1的位置）；
②、当后续调用read()函数时优先读取步骤①中这个char[] buf字符数组中被压入的字符。
PushbackInputStream.class的相关源码和使用方式请参照：13、PushbackInputStream和StreamTokenizer的源码分析和使用方法详细分析
3.1、PushbackReader.class的源码分析
PushbackReader.class 的UML关系图，如下所示：
PushbackReader.class 的源码，如下所示：
package java.io; public class PushbackReader extends FilterReader { //有限长度的用于回退的字符数组缓冲区，默认长度为1 private char[] buf; //可读指针，char[] buf（有限长度的用于回退的字符数组缓冲区）中该指针（包括该指针）索引之后的所有字符都可以读 private int pos; //构造函数，in为被装饰的字符输入流，size为char[] buf（有限长度的用于回退的字符数组缓冲区）的长度 public PushbackReader(Reader in, int size) { super(in); if (size <= 0) { throw new IllegalArgumentException("size <= 0"); } this.buf = new char[size]; this.pos = size;//将可读指针指向char[] buf（有限长度的用于回退的字符数组缓冲区）中最后一个索引（size-1）之后 } //构造函数，in为被装饰的字符输入流 public PushbackReader(Reader in) { this(in, 1);//构造一个默认长度为1的char[] buf（用于回退的字符数组缓冲区） } //检查被装饰的字符输入流是否关闭 private void ensureOpen() throws IOException { if (buf == null) throw new IOException("Stream closed"); } //这个函数在多线程的场景下运行时是线程安全的 //如果char[] buf（用于回退的字符数组缓冲区）中有可读的字符的话，就从该缓冲区中读取1个字符 //如果char[] buf（用于回退的字符数组缓冲区）中没有可读的字符的话，就从被装饰的输入流中读取1个字符 //如果char[] buf（用于回退的字符数组缓冲区）和被装饰的输入流中都没有可读的字符的话，返回-1 public int read() throws IOException { synchronized (lock) {//用Reader.class::lock变量指向的对象（锁）来同步线程 ensureOpen(); if (pos < buf.length) return buf[pos++]; else return super.read(); } } //这个函数在多线程的场景下运行时是线程安全的，尽可能的从char[] buf（用于回退的字符数组缓冲区）和被装饰的输入流中读取len个字符到char[] cbuf的[off,off+len)索引位置，总共分为以下5种场景： //①、如果char[] buf（用于回退的字符数组缓冲区）中有len个字符的话，就从该缓冲区中读取len个字符到字符数组char[] cbuf的[off,off+len)索引位置 //②、如果char[] buf（用于回退的字符数组缓冲区）中没有任何字符并且被装饰的字符输入流中有len个字符，那就从被装饰的字符输入流中读取len个字符到字符数组char[] cbuf的[off,off+len)索引位置 //③、如果char[] buf（用于回退的字符数组缓冲区）中没有任何字符并且被装饰的字符输入流中只有avail（avail<len）个字符，那就从被装饰的字符输入流中读取avail个字符到字符数组char[] cbuf的[off,off+avail)索引位置 //④、如果char[] buf（用于回退的字符数组缓冲区）中有avail（avail<len）个字符的话，就读取avail个字符，剩余len-avail个字符从被装饰的字符输入流中读取，如果被装饰的字符输入流中没有len-avail个字符的话，那就从被装饰的输入流中有多少读取多少，直到将被装饰的输入流读取完毕，然后将以上2个地方（被装饰的输入流+用于回退的字符数组缓冲区）读取的所有字符（假如有x个）放入到字符数组char[] cbuf的[off,off+x)索引位置 //⑤、如果char[] buf（用于回退的字符数组缓冲区）和被装饰的字符输入流中都没有任何字符的话，返回-1 public int read(char cbuf[], int off, int len) throws IOException { synchronized (lock) { //检查被装饰的字符输入流是否关闭 ensureOpen(); try { if (len <= 0) { if (len < 0) { throw new IndexOutOfBoundsException(); } else if ((off < 0) || (off > cbuf.length)) {//相当于off + len > cbuf.length（源码中这样写代码的好处我没看出来） throw new IndexOutOfBoundsException(); } return 0;//要从PushbackReader 对象中读取的len个字符==0时，返回0 } int avail = buf.length - pos;//用于回退的字符数组缓冲区中实际装载了buf.length - pos个字符 if (avail > 0) { if (len < avail) avail = len; System.arraycopy(buf, pos, cbuf, off, avail); pos += avail; off += avail; len -= avail; } if (len > 0) { len = super.read(cbuf, off, len); if (len == -1) { return (avail == 0) ? -1 : avail; } return avail + len;//场景④中的x就是这里的avail + len } return avail; } catch (ArrayIndexOutOfBoundsException e) { throw new IndexOutOfBoundsException(); } } } //一次只可以回推1个字符数据到char[] buf（用于回退的字符数组缓冲区）中 public void unread(int c) throws IOException { synchronized (lock) { ensureOpen(); if (pos == 0)//pos=0时，表示char[] buf（用于回退的字符数组缓冲区）中已经没有足够的容量再放置数据，所以抛出一个IOException异常。 throw new IOException("Pushback buffer overflow"); buf[--pos] = (char) c; } } //一次回推char[] cbuf字符数组中[off,off+len)索引位置的len个字符数据到char[] buf（用于回退的字符数组缓冲区）中 public void unread(char cbuf[], int off, int len) throws IOException { synchronized (lock) { ensureOpen(); if (len > pos)//如果char[] buf（用于回退的字符数组缓冲区）中没有足够的位置放置len个字符，则抛出一个IOException throw new IOException("Pushback buffer overflow"); pos -= len;//如果char[] buf（用于回退的字符数组缓冲区）中有足够的位置放置len个字符，则使用System.arraycopy()函数进行回退 System.arraycopy(cbuf, off, buf, pos, len); } } public void unread(char cbuf[]) throws IOException { unread(cbuf, 0, cbuf.length); } public boolean ready() throws IOException { synchronized (lock) { ensureOpen(); return (pos < buf.length) || super.ready(); } } //不支持mark()函数 public void mark(int readAheadLimit) throws IOException { throw new IOException("mark/reset not supported"); } //不支持reset()函数 public void reset() throws IOException { throw new IOException("mark/reset not supported"); } //不支持mark()函数 public boolean markSupported() { return false; } //关闭被装饰的字符输入流和用于回退的字符数组缓冲区 public void close() throws IOException { super.close(); buf = null; } //从char[] buf（用于回退的字符数组缓冲区）+被装饰的字符输入流中跳过n个字符，如果char[] buf（用于回退的字符数组缓冲区）+被装饰的字符输入流中的字符数量<n，则返回实际跳过的字符数量 public long skip(long n) throws IOException { if (n < 0L) throw new IllegalArgumentException("skip value is negative"); synchronized (lock) { ensureOpen(); int avail = buf.length - pos;//从char[] buf（用于回退的字符数组缓冲区）中跳过的字符 if (avail > 0) { if (n <= avail) { pos += n; return n; } else { pos = buf.length; n -= avail; } } return avail + super.skip(n);//从被装饰的字符输入流中跳过的字符累加到从char[] buf（用于回退的字符数组缓冲区）中跳过的字符 } } }3.2、PushbackReader.class的read()函数和unread()函数
package java.io; public class PushbackReader extends FilterReader { //有限长度的用于回退的字符数组缓冲区，默认长度为1 private char[] buf; //可读指针，char[] buf（有限长度的用于回退的字符数组缓冲区）中该指针（包括该指针）索引之后的所有字符都可以读 private int pos; ...省略部分代码... //这个函数在多线程的场景下运行时是线程安全的，尽可能的从char[] buf（用于回退的字符数组缓冲区）和被装饰的输入流中读取len个字符到char[] cbuf的[off,off+len)索引位置，总共分为以下5种场景： //①、如果char[] buf（用于回退的字符数组缓冲区）中有len个字符的话，就从该缓冲区中读取len个字符到字符数组char[] cbuf的[off,off+len)索引位置 //②、如果char[] buf（用于回退的字符数组缓冲区）中没有任何字符并且被装饰的字符输入流中有len个字符，那就从被装饰的字符输入流中读取len个字符到字符数组char[] cbuf的[off,off+len)索引位置 //③、如果char[] buf（用于回退的字符数组缓冲区）中没有任何字符并且被装饰的字符输入流中只有avail（avail<len）个字符，那就从被装饰的字符输入流中读取avail个字符到字符数组char[] cbuf的[off,off+avail)索引位置 //④、如果char[] buf（用于回退的字符数组缓冲区）中有avail（avail<len）个字符的话，就读取avail个字符，剩余len-avail个字符从被装饰的字符输入流中读取，如果被装饰的字符输入流中没有len-avail个字符的话，那就从被装饰的输入流中有多少读取多少，直到将被装饰的输入流读取完毕，然后将以上2个地方（被装饰的输入流+用于回退的字符数组缓冲区）读取的所有字符（假如有x个）放入到字符数组char[] cbuf的[off,off+x)索引位置 //⑤、如果char[] buf（用于回退的字符数组缓冲区）和被装饰的字符输入流中都没有任何字符的话，返回-1 public int read(char cbuf[], int off, int len) throws IOException { synchronized (lock) { //检查被装饰的字符输入流是否关闭 ensureOpen(); try { if (len <= 0) { if (len < 0) { throw new IndexOutOfBoundsException(); } else if ((off < 0) || (off > cbuf.length)) {//相当于off + len > cbuf.length（源码中这样写代码的好处我没看出来） throw new IndexOutOfBoundsException(); } return 0;//要从PushbackReader 对象中读取的len个字符==0时，返回0 } int avail = buf.length - pos;//用于回退的字符数组缓冲区中实际装载了buf.length - pos个字符 if (avail > 0) { if (len < avail) avail = len; System.arraycopy(buf, pos, cbuf, off, avail); pos += avail; off += avail; len -= avail; } if (len > 0) { len = super.read(cbuf, off, len); if (len == -1) { return (avail == 0) ? -1 : avail; } return avail + len;//场景④中的x就是这里的avail + len } return avail; } catch (ArrayIndexOutOfBoundsException e) { throw new IndexOutOfBoundsException(); } } } //一次只可以回推1个字符数据到char[] buf（用于回退的字符数组缓冲区）中 public void unread(int c) throws IOException { synchronized (lock) { ensureOpen(); if (pos == 0)//pos=0时，表示char[] buf（用于回退的字符数组缓冲区）中已经没有足够的容量再放置数据，所以抛出一个IOException异常。 throw new IOException("Pushback buffer overflow"); buf[--pos] = (char) c; } } ...省略部分代码... }如果使用者使用的被装饰的字符输入流是CharArrayReader，然后执行PushbackReader.class的read()函数和unread()函数时，使用如下代码：
package com.xxx.bio; import java.io.CharArrayReader; import java.io.IOException; import java.io.PushbackReader; import java.io.Reader; public class PushbackReaderTest { public static void main(String[] args) throws IOException { String str = "你好，世界，我将征服你"; Reader reader = new CharArrayReader(str.toCharArray()); //构建字符回退流 PushbackReader pushbackReader = new PushbackReader(reader, 8); int len = -1; System.out.println("输出内容:"); while ((len = pushbackReader.read()) != -1) { //转为char类型 char c = (char) len; if (c == '，') {//此处为中文"，" //为，号时 ，先往前读3个，再往后倒两个 char[] b1 = new char[3]; pushbackReader.read(b1); //往后倒两个 pushbackReader.unread(b1, 0, 2); } else { System.out.print(c); } } } }上面代码的执行结果如下：
以上代码的整个执行过程分为以下5步：
①、通过构造函数构建一个长度为8的char[] buf（用于回退的字符数组缓冲区）和CharArrayReader.class类型的被装饰的字符输入流，如下所示：
PushbackReader pushbackReader = new PushbackReader(reader, 8);②、按照顺序从CharArrayReader.class类型的输入流中读取字符，直到读取到中文“，”时，如下所示：
while ((len = pushbackReader.read()) != -1) { //转为char类型 char c = (char) len; if (c == '，') {//此处为中文"，" } else { System.out.print(c); } }输出如下：
你好③、当第一次读取到中文“，”之后，从被装饰的字符输入流CharArrayReader.class中往char[] b1字符数组中读取3个字符，如下所示：
//为，号时 ，先往前读3个，再往后倒两个 char[] b1 = new char[3]; pushbackReader.read(b1);④、将步骤③中读入到char[] b1字符数组中的[0,2)索引位置的数据读取到PushbackReader中的char[] buf（用于回退的字符数组缓冲区）的[6,8)索引位置中，如下所示：
//往后倒两个 pushbackReader.unread(b1, 0, 2);⑤、再次重复执行步骤②中按照顺序从CharArrayReader.class类型的字符输入流中读取字符时，先读取PushbackReader中的char[] buf（用于回退的字符数组缓冲区）的[6,8)索引位置，再从CharArrayReader.class类型的字符输入流中读取剩余字符，如下所示：
while ((len = pushbackReader.read()) != -1) { //转为char类型 char c = (char) len; if (c == '，') {//此处为中文"，" } else { System.out.print(c); } }
