美文网首页
简述InputStream接口

简述InputStream接口

作者: XJ2017 | 来源:发表于2020-04-25 23:00 被阅读0次

    概念

    源码说明: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)。该方法将\color{red}{阻塞},直到可用输入数据、检测到文件结尾(返回-1)或引发异常为止。
      2. read(byte[]):从输入流中读取一定数量的字节,并将其存储到缓冲区数组中。实际读取的字节数以整数形式返回。该方法将\color{red}{阻塞},直到可用输入数据、检测到文件结尾或引发异常为止。
      3. read(byte[], int, int):从输入流中最多读取n个字节的数据到字节数组中。实际读取的字节数以整数形式返回。 此方法将\color{red}{阻塞},直到可用输入数据、检测到文件结尾或引发异常为止。
    • 标记数据(重读数据)
      1. markSupported():判断当前输入流是否支持 mark和reset方法
      2. mark(int):标记此输入流中的当前位置。后续调用reset 方法将从最后一个标记位置开始读取字节流。入参表示标记位置变为无效之前可以读取的最大字节数限制
      3. reset():将此流重新定位到在此输入流上最后一次调用mark 方法时的位置
    • 其他
      1. shik(long):跳过并丢弃此输入流中的n个字节的数据(跳过的数据还是可以通过mark与reset重新读取)
      2. available():返回可以从此输入流读取(或跳过)而不会被该输入流的方法的下一次调用\color{red}{阻塞的字节数}的估计值
      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 {
        }
    
    }
    

    相关文章

      网友评论

          本文标题:简述InputStream接口

          本文链接:https://www.haomeiwen.com/subject/kahcwhtx.html