A：关键字
  private Writer out;   底层字符输出流

  
  private char cb[];   缓冲数组
  
  private int nChars, nextChar;   nChars--cb的size，nextChar--cb中下一个字符的下标

  private static int defaultCharBufferSize = 8192;   默认cb大小

  private String lineSeparator;  换行符、用于newLine方法。不同平台具有不同的值。

    B：构造方法

  BufferedWriter(Writer out)  使用默认cb大小创建BufferedWriter bw。
  
  BufferedWriter(Writer out, int sz)  使用默认cb大小创建BufferedWriter bw。

    C：一般方法

  void close()  关闭此流、释放与此流有关的资源。
  
  void flushBuffer()  将cb中缓存的字符flush到底层out中、
  
  void flush() 刷新此流、同时刷新底层out流
  
  void newLine()  写入一个换行符。
  
  void write(int c)  将一个单个字符写入到cb中。
  
  void write(char cbuf[], int off, int len) 将一个从下标off开始长度为len个字符写入cb中
  
  void write(String s, int off, int len)  将一个字符串的一部分写入cb中

package com.chy.io.original.code;

import java.io.IOException;
import java.io.PrintWriter;


/**
 * 为字符输出流提供缓冲功能、提高效率。可以使用指定字符缓冲数组大小也可以使用默认字符缓冲数组大小。
 */

public class BufferedWriter extends Writer {

 //底层字符输出流
  private Writer out;

  //缓冲数组
  private char cb[];
  //nChars--cb中总的字符数，nextChar--cb中下一个字符的下标
  private int nChars, nextChar;

  //默认cb大小
  private static int defaultCharBufferSize = 8192;

  /**
   * Line separator string. This is the value of the line.separator
   * property at the moment that the stream was created.
   * 换行符、用于newLine方法。不同平台具有不同的值。
   */
  private String lineSeparator;

  /**
   * 使用默认cb大小创建BufferedWriter bw。
   */
  public BufferedWriter(Writer out) {
   this(out, defaultCharBufferSize);
  }

  /**
   * 使用指定cb大小创建br、初始化相关字段
   */
  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 = (String) java.security.AccessController.doPrivileged(
          new sun.security.action.GetPropertyAction("line.separator"));
  }

  /** 检测底层字符输出流是否关闭*/
  private void ensureOpen() throws IOException {
  if (out == null)
    throw new IOException("Stream closed");
  }

  /**
   * 将cb中缓存的字符flush到底层out中、但是不flush底层out中的字符。
   * 并且将cb清空。
   */
  void flushBuffer() throws IOException {
  synchronized (lock) {
    ensureOpen();
    if (nextChar == 0)
     return;
    out.write(cb, 0, nextChar);
    nextChar = 0;
  }
  }

  /**
   * 将一个单个字符写入到cb中。
   */
  public void write(int c) throws IOException {
  synchronized (lock) {
    ensureOpen();
    if (nextChar >= nChars)
   flushBuffer();
    cb[nextChar++] = (char) c;
  }
  }

  /**
   * Our own little min method, to avoid loading java.lang.Math if we've run
   * out of file descriptors and we're trying to print a stack trace.
   */
  private int min(int a, int b) {
 if (a < b) return a;
 return b;
  }

  /**
   * 将一个从下标off开始长度为len个字符写入cb中
   */
  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) {
    /* 如果len大于cb的长度、那么就直接将cb中现有的字符和cbuf中的字符写入out中、
     * 而不是写入cb、再写入out中 。
     */
    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();
    }
  }
  }

  /**
   * 将一个字符串的一部分写入cb中
   */
  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);
  }

  /**
   * 刷新此流、同时刷新底层out流
   */
  public void flush() throws IOException {
  synchronized (lock) {
    flushBuffer();
    out.flush();
  }
  }
  /**
   * 关闭此流、释放与此流有关的资源。
   */
  public void close() throws IOException {
  synchronized (lock) {
    if (out == null) {
   return;
    }
    try {
      flushBuffer();
    } finally {
      out.close();
      out = null;
      cb = null;
    }
  }
  }
}

 A：构造方法

  BufferedReader(Reader in, int sz)  根据指定大小和底层字符输入流创建BufferedReader。br
  
  BufferedReader(Reader in)  使用默认大小创建底层输出流的缓冲流
 

    B：一般方法

  void close() 关闭此流、释放与此流有关的所有资源
  
  void mark(int readAheadLimit) 标记此流此时的位置
  
  boolean markSupported()  判断此流是否支持标记
  
  void reset() 重置in被最后一次mark的位置
  
  boolean ready()  判断此流是否可以读取字符
  
  int read()  读取单个字符、以整数形式返回。如果读到in的结尾则返回-1。
  
  int read(char[] cbuf, int off, int len) 将in中len个字符读取到cbuf从下标off开始长度len中
  
  String readLine() 读取一行
  
  long skip(long n)  丢弃in中n个字符

package com.chy.io.original.code;

import java.io.IOException;

/**
 * 为底层字符输入流添加字符缓冲cb数组。提高效率
 * @version  1.1, 13/11/17
 * @author  andyChen
 */

public class BufferedReader extends Reader {

  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;

  /**
   * 根据指定大小和底层字符输入流创建BufferedReader。br
   */
  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);
  }

  /** 检测底层字符输入流in是否关闭 */
  private void ensureOpen() throws IOException {
  if (in == null)
    throw new IOException("Stream closed");
  }

  /**
   * 填充cb。
   */
  private void fill() throws IOException {
  int dst;
  if (markedChar <= UNMARKED) {
    /* No mark */
    dst = 0;
  } else {
    /* Marked */
    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;
  do {
    n = in.read(cb, dst, cb.length - dst);
  } while (n == 0);
  if (n > 0) {
    nChars = dst + n;
    nextChar = dst;
  }
  }

  /**
   * 读取单个字符、以整数形式返回。如果读到in的结尾则返回-1。
   */
  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++];
    }
  }
  }

  /**
   * 将in中len个字符读取到cbuf从下标off开始长度len中
   */
  private int read1(char[] cbuf, int off, int len) throws IOException {
  if (nextChar >= nChars) {
    /* If the requested length is at least as large as the buffer, and
      if there is no mark/reset activity, and if line feeds are not
      being skipped, do not bother to copy the characters into the
      local buffer. In this way buffered streams will cascade
      harmlessly. */
    if (len >= cb.length && markedChar <= UNMARKED && !skipLF) {
   return in.read(cbuf, off, len);
    }
    fill();
  }
  if (nextChar >= nChars) return -1;
  if (skipLF) {
    skipLF = false;
    if (cb[nextChar] == '\n') {
   nextChar++;
   if (nextChar >= nChars)
     fill();
   if (nextChar >= nChars)
     return -1;
    }
  }
  int n = Math.min(len, nChars - nextChar);
  System.arraycopy(cb, nextChar, cbuf, off, n);
  nextChar += n;
  return n;
  }

  /**
   * 将in中len个字符读取到cbuf从下标off开始长度len中
   */
  public int read(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 0;
      }

   int n = read1(cbuf, off, len);
   if (n <= 0) return n;
   while ((n < len) && in.ready()) {
  int n1 = read1(cbuf, off + n, len - n);
  if (n1 <= 0) break;
  n += n1;
   }
   return n;
 }
  }

  /**
   * 从in中读取一行、是否忽略换行符
   */
  String readLine(boolean ignoreLF) throws IOException {
  StringBuffer s = null;
  int startChar;
 
    synchronized (lock) {
      ensureOpen();
   boolean omitLF = ignoreLF || skipLF;
  bufferLoop:
  for (;;) {
 
   if (nextChar >= nChars)
     fill();
   if (nextChar >= nChars) { /* EOF */
     if (s != null && s.length() > 0)
    return s.toString();
     else
    return null;
   }
   boolean eol = false;
   char c = 0;
   int i;
 
         /* Skip a leftover '\n', if necessary */
   if (omitLF && (cb[nextChar] == '\n')) 
           nextChar++;
   skipLF = false;
   omitLF = false;
 
    charLoop:
   for (i = nextChar; i < nChars; i++) {
     c = cb[i];
     if ((c == '\n') || (c == '\r')) {
    eol = true;
    break charLoop;
     }
   }
 
   startChar = nextChar;
   nextChar = i;
 
   if (eol) {
     String str;
     if (s == null) {
    str = new String(cb, startChar, i - startChar);
     } else {
    s.append(cb, startChar, i - startChar);
    str = s.toString();
     }
     nextChar++;
     if (c == '\r') {
    skipLF = true;
     }
     return str;
   }
   
   if (s == null) 
     s = new StringBuffer(defaultExpectedLineLength);
   s.append(cb, startChar, i - startChar);
    }
    }
  }

  /**
   * 从in中读取一行、
   */
  public String readLine() throws IOException {
    return readLine(false);
  }

  /**
   * 丢弃in中n个字符
   */
  public long skip(long n) throws IOException {
  if (n < 0L) {
    throw new IllegalArgumentException("skip value is negative");
  }
  synchronized (lock) {
    ensureOpen();
    long r = n;
    while (r > 0) {
   if (nextChar >= nChars)
     fill();
   if (nextChar >= nChars) /* EOF */
     break;
   if (skipLF) {
     skipLF = false;
     if (cb[nextChar] == '\n') {
    nextChar++;
     }
   }
   long d = nChars - nextChar;
   if (r <= d) {
     nextChar += r;
     r = 0;
     break;
   }
   else {
     r -= d;
     nextChar = nChars;
   }
    }
    return n - r;
  }
  }

  /**
   * 判断cb中是否为空、或者底层in中是否有可读字符。
   */
  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;
  }

  /**
   * 标记此流此时的位置、当调用reset方法失效前最多允许读取readAheadLimit个字符。
   */
  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;
  }
  }

  /**
   * 重置in被最后一次mark的位置。即下一个字符从被最后一次mark的位置开始读取。
   */
  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;
    in.close();
    in = null;
    cb = null;
  }
  }
}

package com.chy.io.original.test;

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

public class BufferedWriterAndBufferedReaderTest {
 /**
  * 这里对这两个类的测试比较简单、就是对文件字符流进行包装、实现文件拷贝
  * 有兴趣的可以测试一下效率、、偷个懒、、可无视
  */
 public static void main(String[] args) throws IOException{
  File resouceFile = new File("D:\\test.txt");
  File targetFile = new File("E:\\copyOftest.txt");
  
  BufferedReader br = new BufferedReader(new FileReader(resouceFile));
  BufferedWriter bw = new BufferedWriter(new FileWriter(targetFile));
  
  char[] cbuf = new char[1024];
  int n = 0;
  while((n = br.read(cbuf)) != -1){
   bw.write(cbuf, 0, n);
  }
  //不要忘记刷新和关闭流、否则一方面资源没有及时释放、另一方面有可能照成数据丢失
  br.close();
  bw.flush();
  bw.close();
 }
}