java io系列02之 ByteArrayInputStream的簡介,源碼分析和示例(包括InputStream)

我們以ByteArrayInputStream，拉開對字節類型的“輸入流”的學習序幕。
本章，我們會先對ByteArrayInputStream進行介紹，然后深入了解一下它的源碼，最后通過示例來掌握它的用法。

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

ByteArrayInputStream 介紹

ByteArrayInputStream 是字節數組輸入流。它繼承於InputStream。
它包含一個內部緩沖區，該緩沖區包含從流中讀取的字節；通俗點說，它的內部緩沖區就是一個字節數組，而ByteArrayInputStream本質就是通過字節數組來實現的。
我們都知道，InputStream通過read()向外提供接口，供它們來讀取字節數據；而ByteArrayInputStream 的內部額外的定義了一個計數器，它被用來跟蹤 read() 方法要讀取的下一個字節。

InputStream 函數列表

// 構造函數
InputStream()

             int     available()
             void    close()
             void    mark(int readlimit)
             boolean markSupported()
             int     read(byte[] buffer)
abstract     int     read()
             int     read(byte[] buffer, int offset, int length)
synchronized void    reset()
             long    skip(long byteCount)

ByteArrayInputStream 函數列表

// 構造函數
ByteArrayInputStream(byte[] buf)
ByteArrayInputStream(byte[] buf, int offset, int length)

synchronized int         available()
             void        close()
synchronized void        mark(int readlimit)
             boolean     markSupported()
synchronized int         read()
synchronized int         read(byte[] buffer, int offset, int length)
synchronized void        reset()
synchronized long        skip(long byteCount)

InputStream和ByteArrayInputStream源碼分析

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

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

package java.io;

public abstract class InputStream implements Closeable {

    // 能skip的大小
    private static final int MAX_SKIP_BUFFER_SIZE = 2048;

    // 從輸入流中讀取數據的下一個字節。
    public abstract int read() throws IOException;

    // 將數據從輸入流讀入 byte 數組。
    public int read(byte b[]) throws IOException {
        return read(b, 0, b.length);
    }

    // 將最多 len 個數據字節從此輸入流讀入 byte 數組。
    public int read(byte b[], int off, int len) throws IOException {
        if (b == null) {
            throw new NullPointerException();
        } else if (off < 0 || len < 0 || len > b.length - off) {
            throw new IndexOutOfBoundsException();
        } else if (len == 0) {
            return 0;
        }

        int c = read();
        if (c == -1) {
            return -1;
        }
        b[off] = (byte)c;

        int i = 1;
        try {
            for (; i < len ; i++) {
                c = read();
                if (c == -1) {
                    break;
                }
                b[off + i] = (byte)c;
            }
        } catch (IOException ee) {
        }
        return i;
    }

    // 跳過輸入流中的n個字節
    public long skip(long n) throws IOException {

        long remaining = n;
        int nr;

        if (n <= 0) {
            return 0;
        }

        int size = (int)Math.min(MAX_SKIP_BUFFER_SIZE, remaining);
        byte[] skipBuffer = new byte[size];
        while (remaining > 0) {
            nr = read(skipBuffer, 0, (int)Math.min(size, remaining));
            if (nr < 0) {
                break;
            }
            remaining -= nr;
        }

        return n - remaining;
    }

    public int available() throws IOException {
        return 0;
    }

    public void close() throws IOException {}

    public synchronized void mark(int readlimit) {}

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

    public boolean markSupported() {
        return false;
    }
}

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

package java.io;

public class ByteArrayInputStream extends InputStream {

    // 保存字節輸入流數據的字節數組
    protected byte buf[];

    // 下一個會被讀取的字節的索引
    protected int pos;

    // 標記的索引
    protected int mark = 0;

    // 字節流的長度
    protected int count;

    // 構造函數：創建一個內容為buf的字節流
    public ByteArrayInputStream(byte buf[]) {
        // 初始化“字節流對應的字節數組為buf”
        this.buf = buf;
        // 初始化“下一個要被讀取的字節索引號為0”
        this.pos = 0;
        // 初始化“字節流的長度為buf的長度”
        this.count = buf.length;
    }

    // 構造函數：創建一個內容為buf的字節流，並且是從offset開始讀取數據，讀取的長度為length
    public ByteArrayInputStream(byte buf[], int offset, int length) {
        // 初始化“字節流對應的字節數組為buf”
        this.buf = buf;
        // 初始化“下一個要被讀取的字節索引號為offset”
        this.pos = offset;
        // 初始化“字節流的長度”
        this.count = Math.min(offset + length, buf.length);
        // 初始化“標記的字節流讀取位置”
        this.mark = offset;
    }

    // 讀取下一個字節
    public synchronized int read() {
        return (pos < count) ? (buf[pos++] & 0xff) : -1;
    }

    // 將“字節流的數據寫入到字節數組b中”
    // off是“字節數組b的偏移地址”，表示從數組b的off開始寫入數據
    // len是“寫入的字節長度”
    public synchronized int read(byte b[], int off, int len) {
        if (b == null) {
            throw new NullPointerException();
        } else if (off < 0 || len < 0 || len > b.length - off) {
            throw new IndexOutOfBoundsException();
        }

        if (pos >= count) {
            return -1;
        }

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

    // 跳過“字節流”中的n個字節。
    public synchronized long skip(long n) {
        long k = count - pos;
        if (n < k) {
            k = n < 0 ? 0 : n;
        }

        pos += k;
        return k;
    }

    // “能否讀取字節流的下一個字節”
    public synchronized int available() {
        return count - pos;
    }

    // 是否支持“標簽”
    public boolean markSupported() {
        return true;
    }

    // 保存當前位置。readAheadLimit在此處沒有任何實際意義
    public void mark(int readAheadLimit) {
        mark = pos;
    }

    // 重置“字節流的讀取索引”為“mark所標記的位置”
    public synchronized void reset() {
        pos = mark;
    }

    public void close() throws IOException {
    }
}

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

示例代碼

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

import java.io.ByteArrayInputStream;
import java.io.ByteArrayOutputStream;

/**
 * ByteArrayInputStream 測試程序
 *
 * @author skywang
 */
public class ByteArrayInputStreamTest {

    private static final int LEN = 5;
    // 對應英文字母“abcddefghijklmnopqrsttuvwxyz”
    private static final byte[] ArrayLetters = {
        0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F,
        0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A
    };

    public static void main(String[] args) {
        String tmp = new String(ArrayLetters);
        System.out.println("ArrayLetters="+tmp);

        tesByteArrayInputStream() ;
    }

    /**
     * ByteArrayInputStream的API測試函數
     */
    private static void tesByteArrayInputStream() {
        // 創建ByteArrayInputStream字節流，內容是ArrayLetters數組
        ByteArrayInputStream bais = new ByteArrayInputStream(ArrayLetters);

        // 從字節流中讀取5個字節
        for (int i=0; i<LEN; i++) {
            // 若能繼續讀取下一個字節，則讀取下一個字節
            if (bais.available() >= 0) {
                // 讀取“字節流的下一個字節”
                int tmp = bais.read();
                System.out.printf("%d : 0x%s\n", i, Integer.toHexString(tmp));
            }
        }

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

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

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

        // 從字節流中讀取5個數據。即讀取“0x6B, 0x6C, 0x6D, 0x6E, 0x6F”
        byte[] buf = new byte[LEN];
        bais.read(buf, 0, LEN);
        // 將buf轉換為String字符串。“0x6B, 0x6C, 0x6D, 0x6E, 0x6F”對應字符是“klmno”
        String str1 = new String(buf);
        System.out.printf("str1=%s\n", str1);
    
        // 重置“字節流”：即，將“字節流中下一個被讀取的位置”重置到“mark()所標記的位置”，即0x66。
        bais.reset();
        // 從“重置后的字節流”中讀取5個字節到buf中。即讀取“0x66, 0x67, 0x68, 0x69, 0x6A”
        bais.read(buf, 0, LEN);
        // 將buf轉換為String字符串。“0x66, 0x67, 0x68, 0x69, 0x6A”對應字符是“fghij”
        String str2 = new String(buf);
        System.out.printf("str2=%s\n", str2);
    }
}

運行結果：
ArrayLetters=abcdefghijklmnopqrstuvwxyz
0 : 0x61
1 : 0x62
2 : 0x63
3 : 0x64
4 : 0x65
str1=klmno
str2=fghij
結果說明：
(01) ArrayLetters 是字節數組。0x61對應的ASCII碼值是a，0x62對應的ASCII碼值是b，依次類推...
(02) ByteArrayInputStream bais = new ByteArrayInputStream(ArrayLetters); 這句話是創建“字節流bais”，它的內容就是ArrayLetters。
(03) for (int i=0; i<LEN; i++) ; 這個for循環的作用就是從字節流中讀取5個字節。每次調用bais.read()就從字節流中讀取一個字節。
(04) bais.mark(0); 這句話就是“設置字節流的標記”，此時標記的位置對應的值是0x66。
(05) bais.skip(5); 這句話是跳過5個字節。跳過5個字節后，對應的字節流中下一個被讀取的字節的值是0x6B。
(06) bais.read(buf, 0, LEN); 這句話是“從字節流中讀取LEN個數據寫入到buf中，0表示從buf的第0個位置開始寫入”。
(07) bais.reset(); 這句話是將“字節流中下一個被讀取的位置”重置到“mark()所標記的位置”，即0x66。

學完了ByteArrayInputStream輸入流。下面，我們學習與之對應的輸出流ByteArrayOutputStream。

---

更多內容

1. java 集合系列目錄(Category)

2. java io系列01之 IO框架

3. java io系列02之 ByteArrayInputStream的簡介,源碼分析和示例(包括InputStream)

4. java io系列03之 ByteArrayOutputStream的簡介,源碼分析和示例(包括OutputStream)