Java I/O系列（二）ByteArrayInputStream与ByteArrayOutputStream源码分析及理解

1. ByteArrayInputStream

定义

---

 继承了InputStream，数据源是内置的byte数组buf，那read ()方法的使命（读取一个个字节出来），在ByteArrayInputStream就是简单的通过定向的取buf元素实现的

 

核心源码理解

---

源码：

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

理解：

1. 构造ByteArrayInputStream, 直接将外部的byte数组作为内置的buf，作为被读取的数据源

 

源码：

    // 存放数据的地方
    protected byte buf[];

    // 下一个要被读取的位置，即等待读取的位置
    protected int pos;

    // 标记pos的位置
    protected int mark = 0;

    // 实际能被读取的byte的数量
    protected int count;

理解：

 

源码：

 public synchronized int read() { 2 return (pos < count) ? (buf[pos++] & 0xff) : -1;} 

理解：

1. 该方法是被synchronized修饰的，其它方法也是，故ByteArrayInputStream是线程安全的

2. byte类型和0xff做与运算，转成byte的无符号类型（0-255），上节也说明过

 

源码：

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

理解：

　　1. 因为数据源是byte数组，目的源也是byte数组，故直接采用了数组copy的方法，写入到b数组中

 

源码：

public synchronized long skip(long n) {
        long k = count - pos;
        if (n < k) {
            k = n < 0 ? 0 : n;
        }

        pos += k;
        return k;
    }

理解：

　　1. 通过调整pos的值，来实现skip操作

 

源码：

 public void close() throws IOException { 2 } 

理解：

　　1. 空实现，故close后并不会有任何影响，还是可以继续往外读的

 

 2. ByteArrayOutputStream

定义

---

 继承了OutputStream，目的源是内置的byte数组buf，write()方法是一个个字节写入到buf中(其实就是简单到buf[i]=b，这种赋值操作)

 

核心源码理解

---

源码：

// 目的源，存储数据的地方 
protected byte buf[];

// buf中实际的byte数（不是buf.length)
 protected int count;

 

 public ByteArrayOutputStream() { 2 this(32); 3 } 

 public ByteArrayOutputStream(int size) {
        if (size < 0) {
            throw new IllegalArgumentException("Negative initial size: "
                                               + size);
        }
        buf = new byte[size];
    }

 理解：

　　1. 默认构造ByteArrayOutputStream的buf长度是32；可以指定存储数据的buf数组的长度

 

源码：

public synchronized void write(int b) {
        ensureCapacity(count + 1);
        buf[count] = (byte) b;
        count += 1;
    }

理解：

　　1. 重写了InputStream的write(int b) 方法，直接给buf某个元素赋值；

　　2. 被synchronized修饰（包括其它方法），因此ByteArrayOutputStream是线程安全的

　　3. ensureCapacity，是判断当前的容量和buf.length的大小，如果超过了buf.length，则会对buf进行扩容(申请一个更大的数组，通过Arrays.copyOf方法进行旧元素copy，让buf指向这个新的大数组）

 

源码：

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

 理解：

　　1. 参数b数组是数据源，待被读取的字节数组，由于目的源是内置的字节数组buf，直接通过数组copy的形式完成写入操作

　　2. 与ByteArrayInputStream的read(byte b[], int off, int len)几乎一样，只是内置的buf数组和参数b数组的数据源角色和目的源角色互调下而已

 

源码：

 public synchronized byte toByteArray()[] { 2 return Arrays.copyOf(buf, count); 3 } 

public synchronized String toString() {
        return new String(buf, 0, count);
    }

public synchronized String toString(String charsetName)
        throws UnsupportedEncodingException
    {
        return new String(buf, 0, count, charsetName);
    }

 理解：

　　1. 这三个方法都是取出内置的buf数据，比较容易理解

 

源码：

 public void close() throws IOException {  } 

理解：

　　1. close后还是可以继续写入的

 

3. 总结：

1. 实现了mark与reset方法，mark方法中让mark=pos，reset时让pos=mark，比较容易理解

 

4. 问题：

 1. 欢迎大家提出问题，共同交流学习！

 

5. 示例： 

    /**
     * ByteArrayInputStream的read是从自己内置的buf中读，read的数据源是buf
     * ByteArrayOutputStream的write是写入到自己内置的buf中去，write的目的源是buf
     */
    public static void test1() {
        // 对应abcddefghijklmnopqrsttuvwxyz的ASCII码十六进制分别为
        byte[] bytes = new byte[] { 0x61, 0x62, 0x63, 0x64, 0x65, 0x66, 0x67, 0x68, 0x69, 0x6A, 0x6B, 0x6C, 0x6D, 0x6E, 0x6F,
                0x70, 0x71, 0x72, 0x73, 0x74, 0x75, 0x76, 0x77, 0x78, 0x79, 0x7A
        };

        // 0x64, 0x65, 0x66, 0x67, 0x68
        ByteArrayInputStream bis = new ByteArrayInputStream(bytes, 3, 5);
        ByteArrayOutputStream bos = new ByteArrayOutputStream(); //默认内置的buf长度为32哦
        int b = 0;
        while((b = bis.read()) != -1) {
            System.out.println("ASCII码的十进制: " + b);

            //将读到的字节，再写入到bos中的内置buf中
            bos.write(b);
        }

        // 虽然close都是空实现，但养成一个关闭资源（比如流，连接）的习惯
        try {
            bis.close();
            bos.close();
        } catch (IOException e) {
            e.printStackTrace();
        }

        System.out.println("bos的内置buf数据： " + bos.toString());
    }

执行：

public static void main(String args[]) {
    test1();
}

结果：

ASCII码的十进制: 100
ASCII码的十进制: 101
ASCII码的十进制: 102
ASCII码的十进制: 103
ASCII码的十进制: 104
bos的内置buf数据： defgh

 

6. 参考:

 1. http://www.cnblogs.com/skywang12345/p/io_03.html