IO流之ByteArrayInputStream和ByteArrayOutputStream原理研究

待我称王封你为后i 2022-05-23 06:16 165阅读 0赞

### ByteArrayOutputStream和ByteArrayInputStream介绍 ###

*  概念  
    
    
     *  ByteArrayOutputStream  
        “字节数组输出流”，内部有有一个缓存字节的数组作为缓存区，所有发送到输出流的数据保存在该字节数组缓冲区中。  
        其中字节的数组的数据顺序和数量很重要。
     *  ByteArrayInputStream  
        “字节数组输入流”，在内存中创建一个字节数组缓冲区，从输入流读取的数据保存在该字节数组缓冲区中。

### 实现原理 ###

*  ByteArrayOutputStream原理分析
    
     *  write(int b)
        
            public synchronized void write(int b) {
                  // 确保缓存数组的长度，如果不够，则会进行增长
                  ensureCapacity(count + 1);
                  // 写入缓存数组中
                  buf[count] = (byte) b;
                  count += 1;
              }
            
              // 检测容量
              private void ensureCapacity(int minCapacity) {
                  // overflow-conscious code
                  // 如果要写入的内容大小大于缓存数组大小，则需要进行容量自增
                  if (minCapacity - buf.length > 0)
                      grow(minCapacity);
              }
            
              // 自动增长方法
              private void grow(int minCapacity) {
                  // overflow-conscious code
                  int oldCapacity = buf.length;
                  int newCapacity = oldCapacity << 1;
                  if (newCapacity - minCapacity < 0)
                      newCapacity = minCapacity;
                  if (newCapacity - MAX_ARRAY_SIZE > 0)
                      newCapacity = hugeCapacity(minCapacity);
                  // 将原数组内容复制到新数组中，长度是增长后的
                  buf = Arrays.copyOf(buf, newCapacity);
              }
     *  write(byte b\[\], int off, int len)
        
            public synchronized void write(byte b[], int off, int len) {
                  if ((off < 0) || (off > b.length) || (len < 0) ||
                      ((off + len) - b.length > 0)) {
                      throw new IndexOutOfBoundsException();
                  }
                  ensureCapacity(count + len);
                  // 将要写入的字节数组内容添加到缓存数组中
                  System.arraycopy(b, off, buf, count, len);
                  count += len;
              }
     *  writeTo(OutputStream out)
        
            public synchronized void writeTo(OutputStream out) throws IOException {
                    out.write(buf, 0, count);
                }
     *  toString() 将缓存区内容转成字符串返回
        
            public synchronized String toString() {
                    return new String(buf, 0, count);
                }
     *  size() 返回内置缓存数组长度；即属性count
     *  reset() 将内置缓存数组长度为0
 *  ByteArrayInputStream原理分析
    
     *  构造函数
        
            public ByteArrayInputStream(byte buf[], int offset, int length) {
                this.buf = buf;
                this.pos = offset;
                // 初始化buf的长度、取min的意义在于剔除不合理参数、避免出现异常
                this.count = Math.min(offset + length, buf.length);
                this.mark = offset;
            }
     *  read() 读取源字节数组中的字节
        
            public synchronized int read() {
                    // 如果读到末尾，返回-1
                    return (pos < count) ? (buf[pos++] & 0xff) : -1;
                }
     *  read(byte b\[\], int off, int len)
        
            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();
                  }
            
                  // 如果缓存数组中没有内容，则返回-1
                  if (pos >= count) {
                      return -1;
                  }
            
                  // count总比可读的字节数大1
                  int avail = count - pos;
                  if (len > avail) {
                      len = avail;
                  }
                  if (len <= 0) {
                      return 0;
                  }
                  // 将buf下标为pos的之后的字节数组复制到b中下标从b开始长度为len的数组中
                  System.arraycopy(buf, pos, b, off, len);
                  // 设置下一个要读的字节开始位置
                  pos += len;
                  return len;
              }
     *  mark(int readAheadLimit)设置当前流的mark位置,并且里面参数无效，看源码就知道了
        
            public void mark(int readAheadLimit) {
                  mark = pos;
              }

### 应用场景 ###

*  问题  
    
    
     *  一般，我们需要先访问服务器或本地的文件或其他文件，把其数据以二进制读取到内存中，  
        然后在再以输入流的形式发送给客户端。这样存在一个问题。我们从网络上获取的还要先存在本地，然后  
        在读取，再发送，这样做是不是很麻烦，而上面两个流的出现就可以完美解决这个问题。
 *  解决  
    
    
     *  ByteArrayInputStream将内建缓存数组作为流的目的地
     *  ByteArrayOutputStream将内建缓存数组作为流的数据源
     *  解决  
        将从网络上读取的文件读取到ByteArrayInputStream将内建缓存数组中，然后直接再以  
        输出流的形式发送给客户端。
 *  优点  
    
    
     *  提高了效率
 *  用途  
    
    
     *  创建临时文件
     *  无需访问磁盘，把数据进行读取，写出

### 总结及问题 ###

*  ByteArrayInputStream、ByteArrayOutputStream的本质都是对内置字节数组的操作，其中包含了  
    读取字节大小，toString，写入另外一个输出流及清空缓存区等；
 *  ByteArrayInputStream中的count属性，不是代表buf中可读字节总数，它是正数或0，并且不应大于 buf 的长度
 *  内建数组严格遵守“一定的顺序”