Java基礎(chǔ)知識(shí)之BufferedReader流的使用

更新時(shí)間：2021年12月09日 10:29:52 作者：咕嚕是個(gè)大胖子

這篇文章主要介紹了Java基礎(chǔ)知識(shí)之BufferedReader流的使用，具有很好的參考價(jià)值，希望對(duì)大家有所幫助。如有錯(cuò)誤或未考慮完全的地方，望不吝賜教

一、BufferedReader類(lèi)概念

API文檔描述：

BufferedReader類(lèi)從字符輸入流中讀取文本并緩沖字符，以便有效地讀取字符，數(shù)組和行

可以通過(guò)構(gòu)造函數(shù)指定緩沖區(qū)大小也可以使用默認(rèn)大小。對(duì)于大多數(shù)用途，默認(rèn)值足夠大

由Reader構(gòu)成的每個(gè)讀取請(qǐng)求都會(huì)導(dǎo)致相應(yīng)的讀取請(qǐng)求由基礎(chǔ)字符或字節(jié)流構(gòu)成，建議通過(guò)BufferedReader包裝Reader的實(shí)例類(lèi)以提高效率如

BufferedReader in  = new BufferedReader（new FileReader（“foo.in”））;

使用DataInputStreams進(jìn)行文本輸入的程序可以通過(guò)用適當(dāng)?shù)腂ufferedReader替換每個(gè)DataInputStream來(lái)進(jìn)行本地化

1）從字符輸入流中讀取文本并緩沖字符，以便有效地讀取字符，數(shù)組和行怎么理解？

說(shuō)明該類(lèi)存在緩沖字符數(shù)組并且是該類(lèi)可以高效讀取字符的關(guān)鍵

2）構(gòu)造函數(shù)指定緩沖區(qū)大小也可以使用默認(rèn)大小怎么理解？

意味著該類(lèi)存在的構(gòu)造方法既可以傳遞數(shù)值指定緩沖區(qū)大小也可以由類(lèi)中的默認(rèn)大小指定

3）由Reader構(gòu)成的每個(gè)讀取請(qǐng)求都會(huì)導(dǎo)致相應(yīng)的讀取請(qǐng)求由基礎(chǔ)字符或字節(jié)流構(gòu)成，建議通過(guò)BufferedReader包裝Reader的實(shí)例類(lèi)以提高效率?

Reader構(gòu)成的對(duì)象是字符對(duì)象，每次的讀取請(qǐng)求都會(huì)涉及到字節(jié)讀取解碼字符的過(guò)程，而B(niǎo)ufferedReader類(lèi)中有設(shè)計(jì)減少這樣的解碼次數(shù)的方法，進(jìn)而提高轉(zhuǎn)換效率

4）BufferedReader替代DataInputStreams進(jìn)行本地化？

需要查看DataInputStreams源碼后才可知

二、BufferedReader類(lèi)實(shí)例域

    // 字符輸入流
    private Reader in; 
    // 字符緩沖區(qū)
    private char cb[]; 
    //讀取字符存儲(chǔ)的最末下標(biāo)+1
    private int nChars; 
    //讀取字符存儲(chǔ)的起始下標(biāo)
    private int nextChar; 
    private static final int INVALIDATED = -2;
    private static final int UNMARKED = -1;
    private int markedChar = UNMARKED;
 
    // 僅在markedChar為0時(shí)有效
    private int readAheadLimit = 0;
 
    // 如果下個(gè)字符是換行符，則跳過(guò)--專(zhuān)用于readLine()方法里面控制
    private boolean skipLF = false;
 
    // 設(shè)置標(biāo)志時(shí)的markedSkipLF--用于mark()方法的變量
    private boolean markedSkipLF = false;
 
    // 默認(rèn)的字符緩沖大小
    private static int defaultCharBufferSize =8192;
    
    //用于readLine()方法時(shí)初始化StringBuffer的初始容量
    private static int defaultExpectedLineLength = 80;

三、BufferedReader類(lèi)構(gòu)造函數(shù)

1）使用默認(rèn)的緩沖區(qū)大小來(lái)創(chuàng)建緩沖字符輸入流，默認(rèn)大小為8192個(gè)字符

   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）創(chuàng)建指定緩沖區(qū)大小的緩沖字符輸入流，一般使用默認(rèn)即可

  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類(lèi)API

1）read()方法：讀取1個(gè)或多個(gè)字節(jié)，返回一個(gè)字符，當(dāng)讀取到文件末尾時(shí)，返回-1

    /**
     * 讀取一個(gè)字符，若讀取到末尾則返回-1
     */
    public int read() throws IOException
    {
        synchronized (lock)
        {
            ensureOpen();
            for (;;)
            {
 
                 //一般條件為真，除非是使用了skip方法跳躍字節(jié)
                if (nextChar >= nChars)
                {
                    fill();  //調(diào)用該方法讀取字符
 
                    if (nextChar >= nChars)
                        return -1;
                }
 
                 //此方法暫時(shí)不用管，涉及跳過(guò)字節(jié)數(shù)和換行符問(wèn)題
                if (skipLF) 
                {
                    skipLF = false;
                    if (cb[nextChar] == '\n')
                    {
                        nextChar++;
                        continue;
                    }
                }
                return cb[nextChar++];
            }
        }
    }

實(shí)際流程圖解：

2）fill()方法：從底層輸入流中填充字符到緩沖區(qū)中，此方法會(huì)調(diào)用StreamDecoder的方法實(shí)現(xiàn)字節(jié)到字符的轉(zhuǎn)換

    /**
     * 填充字符緩沖區(qū)，若有效則將標(biāo)記考慮在內(nèi)
     */
    private void fill() throws IOException
    {
        int dst;
        
        //查看是否調(diào)用過(guò)make方法進(jìn)行標(biāo)記--若未使用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
        {
            
          //調(diào)用InputStreamReader的方法，實(shí)際是調(diào)用StreamDecoder的read(char cbuf[], int offset, int length)方法   
            n = in.read(cb, dst, cb.length - dst);  
        }
        while (n == 0);
        if (n > 0)   //當(dāng)讀取到字符時(shí)
        {
            nChars = dst + n;   //字符緩沖區(qū)存儲(chǔ)讀到的字符的最末下標(biāo)
            nextChar = dst;     //字符緩沖區(qū)存儲(chǔ)讀到的字符的起始下標(biāo)
        }
    }

實(shí)際流程圖解：注意根據(jù)read()方法先理解變量nChars和nextChar的意義

3）read(char cbuf[], int off, int len)：將最多l(xiāng)ength個(gè)字符讀入數(shù)組中，返回實(shí)際讀入的字符個(gè)數(shù)，當(dāng)讀取到文件末尾時(shí)，返回-1，

    /**
     * 字符讀入數(shù)組的一部分，
     */
    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); // 調(diào)用read1(cbuf, off, len)
            if (n <= 0)
                return n;
            while ((n < len) && in.ready())   // 注意該while循環(huán)，多次測(cè)試發(fā)現(xiàn)并未進(jìn)入該方法，即使進(jìn)入，本質(zhì)還是調(diào)用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)
        {
 
            // 若請(qǐng)求的長(zhǎng)度與緩沖區(qū)長(zhǎng)度一樣大時(shí)，直接會(huì)把字符讀取到數(shù)組中，并未使用該類(lèi)的字符緩沖區(qū)
 
            if (len >= cb.length && markedChar <= UNMARKED && !skipLF)
            {
                return in.read(cbuf, off, len);
            }
            fill();
        }
        if (nextChar >= nChars)
            return -1;
        if (skipLF) //若使用了換行、跳過(guò)字節(jié)數(shù)等才會(huì)考慮判斷，暫時(shí)不用管
        {
            skipLF = false;
            if (cb[nextChar] == '\n')
            {
                nextChar++;
                if (nextChar >= nChars)
                    fill();
                if (nextChar >= nChars)
                    return -1;
            }
        }
        
        int n = Math.min(len, nChars - nextChar); //取實(shí)際讀取字符數(shù)與目標(biāo)字符數(shù)len的最小數(shù)        
        System.arraycopy(cb, nextChar, cbuf, off, n);  //從字符緩沖區(qū)中復(fù)制字符到目標(biāo)數(shù)組中        
        nextChar += n; //字符緩沖區(qū)存儲(chǔ)下標(biāo)位置前諾，避免重復(fù)取一樣數(shù)據(jù)        
        return n;
    }

實(shí)際流程圖解：圖解read1(cbuf, off, len)方法即可，本質(zhì)是該方法在起作用

4）讀一行文字并返回該行字符，若讀到文件末尾，則返回null：即當(dāng)遇到換行符（'\ n'），回車(chē)符（'\ r'）時(shí)會(huì)終止讀取表示該行文字讀取完畢且返回該行文字（不包含換行符和回車(chē)符）

   /**
     * 閱讀一行文字，任何一條線都被視為終止，返回包含該行內(nèi)容的字符串，但是不含換行符等
     */
    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) //判斷是否有元素，沒(méi)有則調(diào)用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;
 
               //如果遇到過(guò)換行符，則跳過(guò)該換行符繼續(xù)讀取
                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);
            }
        }
    }

實(shí)際流程圖解：

5）close()方法：關(guān)閉資源釋放鏈接

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

6）其它的skip()、make()方法等暫時(shí)不了解

五、BufferedReader類(lèi)與InputStreamReader類(lèi)比較

InputStreamReader中的文檔說(shuō)明提到過(guò)：為了獲得最高效率，請(qǐng)考慮在BufferedReader中包裝InputStreamReader？

從read()方法理解，若使用InputStreamReader的read()方法，可以發(fā)現(xiàn)存在每2次就會(huì)調(diào)用一次解碼器解碼，但若是使用 BufferedReader包裝InputStreamReader后調(diào)用read()方法，可以發(fā)現(xiàn)只會(huì)調(diào)用一次解碼器解碼，其余時(shí)候都是直接從BufferedReader的緩沖區(qū)中取字符即可

從read(char cbuf[], int offset, int length)方法理解，若使用InputStreamReader的方法則只會(huì)讀取leng個(gè)字符，但是使用BufferedReader類(lèi)則會(huì)讀取讀取8192個(gè)字符，會(huì)盡量提取比當(dāng)前操作所需的更多字節(jié)；

例如文件中有20個(gè)字符，我們先通過(guò)read(cbuf,0,5)要讀取5個(gè)字符到數(shù)組cbuf中，然后再通過(guò)read()方法讀取1個(gè)字符。那么使用InputStreamReader類(lèi)的話，則會(huì)調(diào)用一次解碼器解碼然后存儲(chǔ)5個(gè)字符到數(shù)組中，然后又調(diào)用read()方法調(diào)用一次解碼器讀取2個(gè)字符，然后返回1個(gè)字符；等于是調(diào)用了2次解碼器，若使用BufferedReader類(lèi)的話則是先調(diào)用一次解碼器讀取20個(gè)字符到字符緩沖區(qū)中，然后復(fù)制5個(gè)到數(shù)組中，在調(diào)用read()方法時(shí)，則直接從緩沖區(qū)中讀取字符，等于是調(diào)用了一次解碼器

因此可以看出BufferedReader類(lèi)會(huì)盡量提取比當(dāng)前操作所需的更多字節(jié)，以應(yīng)該更多情況下的效率提升，

因此在設(shè)計(jì)到文件字符輸入流的時(shí)候，我們使用BufferedReader中包裝InputStreamReader類(lèi)即可

以上為個(gè)人經(jīng)驗(yàn)，希望能給大家一個(gè)參考，也希望大家多多支持腳本之家。

您可能感興趣的文章: