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

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