简介

ByteArrayInputStream 是字节数组输入流，它继承于InputStream。
它的内部数据存储结构就是字节数组。

ByteArrayOutputStream是字节数组输出流，它继承于OutputStream。
它的内部数据存储结构也是字节数组。

源码分析

InputStream

在分析ByteArrayInputStream之前，应该先看InputStream，父类InputStream是ByteArrayInputStream的父类，主要实现了读取和跳跃的方法。

public abstract class InputStream implements Closeable {

    // 最大可跳过的字节数

    private static final int MAX_SKIP_BUFFER_SIZE = 2048;

	// 向后读取一个字节

    public abstract int read() throws IOException;

	// 将字节流中的数据装到字节数组的0位开始的位置

    public int read(byte b[]) throws IOException {

        return read(b, 0, b.length);

    }

	// 将字节流中的数据装到字节数组的指定位置当中

    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;

    }

}

ByteArrayInputStream

public

class ByteArrayInputStream extends InputStream {

  	// 字节数组，存储数据

    protected byte buf[];

	// 记录当前可读的第一个位置

    protected int pos;

	// 标记的位置

    protected int mark = 0;

	// 数据最大的可读长度

    protected int count;

	// 初始化字节流数组

    public ByteArrayInputStream(byte buf[]) {

        this.buf = buf;

        this.pos = 0;

        this.count = buf.length;

    }

	// 初始化字节流，填入字节数组的指定位置

    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;

    }

	// 读取单个字节

    public synchronized int read() {

    	// 这里& 0xff的操作是为了只取低八位

        return (pos < count) ? (buf[pos++] & 0xff) : -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;

    }

	// 跳过指定长度的字节

    public synchronized long skip(long n) {

        long k = count - pos;

        if (n < k) {

        	// 如果是负数那么就不动

        	// 取n和k最小的一个

            k = n < 0 ? 0 : n;

        }

		// 移动k位

        pos += k;

        return k;

    }

	// 是否还有数据可以读

    public synchronized int available() {

        return count - pos;

    }

	// 是否支持标记功能

    public boolean markSupported() {

        return true;

    }

	// 标记当前位置，这个传入参数是个摆设

    public void mark(int readAheadLimit) {

        mark = pos;

    }

	// 重置，也就是将当前指针指向之前mark的位置

    public synchronized void reset() {

        pos = mark;

    }

	// 关闭字节流

    public void close() throws IOException {

    }

}

OutputStream

OutputStream是ByteArrayOutputStream的父类，先看看它的源码。

很短，实现了Closeable, Flushable。

public abstract class OutputStream implements Closeable, Flushable {

    public abstract void write(int b) throws IOException;

    public void write(byte b[]) throws IOException {

        write(b, 0, b.length);

    }

    public void write(byte b[], int off, int len) throws IOException {

        if (b == null) {

            throw new NullPointerException();

        } else if ((off < 0) || (off > b.length) || (len < 0) ||

                   ((off + len) > b.length) || ((off + len) < 0)) {

            throw new IndexOutOfBoundsException();

        } else if (len == 0) {

            return;

        }

        for (int i = 0 ; i < len ; i++) {

            write(b[off + i]);

        }

    }

    public void flush() throws IOException {

    }

    public void close() throws IOException {

    }

}

ByteArrayOutputStream

public class ByteArrayOutputStream extends OutputStream {

	// 存储数据的字节数组

    protected byte buf[];

	// 数组长度

    protected int count;

	// 默认构造，默认大小是32

    public ByteArrayOutputStream() {

        this(32);

    }

	// 初始化长度的构造

    public ByteArrayOutputStream(int size) {

        if (size < 0) {

            throw new IllegalArgumentException("Negative initial size: "

                                               + size);

        }

        // 初始化一个数组对象

        buf = new byte[size];

    }

	// 查看是否需要扩容

    private void ensureCapacity(int minCapacity) {

        // overflow-conscious code

        if (minCapacity - buf.length > 0)

            grow(minCapacity);

    }

	// 数组的最大长度

    private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;

	// 扩容

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

    }

	// 边界判断

    private static int hugeCapacity(int minCapacity) {

        if (minCapacity < 0) // overflow

            throw new OutOfMemoryError();

        return (minCapacity > MAX_ARRAY_SIZE) ?

            Integer.MAX_VALUE :

            MAX_ARRAY_SIZE;

    }

	// 写入单个字节

    public synchronized void write(int b) {

    	// 先判断是否需要扩容

        ensureCapacity(count + 1);

        // 写入字节

        buf[count] = (byte) b;

        // 增加可用长度

        count += 1;

    }

	// 写入字节数组

    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;

    }

	// 将当前Stream输出到指定的Streamz中

    public synchronized void writeTo(OutputStream out) throws IOException {

    	// 直接将可用长度的数组写入

        out.write(buf, 0, count);

    }

	// 重置

    public synchronized void reset() {

        count = 0;

    }

	// 转化为字符数组

    public synchronized byte toByteArray()[] {

        return Arrays.copyOf(buf, count);

    }

	// 获取可用长度

    public synchronized int size() {

        return count;

    }

	// 转化为字符串

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

    }

    @Deprecated

    // 获取高位的字节

    public synchronized String toString(int hibyte) {

        return new String(buf, hibyte, 0, count);

    }

    public void close() throws IOException {

    }

}

总结

输入输出流的本质就是一个中间缓存器，暂时将数据放在中间的缓存区，然后根据指定要求输出或如输入。

ByteArrayInputStream 特点

数组实现中间缓存；
修改和读取操作都是线程安全了，因为加了synchronized；
具有标记回读的功能，就是可以先读后面的数据，然后经过重置，再去读前面标记位置的数据。

ByteArrayOutputStream特点

数组实现中间缓存；
修改读取也是具有线程安全的；
具有扩容功能，应为想要写入的数据是增长的，在写入之前，就会进行依次扩容判断；
默认的初始大小是32，如果一个个数据写入的扩容，每次是扩一倍的大小；
可以写入到其他的输出流上。

巴特西

Java IO源码分析（二）——ByteArrayInputStream 和 ByteArrayOutputStream

简介