A：關(guān)鍵字
  private Writer out;		 底層字符輸出流

  
  private char cb[];		 緩沖數(shù)組
  
  private int nChars, nextChar;		 nChars--cb的size，nextChar--cb中下一個(gè)字符的下標(biāo)

  private static int defaultCharBufferSize = 8192;		 默認(rèn)cb大小

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

    B：構(gòu)造方法

  BufferedWriter(Writer out)		使用默認(rèn)cb大小創(chuàng)建BufferedWriter bw。
  
  BufferedWriter(Writer out, int sz)		使用默認(rèn)cb大小創(chuàng)建BufferedWriter bw。

    C：一般方法

  void close()		關(guān)閉此流、釋放與此流有關(guān)的資源。
  
  void flushBuffer()		將cb中緩存的字符flush到底層out中、
  
  void flush()	刷新此流、同時(shí)刷新底層out流
  
  void newLine()		寫入一個(gè)換行符。
  
  void write(int c)		將一個(gè)單個(gè)字符寫入到cb中。
  
  void write(char cbuf[], int off, int len)	將一個(gè)從下標(biāo)off開始長度為len個(gè)字符寫入cb中
  
  void write(String s, int off, int len)		將一個(gè)字符串的一部分寫入cb中

package com.chy.io.original.code;

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


/**
 * 為字符輸出流提供緩沖功能、提高效率?？梢允褂弥付ㄗ址彌_數(shù)組大小也可以使用默認(rèn)字符緩沖數(shù)組大小。
 */

public class BufferedWriter extends Writer {

	//底層字符輸出流
  private Writer out;

  //緩沖數(shù)組
  private char cb[];
  //nChars--cb中總的字符數(shù)，nextChar--cb中下一個(gè)字符的下標(biāo)
  private int nChars, nextChar;

  //默認(rèn)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;

  /**
   * 使用默認(rèn)cb大小創(chuàng)建BufferedWriter bw。
   */
  public BufferedWriter(Writer out) {
  	this(out, defaultCharBufferSize);
  }

  /**
   * 使用指定cb大小創(chuàng)建br、初始化相關(guān)字段
   */
  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"));
  }

  /** 檢測底層字符輸出流是否關(guān)閉*/
  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;
		}
  }

  /**
   * 將一個(gè)單個(gè)字符寫入到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;
  }

  /**
   * 將一個(gè)從下標(biāo)off開始長度為len個(gè)字符寫入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中現(xiàn)有的字符和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();
		  }
		}
  }

  /**
   * 將一個(gè)字符串的一部分寫入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();
	  }
	}
  }

  /**
   * 寫入一個(gè)換行符。
   */
  public void newLine() throws IOException {
  	write(lineSeparator);
  }

  /**
   * 刷新此流、同時(shí)刷新底層out流
   */
  public void flush() throws IOException {
		synchronized (lock) {
		  flushBuffer();
		  out.flush();
		}
  }
  /**
   * 關(guān)閉此流、釋放與此流有關(guān)的資源。
   */
  public void close() throws IOException {
		synchronized (lock) {
		  if (out == null) {
			return;
		  }
		  try {
		    flushBuffer();
		  } finally {
		    out.close();
		    out = null;
		    cb = null;
		  }
		}
  }
}

 A：構(gòu)造方法

  BufferedReader(Reader in, int sz)		根據(jù)指定大小和底層字符輸入流創(chuàng)建BufferedReader。br
  
  BufferedReader(Reader in)		使用默認(rèn)大小創(chuàng)建底層輸出流的緩沖流
 

    B：一般方法

  void close()	關(guān)閉此流、釋放與此流有關(guān)的所有資源
  
  void mark(int readAheadLimit)	標(biāo)記此流此時(shí)的位置
  
  boolean markSupported()		判斷此流是否支持標(biāo)記
  
  void reset()	重置in被最后一次mark的位置
  
  boolean ready()		判斷此流是否可以讀取字符
  
  int read()		讀取單個(gè)字符、以整數(shù)形式返回。如果讀到in的結(jié)尾則返回-1。
  
  int read(char[] cbuf, int off, int len)	將in中l(wèi)en個(gè)字符讀取到cbuf從下標(biāo)off開始長度len中
  
  String readLine()	讀取一行
  
  long skip(long n)		丟棄in中n個(gè)字符

package com.chy.io.original.code;

import java.io.IOException;

/**
 * 為底層字符輸入流添加字符緩沖cb數(shù)組。提高效率
 * @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;

  /**
   * 根據(jù)指定大小和底層字符輸入流創(chuàng)建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;
  }

  /**
   * 使用默認(rèn)大小創(chuàng)建底層輸出流的緩沖流
   */
  public BufferedReader(Reader in) {
  	this(in, defaultCharBufferSize);
  }

  /** 檢測底層字符輸入流in是否關(guān)閉 */
  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;
		}
  }

  /**
   * 讀取單個(gè)字符、以整數(shù)形式返回。如果讀到in的結(jié)尾則返回-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中l(wèi)en個(gè)字符讀取到cbuf從下標(biāo)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中l(wèi)en個(gè)字符讀取到cbuf從下標(biāo)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個(gè)字符
   */
  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();
		}
  }

  /**
   * 判斷此流是否支持標(biāo)記
   */
  public boolean markSupported() {
  	return true;
  }

  /**
   * 標(biāo)記此流此時(shí)的位置、當(dāng)調(diào)用reset方法失效前最多允許讀取readAheadLimit個(gè)字符。
   */
  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的位置。即下一個(gè)字符從被最后一次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;
		}
  }

  //關(guān)閉此流、釋放與此流有關(guān)的所有資源
  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 {
	/**
	 * 這里對這兩個(gè)類的測試比較簡單、就是對文件字符流進(jìn)行包裝、實(shí)現(xiàn)文件拷貝
	 * 有興趣的可以測試一下效率、、偷個(gè)懶、、可無視
	 */
	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);
		}
		//不要忘記刷新和關(guān)閉流、否則一方面資源沒有及時(shí)釋放、另一方面有可能照成數(shù)據(jù)丟失
		br.close();
		bw.flush();
		bw.close();
	}
}