java io系列18之 CharArrayReader(字符數組輸入流)

從本章開始，我們開始對java io中的“字符流”進行學習。首先，要學習的是CharArrayReader。學習時，我們先對CharArrayReader有個大致了解，然后深入了解一下它的源碼，最后通過示例來掌握它的用法。

轉載請注明出處：http://www.cnblogs.com/skywang12345/p/io_18.html

CharArrayReader 介紹

CharArrayReader 是字符數組輸入流。它和ByteArrayInputStream類似，只不過ByteArrayInputStream是字節數組輸入流，而CharArray是字符數組輸入流。CharArrayReader 是用於讀取字符數組，它繼承於Reader。操作的數據是以字符為單位！

CharArrayReader 函數列表

CharArrayReader(char[] buf)
CharArrayReader(char[] buf, int offset, int length)

void      close()
void      mark(int readLimit)
boolean   markSupported()
int       read()
int       read(char[] buffer, int offset, int len)
boolean   ready()
void      reset()
long      skip(long charCount)

 

Reader和CharArrayReader源碼分析

Reader是CharArrayReader的父類，我們先看看Reader的源碼，然后再學CharArrayReader的源碼。

1. Reader源碼分析(基於jdk1.7.40)

package java.io;

public abstract class Reader implements Readable, Closeable {

    protected Object lock;

    protected Reader() {
        this.lock = this;
    }

    protected Reader(Object lock) {
        if (lock == null) {
            throw new NullPointerException();
        }
        this.lock = lock;
    }

    public int read(java.nio.CharBuffer target) throws IOException {
        int len = target.remaining();
        char[] cbuf = new char[len];
        int n = read(cbuf, 0, len);
        if (n > 0)
            target.put(cbuf, 0, n);
        return n;
    }

    public int read() throws IOException {
        char cb[] = new char[1];
        if (read(cb, 0, 1) == -1)
            return -1;
        else
            return cb[0];
    }

    public int read(char cbuf[]) throws IOException {
        return read(cbuf, 0, cbuf.length);
    }

    abstract public int read(char cbuf[], int off, int len) throws IOException;

    private static final int maxSkipBufferSize = 8192;

    private char skipBuffer[] = null;

    public long skip(long n) throws IOException {
        if (n < 0L)
            throw new IllegalArgumentException("skip value is negative");
        int nn = (int) Math.min(n, maxSkipBufferSize);
        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;
        }
    }

    public boolean ready() throws IOException {
        return false;
    }

    public boolean markSupported() {
        return false;
    }

    public void mark(int readAheadLimit) throws IOException {
        throw new IOException("mark() not supported");
    }

    public void reset() throws IOException {
        throw new IOException("reset() not supported");
    }

     abstract public void close() throws IOException;
}

2. CharArrayReader 源碼分析(基於jdk1.7.40)

package java.io;

public class CharArrayReader extends Reader {
    // 字符數組緩沖
    protected char buf[];

    // 下一個被獲取的字符的位置
    protected int pos;

    // 被標記的位置
    protected int markedPos = 0;

    // 字符緩沖的長度
    protected int count;

    // 構造函數
    public CharArrayReader(char buf[]) {
        this.buf = buf;
        this.pos = 0;
        this.count = buf.length;
    }

    // 構造函數
    public CharArrayReader(char buf[], int offset, int length) {
        if ((offset < 0) || (offset > buf.length) || (length < 0) ||
            ((offset + length) < 0)) {
            throw new IllegalArgumentException();
        }
        this.buf = buf;
        this.pos = offset;
        this.count = Math.min(offset + length, buf.length);
        this.markedPos = offset;
    }

    // 判斷“CharArrayReader是否有效”。
    // 若字符緩沖為null，則認為其無效。
    private void ensureOpen() throws IOException {
        if (buf == null)
            throw new IOException("Stream closed");
    }

    // 讀取下一個字符。即返回字符緩沖區中下一位置的值。
    // 注意：讀取的是字符！
    public int read() throws IOException {
        synchronized (lock) {
            ensureOpen();
            if (pos >= count)
                return -1;
            else
                return buf[pos++];
        }
    }

    // 讀取數據，並保存到字符數組b中從off開始的位置中，len是讀取長度。
    public int read(char b[], int off, int len) throws IOException {
        synchronized (lock) {
            ensureOpen();
            if ((off < 0) || (off > b.length) || (len < 0) ||
                ((off + len) > b.length) || ((off + len) < 0)) {
                throw new IndexOutOfBoundsException();
            } else if (len == 0) {
                return 0;
            }

            if (pos >= count) {
                return -1;
            }
            if (pos + len > count) {
                len = count - pos;
            }
            if (len <= 0) {
                return 0;
            }
            System.arraycopy(buf, pos, b, off, len);
            pos += len;
            return len;
        }
    }

    // 跳過n個字符
    public long skip(long n) throws IOException {
        synchronized (lock) {
            ensureOpen();
            if (pos + n > count) {
                n = count - pos;
            }
            if (n < 0) {
                return 0;
            }
            pos += n;
            return n;
        }
    }

    // 判斷“是否能讀取下一個字符”。能的話，返回true。
    public boolean ready() throws IOException {
        synchronized (lock) {
            ensureOpen();
            return (count - pos) > 0;
        }
    }

    public boolean markSupported() {
        return true;
    }

    // 保存當前位置。readAheadLimit在此處沒有任何實際意義
    // mark()必須和reset()配合使用才有意義！
    public void mark(int readAheadLimit) throws IOException {
        synchronized (lock) {
            ensureOpen();
            markedPos = pos;
        }
    }

    // 重置“下一個讀取位置”為“mark所標記的位置”
    public void reset() throws IOException {
        synchronized (lock) {
            ensureOpen();
            pos = markedPos;
        }
    }

    public void close() {
        buf = null;
    }
}

說明：
CharArrayReader實際上是通過“字符數組”去保存數據。

(01) 通過 CharArrayReader(char[] buf) 或 CharArrayReader(char[] buf, int offset, int length) ，我們可以根據buf數組來創建CharArrayReader對象。
(02) read()的作用是從CharArrayReader中“讀取下一個字符”。
(03) read(char[] buffer, int offset, int len)的作用是從CharArrayReader讀取字符數據，並寫入到字符數組buffer中。offset是將字符寫入到buffer的起始位置，len是寫入的字符的長度。
(04) markSupported()是判斷CharArrayReader是否支持“標記功能”。它始終返回true。
(05) mark(int readlimit)的作用是記錄標記位置。記錄標記位置之后，某一時刻調用reset()則將“CharArrayReader下一個被讀取的位置”重置到“mark(int readlimit)所標記的位置”；也就是說，reset()之后再讀取CharArrayReader時，是從mark(int readlimit)所標記的位置開始讀取。

 

示例代碼

關於CharArrayReader中API的詳細用法，參考示例代碼(CharArrayReaderTest.java)： 

/**
 * CharArrayReader 演示程序
 *
 * @author skywang
 */

import java.io.CharArrayReader;
import java.io.CharArrayWriter;
import java.io.IOException;

public class CharArrayReaderTest {

    private static final int LEN = 5;
    // 對應英文字母“abcdefghijklmnopqrstuvwxyz”
    private static final char[] ArrayLetters = new char[] {'a','b','c','d','e','f','g','h','i','j','k','l','m','n','o','p','q','r','s','t','u','v','w','x','y','z'};
    
    public static void main(String[] args) {
        tesCharArrayReader() ;
    }

    /**
     * CharArrayReader的API測試函數
     */
    private static void tesCharArrayReader() {
        try {
            // 創建CharArrayReader字符流，內容是ArrayLetters數組
            CharArrayReader car = new CharArrayReader(ArrayLetters);

            // 從字符數組流中讀取5個字符
            for (int i=0; i<LEN; i++) {
                // 若能繼續讀取下一個字符，則讀取下一個字符
                if (car.ready() == true) {
                    // 讀取“字符流的下一個字符”
                    char tmp = (char)car.read();
                    System.out.printf("%d : %c\n", i, tmp);
                }
            }

            // 若“該字符流”不支持標記功能，則直接退出
            if (!car.markSupported()) {
                System.out.println("make not supported!");
                return ;
            }

            // 標記“字符流中下一個被讀取的位置”。即--標記“f”，因為因為前面已經讀取了5個字符，所以下一個被讀取的位置是第6個字符”
            // (01), CharArrayReader類的mark(0)函數中的“參數0”是沒有實際意義的。
            // (02), mark()與reset()是配套的，reset()會將“字符流中下一個被讀取的位置”重置為“mark()中所保存的位置”
            car.mark(0);

            // 跳過5個字符。跳過5個字符后，字符流中下一個被讀取的值應該是“k”。
            car.skip(5);

            // 從字符流中讀取5個數據。即讀取“klmno”
            char[] buf = new char[LEN];
            car.read(buf, 0, LEN);
            System.out.printf("buf=%s\n", String.valueOf(buf));
        
            // 重置“字符流”：即，將“字符流中下一個被讀取的位置”重置到“mark()所標記的位置”，即f。
            car.reset();
            // 從“重置后的字符流”中讀取5個字符到buf中。即讀取“fghij”
            car.read(buf, 0, LEN);
            System.out.printf("buf=%s\n", String.valueOf(buf));
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

運行結果：

0 : a
1 : b
2 : c
3 : d
4 : e
buf=klmno
buf=fghij