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

来源：互联网发布：pokemon go坐标软件编辑：程序博客网时间：2024/05/03 18:51

本文摘抄至： skywang12345
摘要： 介绍了 InputStream超类中的定义方法和ByteArrayInputStream的源码解析（基于JDK 1.7）。最后同个小示例表达其大致的用法

我们以ByteArrayInputStream，拉开对字节类型的“输入流”的学习序幕。
本章，我们会先对ByteArrayInputStream进行介绍，然后深入了解一下它的源码，最后通过示例来掌握它的用法。

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)

 1 package java.io; 2  3 public abstract class InputStream implements Closeable { 4  5     // 能skip的大小 6     private static final int MAX_SKIP_BUFFER_SIZE = 2048; 7  8     // 从输入流中读取数据的下一个字节。 9     public abstract int read() throws IOException;10 11     // 将数据从输入流读入 byte 数组。12     public int read(byte b[]) throws IOException {13         return read(b, 0, b.length);14     }15 16     // 将最多 len 个数据字节从此输入流读入 byte 数组。17     public int read(byte b[], int off, int len) throws IOException {18         if (b == null) {19             throw new NullPointerException();20         } else if (off < 0 || len < 0 || len > b.length - off) {21             throw new IndexOutOfBoundsException();22         } else if (len == 0) {23             return 0;24         }25 26         int c = read();27         if (c == -1) {28             return -1;29         }30         b[off] = (byte)c;31 32         int i = 1;33         try {34             for (; i < len ; i++) {35                 c = read();36                 if (c == -1) {37                     break;38                 }39                 b[off + i] = (byte)c;40             }41         } catch (IOException ee) {42         }43         return i;44     }45 46     // 跳过输入流中的n个字节47     public long skip(long n) throws IOException {48 49         long remaining = n;50         int nr;51 52         if (n <= 0) {53             return 0;54         }55 56         int size = (int)Math.min(MAX_SKIP_BUFFER_SIZE, remaining);57         byte[] skipBuffer = new byte[size];58         while (remaining > 0) {59             nr = read(skipBuffer, 0, (int)Math.min(size, remaining));60             if (nr < 0) {61                 break;62             }63             remaining -= nr;64         }65 66         return n - remaining;67     }68 69     public int available() throws IOException {70         return 0;71     }72 73     public void close() throws IOException {}74 75     public synchronized void mark(int readlimit) {}76 77     public synchronized void reset() throws IOException {78         throw new IOException("mark/reset not supported");79     }80 81     public boolean markSupported() {82         return false;83     }84 }

2. ByteArrayInputStream.java源码分析(基于jdk1.7.40)

  1 package java.io;  2   3 public class ByteArrayInputStream extends InputStream {  4   5     // 保存字节输入流数据的字节数组  6     protected byte buf[];  7   8     // 下一个会被读取的字节的索引  9     protected int pos; 10  11     // 标记的索引 12     protected int mark = 0; 13  14     // 字节流的长度 15     protected int count; 16  17     // 构造函数：创建一个内容为buf的字节流 18     public ByteArrayInputStream(byte buf[]) { 19         // 初始化“字节流对应的字节数组为buf” 20         this.buf = buf; 21         // 初始化“下一个要被读取的字节索引号为0” 22         this.pos = 0; 23         // 初始化“字节流的长度为buf的长度” 24         this.count = buf.length; 25     } 26  27     // 构造函数：创建一个内容为buf的字节流，并且是从offset开始读取数据，读取的长度为length 28     public ByteArrayInputStream(byte buf[], int offset, int length) { 29         // 初始化“字节流对应的字节数组为buf” 30         this.buf = buf; 31         // 初始化“下一个要被读取的字节索引号为offset” 32         this.pos = offset; 33         // 初始化“字节流的长度” 34         this.count = Math.min(offset + length, buf.length); 35         // 初始化“标记的字节流读取位置” 36         this.mark = offset; 37     } 38  39     // 读取下一个字节 40     public synchronized int read() { 41         return (pos < count) ? (buf[pos++] & 0xff) : -1; 42     } 43  44     // 将“字节流的数据写入到字节数组b中” 45     // off是“字节数组b的偏移地址”，表示从数组b的off开始写入数据 46     // len是“写入的字节长度” 47     public synchronized int read(byte b[], int off, int len) { 48         if (b == null) { 49             throw new NullPointerException(); 50         } else if (off < 0 || len < 0 || len > b.length - off) { 51             throw new IndexOutOfBoundsException(); 52         } 53  54         if (pos >= count) { 55             return -1; 56         } 57  58         int avail = count - pos; 59         if (len > avail) { 60             len = avail; 61         } 62         if (len <= 0) { 63             return 0; 64         } 65         System.arraycopy(buf, pos, b, off, len); 66         pos += len; 67         return len; 68     } 69  70     // 跳过“字节流”中的n个字节。 71     public synchronized long skip(long n) { 72         long k = count - pos; 73         if (n < k) { 74             k = n < 0 ? 0 : n; 75         } 76  77         pos += k; 78         return k; 79     } 80  81     // “能否读取字节流的下一个字节” 82     public synchronized int available() { 83         return count - pos; 84     } 85  86     // 是否支持“标签” 87     public boolean markSupported() { 88         return true; 89     } 90  91     // 保存当前位置。readAheadLimit在此处没有任何实际意义 92     public void mark(int readAheadLimit) { 93         mark = pos; 94     } 95  96     // 重置“字节流的读取索引”为“mark所标记的位置” 97     public synchronized void reset() { 98         pos = mark; 99     }100 101     public void close() throws IOException {102     }103 }

说明：
ByteArrayInputStream实际上是通过“字节数组”去保存数据。

通过ByteArrayInputStream（byte buf[]）或 ByteArrayInputStream(byte buf[], int offset, int length) ，我们可以根据 buf 数组来创建字节流对象。
read（)的作用是从字节流中“读取下一个字节”。
read(byte[] buffer, int offset, int length)的作用是从字节流读取字节数据，并写入到字节数组 buffer 中。offset是将字节写入到 buffer 的起始位置，length 是写入字节的长度。
markSupported（）是判断字节流是否支持“标记功能”。它一直返回 true。
mark（int readlimit）的作用是记录标记位置。记录标记位置之后，某一刻调用 reset（）则将“字节流下一个被读取的位置”重置到“mark（int readlimit）所标记的位置”；也就是说，reset（）之后再读取字节流时，是从mark（int readlimit）所标记的位置开始读取。

示例代码

关于ByteArrayInputStream中API的详细用法，参考示例代码(ByteArrayInputStreamTest.java)：

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
其中“%d : 0x%s\n”、”str1=%s\n”等是 C 的一种方式。

结果说明：

ArrayLetters 是字节数组。0x61对应的ASCII码值是a，0x62对应的ASCII码值是b，依次类推…
ByteArrayInputStream bais = new ByteArrayInputStream（ArrayLetters）；这句话是创建“字节流 bais”，它的内容就是 ArrayLetters。
for (int i=0; i < LEN; i++) ; 这for循环的作用就是从字节流中读取 5 个字节。每一次调用 bais。read（）就是从字节流中读取一个字节
bais.mark(0);这句话就是“设置字节流的标记”，此时标记的位置对应值是 0x66。
bais.skip(5)；这句话是跳过 5个字节，跳过 5个字节后，对应的字节流中下一个被读取的字节的值就是 0x6B。
bais.read(buf, 0, LEN）;这句话是“从字节流中读取 LEN个数据写入到 buf中，0 表示从 buf 的第 0 个位置开始写入”。
bais.reset( )；这句话是将“字节流中下一个被读取的位置”重置到“mark（）所标记的位置”，即 0x66。

0 0