概念

源码说明：This abstract class is the superclass of all classes representing an input stream of bytes（个人理解为：定义输入字节流的规范。即需要输入字节流可按照这个规范实现）

内部结构

屏幕截图 2020-04-25 20.43.15.png

• 读取数据
  1. read()：从输入数据的流中获取下一个字节数据（虽然返回int类型，但存储范围是0-255）。该方法将，直到可用输入数据、检测到文件结尾（返回-1）或引发异常为止。
  2. read(byte[])：从输入流中读取一定数量的字节，并将其存储到缓冲区数组中。实际读取的字节数以整数形式返回。该方法将，直到可用输入数据、检测到文件结尾或引发异常为止。
  3. read(byte[], int, int)：从输入流中最多读取n个字节的数据到字节数组中。实际读取的字节数以整数形式返回。 此方法将，直到可用输入数据、检测到文件结尾或引发异常为止。
• 标记数据（重读数据）
  1. markSupported()：判断当前输入流是否支持 mark和reset方法
  2. mark(int)：标记此输入流中的当前位置。后续调用reset 方法将从最后一个标记位置开始读取字节流。入参表示标记位置变为无效之前可以读取的最大字节数限制
  3. reset()：将此流重新定位到在此输入流上最后一次调用mark 方法时的位置
• 其他
  1. shik(long)：跳过并丢弃此输入流中的n个字节的数据（跳过的数据还是可以通过mark与reset重新读取）
  2. available()：返回可以从此输入流读取（或跳过）而不会被该输入流的方法的下一次调用的估计值
  3. close()：关闭此输入流并释放与该流关联的所有系统资源

接口实现

为了更好的理解InputStream接口，咱们选择一个具体实现来学习。这里咱们选择java.io.ByteArrayInputStream

屏幕截图 2020-04-25 22.06.27.png

package java.io;

/**
 * @author  Arthur van Hoff
 * @see     java.io.StringBufferInputStream
 * @since   JDK1.0
 */
public class ByteArrayInputStream extends InputStream {

    /**
     * 存储当前流的所有流数据，read操作即获取数组中数据
     */
    protected byte buf[];

    /**
     * 记录下次read操作的数组（buf[]）下标值
     */
    protected int pos;

    /**
     * 记录当前流被标记的数组（buf[]）下标值，通过mark方法设置，执行reset方法时将pos设置为mark
     *
     * @since   JDK1.1
     */
    protected int mark = 0;

    /**
     * 记录当前流能被read的最大下标值+1
     */
    protected int count;

    /**
     * 构造函数
     *
     * @param   当前流的所有数据
     */
    public ByteArrayInputStream(byte buf[]) {
        this.buf = buf;
        this.pos = 0;
        this.count = buf.length;
    }

    /**
     * 构造函数
     *
     * @param   buf      当前流的所有数据
     * @param   offset   开始被read的数组下标值
     * @param   length   允许被read的总字节数
     */
    public ByteArrayInputStream(byte buf[], int offset, int length) {
        this.buf = buf;
        this.pos = offset;
        this.count = Math.min(offset + length, buf.length);
        this.mark = offset;
    }

    /**
     * 获取当前流的下一个字节
     *
     * @return 读取的字节，如果超过最大运行被读的字节时则返回-1
     */
    public synchronized int read() {
        return (pos < count) ? (buf[pos++] & 0xff) : -1;
    }

    /**
     * 将当前流中最多len个字节数据读取到一个字节数组中s
     *
     * @param   b     存储本次读取的字节组
     * @param   off   目标数组b开始存储读取字节数组的下标值
     * @param   len  最大读取字节数
     * @return  总共读取字节数，如果到达流结尾则返回-1
     */
    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个字节
     *
     * @param   n   需要跳过的字节总数
     * @return  实际跳过的字节总数
     */
    public synchronized long skip(long n) {
        long k = count - pos;
        if (n < k) {
            k = n < 0 ? 0 : n;
        }

        pos += k;
        return k;
    }

    /**
     * 返回可以从此输入流读取（或跳过）而不会阻塞的剩余字节数。
     *
     * @return  可以从此输入流读取（或跳过）而不会阻塞的剩余字节数
     */
    public synchronized int available() {
        return count - pos;
    }

    /**
     * 判断当前输入流是否支持 mark和reset方法（总是返回true）。
     *
     * @since   JDK1.1
     */
    public boolean markSupported() {
        return true;
    }

    /**
     * 设置流中的当前标记位置
     *
     * 注意：此类的readAheadLimit没有任何意义。
     *
     * @since   JDK1.1
     */
    public void mark(int readAheadLimit) {
        mark = pos;
    }

    /**
     * 将缓冲区重置到标记的位置。除非在构造函数中标记了另一个位置或指定了偏移量，否则标记的位置为0。
     */
    public synchronized void reset() {
        pos = mark;
    }

    /**
     * 关闭ByteArrayInputStream无效。可以在关闭流之后调用此类中的方法，而不会生成IOException。
     */
    public void close() throws IOException {
    }

}