ByteArrayInputStream类

一、说明

哈哈，这是学习Java之路的第一篇博文。虽然说接触学习Java有一段时间了，但是对流的概念一直并不是很清楚。也看了很多资料，但是感觉还是非常的抽象很难去理解。但是流又是Java中很重要的一部分，所以就决定花点时间好好弄一下。这篇文章也并非全部是我的原创文章，我浏览了写的比较好的博客，将其修改添加，加上一些自己的看法，就当成自己学习的笔记。仅供学习参考。参考原文链接

 

二、ByteArrayInputStream类

流的概念真的是挺令人困惑的。有一本书中说：流代表任何有能力产出数据的数据流对象，或者有能力接收数据的接收端对象。开始也是不理解的，后来结合流类的jdk源码，测试实例仔细想一下，好像是这么回事。这个流的定义好在把抽象的流定义在了对象上。

再来说一下ByteArrayInputStream类。
ByteArrayInputStream 是字节数组输入流。它继承于InputStream。
它包含一个内部缓冲区，该缓冲区包含从流中读取的字节；通俗点说，它的内部缓冲区就是一个字节数组，而ByteArrayInputStream本质就是通过字节数组来实现的。
我们都知道，InputStream通过read()向外提供接口，供它们来读取字节数据；而ByteArrayInputStream 的内部额外的定义了一个计数器，它被用来跟踪 read() 方法要读取的下一个字节。

 

InputStream类

InputStream类函数列表

函数	返回值	功能
public int read()  throws IOEXception	返回下一个数据字节 （返回 0 到 255 范围内的 int 字节值）	从输入流中读取数据的下一个字节
public int read(byte[] b)  throws IOEXception	以整数形式返回实际读取的字节数。 如果因为已经到达流末尾而不再有数据可用， 则返回 -1	从输入流中读取一定数量的字节， 并将其存储在缓冲区数组 b 中
public int read(byte[] b,int off,int len)          throws IOEXception	读入缓冲区的总字节数； 如果因为已到达流末尾而不再有数据可用， 则返回 -1。	将输入流中最多 len 个数据字节读入 byte 数
public long skip(long n)  throws IOEXception	跳过的实际字节数	跳过和丢弃此输入流中数据的 n 个字
public int available()  throws IOEXception	可以不受阻塞地从此输入流读取 （或跳过）的估计字节数	返回此输入流下一个方法调用 可以不受阻塞地从此输入流读取 （或跳过）的估计字节数
public boolean markSupported()	如果此输入流实例支持 mark 和 reset 方法， 则返回 true；否则返回 false。	测试此输入流是否支持 mark 和 reset 方法
public void mark(int readlimit)	无	在此输入流中标记当前的位置
public void reset() throws IOEXception	无	将此流重新定位到最后一次对此输入流 调用 mark 方法时的位置
public void close() throws IOEXception	无	关闭此输入流并释放与该流关联的所有系统资源

关于上表的解释：

1.可以这样理解read()函数里的“读取下一个字节”，就是光标在前

2.mark()方法的参数在实现中没有什么实际的意义。

3.InputStream 的 close 方法不执行任何操作。

4.由于InputStream类是所以输入流的父类，方法的实现也就没有那么具体，它相当于给出了一个方法的规范，它的所以子类会按照这个规范去实现方法。也就是说，其子类方法的实现尽管不同，提供的功能却是相同的。

5.想了解更加详细的信息可以去查看jdk文档，是学习java很重要的工具。jdk文档

 

InputStream类源码分析

由于上述给出了此类函数比较详细的介绍，所以这里不作关于源码太多的说明。

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;
    }
}

说明：

1.Closeable 接口表示可以关闭的数据源或目标。这个接口只有一个方法close()。

ByteArrayInputStream类

如果还是觉得上面的内容理解起来还是很抽象，很难懂。没有关系，结合这个具体的InputStream类具体的子类ByteArrayInputStream类来看，会帮助你解开一部分困惑。计算机的学习就是这个样子，后面的知识需要前面的知识作为铺垫，前面的知识需要后面的知识才可以更深的理解。所以要前前后后的看一下，才可以真正的理解。

ByteArrayInputStream 包含一个内部缓冲区，该缓冲区包含从流中读取的字节。内部计数器跟踪 read 方法要提供的下一个字节。

关闭 ByteArrayInputStream 无效。此类中的方法在关闭此流后仍可被调用，而不会产生任何 IOException。

这是jdk文档中关于此类的描述。说明：

1.内部缓冲区指的是buf数组

2.内部计数器就是指字段pos，可以将其看成是光标

3.关闭 ByteArrayInputStream 无效指的是，关闭流的close()方法，在此类中时空方法

这里就不给出ByteArrayInputStream类的方法列表里，因为大体上和InputStream类方法列表的描述是一样的，只是方法的实现是不同的而已。

ByteArrayInputStream类源码分析

源码还是很有必要看一下的可以加强对此类的理解

public class ByteArrayInputStream extends InputStream {

    // 保存字节输入流数据的字节数组
    protected byte buf[];

    // 下一个会被读取的字节的索引
    protected int pos;

    // 用于标记输入流当前位置，就是标记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是“读到b数组中的字节最大长度”
    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 {
    }
}

 

真的是排版能力有限了。此博文仅作学习之用，欢迎指正。