Java基礎知識之BufferedReader流的使用
一、BufferedReader類概念
API文檔描述：
BufferedReader類從字符輸入流中讀取文本並緩沖字符，以便有效地讀取字符，數組和行
可以通過構造函數指定緩沖區大小也可以使用默認大小。對於大多數用途，默認值足夠大
由Reader構成的每個讀取請求都會導致相應的讀取請求由基礎字符或字節流構成，建議通過BufferedReader包裝Reader的實例類以提高效率如
BufferedReader in = new BufferedReader（new FileReader（“foo.in”））;
使用DataInputStreams進行文本輸入的程序可以通過用適當的BufferedReader替換每個DataInputStream來進行本地化
1）從字符輸入流中讀取文本並緩沖字符，以便有效地讀取字符，數組和行怎麼理解？
說明該類存在緩沖字符數組並且是該類可以高效讀取字符的關鍵
2）構造函數指定緩沖區大小也可以使用默認大小怎麼理解？
意味著該類存在的構造方法既可以傳遞數值指定緩沖區大小也可以由類中的默認大小指定
3）由Reader構成的每個讀取請求都會導致相應的讀取請求由基礎字符或字節流構成，建議通過BufferedReader包裝Reader的實例類以提高效率?
Reader構成的對象是字符對象，每次的讀取請求都會涉及到字節讀取解碼字符的過程，而BufferedReader類中有設計減少這樣的解碼次數的方法，進而提高轉換效率
4）BufferedReader替代DataInputStreams進行本地化？
需要查看DataInputStreams源碼後才可知
二、BufferedReader類實例域
// 字符輸入流
private Reader in;
// 字符緩沖區
private char cb[];
//讀取字符存儲的最末下標+1
private int nChars;
//讀取字符存儲的起始下標
private int nextChar;
private static final int INVALIDATED = -2;
private static final int UNMARKED = -1;
private int markedChar = UNMARKED;
// 僅在markedChar為0時有效
private int readAheadLimit = 0;
// 如果下個字符是換行符，則跳過--專用於readLine()方法裡面控制
private boolean skipLF = false;
// 設置標志時的markedSkipLF--用於mark()方法的變量
private boolean markedSkipLF = false;
// 默認的字符緩沖大小
private static int defaultCharBufferSize =8192;
//用於readLine()方法時初始化StringBuffer的初始容量
private static int defaultExpectedLineLength = 80;
三、BufferedReader類構造函數
1）使用默認的緩沖區大小來創建緩沖字符輸入流，默認大小為8192個字符
private static int defaultCharBufferSize = 8192;
public BufferedReader(Reader in) {
this(in, defaultCharBufferSize);
}
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;
}
2）創建指定緩沖區大小的緩沖字符輸入流，一般使用默認即可
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;
}
四、BufferedReader類API
1）read()方法：讀取1個或多個字節，返回一個字符，當讀取到文件末尾時，返回-1
/**
* 讀取一個字符，若讀取到末尾則返回-1
*/
public int read() throws IOException
{
synchronized (lock)
{
ensureOpen();
for (;;)
{
//一般條件為真，除非是使用瞭skip方法跳躍字節
if (nextChar >= nChars)
{
fill(); //調用該方法讀取字符
if (nextChar >= nChars)
return -1;
}
//此方法暫時不用管，涉及跳過字節數和換行符問題
if (skipLF)
{
skipLF = false;
if (cb[nextChar] == '\n')
{
nextChar++;
continue;
}
}
return cb[nextChar++];
}
}
}
實際流程圖解：
2）fill()方法：從底層輸入流中填充字符到緩沖區中，此方法會調用StreamDecoder的方法實現字節到字符的轉換
/**
* 填充字符緩沖區，若有效則將標記考慮在內
*/
private void fill() throws IOException
{
int dst;
//查看是否調用過make方法進行標記--若未使用make方法，則條件為真
if (markedChar <= UNMARKED)
{
dst = 0;
}
else
{
int delta = nextChar - markedChar;
if (delta >= readAheadLimit)
{
markedChar = INVALIDATED;
readAheadLimit = 0;
dst = 0;
}
else
{
if (readAheadLimit <= cb.length)
{
System.arraycopy(cb, markedChar, cb, 0, delta);
markedChar = 0;
dst = delta;
}
else
{
char ncb[] = new char[readAheadLimit];
System.arraycopy(cb, markedChar, ncb, 0, delta);
cb = ncb;
markedChar = 0;
dst = delta;
}
nextChar = nChars = delta;
}
}
int n;
do
{
//調用InputStreamReader的方法，實際是調用StreamDecoder的read(char cbuf[], int offset, int length)方法
n = in.read(cb, dst, cb.length - dst);
}
while (n == 0);
if (n > 0) //當讀取到字符時
{
nChars = dst + n; //字符緩沖區存儲讀到的字符的最末下標
nextChar = dst; //字符緩沖區存儲讀到的字符的起始下標
}
}
實際流程圖解：註意根據read()方法先理解變量nChars和nextChar的意義
3）read(char cbuf[], int off, int len)：將最多length個字符讀入數組中，返回實際讀入的字符個數，當讀取到文件末尾時，返回-1，
/**
* 字符讀入數組的一部分，
*/
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); // 調用read1(cbuf, off, len)
if (n <= 0)
return n;
while ((n < len) && in.ready()) // 註意該while循環，多次測試發現並未進入該方法，即使進入，本質還是調用read1(cbuf, off, len)
{
int n1 = read1(cbuf, off + n, len - n);
if (n1 <= 0)
break;
n += n1;
}
return n;
}
}
private int read1(char[] cbuf, int off, int len) throws IOException
{
if (nextChar >= nChars)
{
// 若請求的長度與緩沖區長度一樣大時，直接會把字符讀取到數組中，並未使用該類的字符緩沖區
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); //取實際讀取字符數與目標字符數len的最小數
System.arraycopy(cb, nextChar, cbuf, off, n); //從字符緩沖區中復制字符到目標數組中
nextChar += n; //字符緩沖區存儲下標位置前諾，避免重復取一樣數據
return n;
}
實際流程圖解：圖解read1(cbuf, off, len)方法即可，本質是該方法在起作用
4）讀一行文字並返回該行字符，若讀到文件末尾，則返回null：即當遇到換行符（’\ n’），回車符（’\ r’）時會終止讀取表示該行文字讀取完畢且返回該行文字（不包含換行符和回車符）
/**
* 閱讀一行文字，任何一條線都被視為終止，返回包含該行內容的字符串，但是不含換行符等
*/
public String readLine() throws IOException
{
return readLine(false);
}
String readLine(boolean ignoreLF) throws IOException
{
StringBuffer s = null;
int startChar;
synchronized (lock)
{
ensureOpen();
boolean omitLF = ignoreLF || skipLF;
bufferLoop: for (;;)
{
if (nextChar >= nChars) //判斷是否有元素，沒有則調用fill()方法取元素
fill();
if (nextChar >= nChars) //判斷是否已到文件末尾，若到文件末尾，則返回S
{
if (s != null && s.length() > 0)
return s.toString();
else
return null;
}
boolean eol = false;
char c = 0;
int i;
//如果遇到過換行符，則跳過該換行符繼續讀取
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);
}
}
}
實際流程圖解：
5）close()方法：關閉資源釋放鏈接
public void close() throws IOException
{
synchronized (lock)
{
if (in == null)
return;
in.close();
in = null;
cb = null;
}
}
6）其它的skip()、make()方法等暫時不瞭解
五、BufferedReader類與InputStreamReader類比較
InputStreamReader中的文檔說明提到過：為瞭獲得最高效率，請考慮在BufferedReader中包裝InputStreamReader？
從read()方法理解，若使用InputStreamReader的read()方法，可以發現存在每2次就會調用一次解碼器解碼，但若是使用 BufferedReader包裝InputStreamReader後調用read()方法，可以發現隻會調用一次解碼器解碼，其餘時候都是直接從BufferedReader的緩沖區中取字符即可
從read(char cbuf[], int offset, int length)方法理解，若使用InputStreamReader的方法則隻會讀取leng個字符，但是使用BufferedReader類則會讀取讀取8192個字符，會盡量提取比當前操作所需的更多字節；
例如文件中有20個字符，我們先通過read(cbuf,0,5)要讀取5個字符到數組cbuf中，然後再通過read()方法讀取1個字符。那麼使用InputStreamReader類的話，則會調用一次解碼器解碼然後存儲5個字符到數組中，然後又調用read()方法調用一次解碼器讀取2個字符，然後返回1個字符；等於是調用瞭2次解碼器，若使用BufferedReader類的話則是先調用一次解碼器讀取20個字符到字符緩沖區中，然後復制5個到數組中，在調用read()方法時，則直接從緩沖區中讀取字符，等於是調用瞭一次解碼器
因此可以看出BufferedReader類會盡量提取比當前操作所需的更多字節，以應該更多情況下的效率提升，
因此在設計到文件字符輸入流的時候，我們使用BufferedReader中包裝InputStreamReader類即可
以上為個人經驗，希望能給大傢一個參考，也希望大傢多多支持WalkonNet。
推薦閱讀：
- 解決BufferedReader.readLine()遇見的坑
- java中使用Files.readLines()處理文本中行數據方式
- 一文詳解JAVA中InputStreamReader流
- 使用BufferedReader讀取TXT文件中數值,並輸出最大值
- 聊聊為什麼要使用BufferedReader讀取File