Java IO - ByteArrayInputStream&ByteArrayOutputStream

基本概念

ByteArrayInputStream：字节数组输入流，继承自 InputStream。它会在内存中创建一个字节数组缓冲区，从输入流读取的数据保存在该字节数组缓冲区中。

ByteArrayOutputStream：字节数组输出流，继承自OutputStream是与 ByteArrayInputStream 相对应的输出流。

实例探究

1.ByteArrayInputStream

下面来看一个完整的实例。

public class Test {

// 英文字母
private static final byte[] ArrayLetters = {
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 };

private static final int LEN = 5;

public static void main(String[] args) throws IOException {
read();
}

private static void read() {

ByteArrayInputStream bis = new ByteArrayInputStream(ArrayLetters);

// 逐个读取字节，输出 a，b，c，d，e
for (int i = 0; i < LEN; i++) {
if (bis.available() != -1) {
int count = bis.read();
System.out.print((char) count);
}
}
System.out.println();

// 判断是否支持标记操作
if (!bis.markSupported()) {
return;
}

// 标记当前字节，即 f（与 reset 配套使用）
bis.mark(0);

// 跳过5个字节，跳过 f，g，h，i，j
bis.skip(5);

//按照字节数组读取，输出结果 k，l，m，n，o
byte[] buf = new byte[LEN];
bis.read(buf, 0, LEN);
System.out.print(new String(buf));
System.out.println();

// 重置字节流，回到 mark 的位置，重新读取字符数组，输出 f，g，h，i，j
bis.reset();
bis.read(buf, 0, LEN);
System.out.print(new String(buf));
}

2.ByteArrayOutputStream

public static void main(String[] args) throws IOException {
write();
}

private static void write() throws IOException {

ByteArrayOutputStream bos = new ByteArrayOutputStream(ArrayLetters.length);

// 按字节写入，输出 a
bos.write(0x61);
System.out.println(bos.toString());

// 按字节数组写入，输出 a，b，c，d
bos.write(ArrayLetters, 1, 3);
System.out.println(bos.toString());

// 缓冲数组中的字节数量，输出 4
int size = bos.size();
System.out.println(size);

// 转换成字节数组，输出 a，b，c，d
byte[] buf = bos.toByteArray();
System.out.println(new String(bos.toByteArray()));

//将内容输出到其他流
bos.writeTo(new ByteArrayOutputStream(size));

}

源码分析

1.ByteArrayInputStream

首先来看它的类结构，如下图所示。



通过类结构图，我们知道它定义了4个成员变量。

//缓冲数组
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;
}

接下来着重来看它的 read 方法。

//按字节读取
public synchronized int read() {

//判断索引位置，并取出数组上相应位置的值。读取完毕返回 -1。
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;
}

//判断要读取的字节数量是否超出了缓冲数组中剩余的字节数量
if (pos + len > count) {
len = count - pos;
}

if (len <= 0) {
return 0;
}

//重点-->将缓冲数组上的字节（从索引位置开始）复制到当前数组中
System.arraycopy(buf, pos, b, off, len);

pos += len;

return len;
}

最后再来看看类中剩余的几个方法。

//表示要跳过的字节，通过改变数组的索引位置实现
public synchronized long skip(long n) {
if (pos + n > count) {
n = count - pos;
}
if (n < 0) {
return 0;
}
pos += n;
return n;
}

//返回缓冲数组中剩余可读取的字节数量
public synchronized int available() {
return count - pos;
}

//表示字节数入流默认支持标记
public boolean markSupported() {
return true;
}

//标记字节
public void mark(int readAheadLimit) {
mark = pos;
}

//释放标记的字节
public synchronized void reset() {
pos = mark;
}

//关闭流，是个空方法，说明缓冲数组输入流不需要关闭流操作
public void close() throws IOException {
}

2.ByteArrayOutputStream

首先来看它的类结构，如下图所示。



通过类结构图，我们知道它定义了2个成员变量，意义与 ByteArrayInputStream 中的成员变量一样，这里不再阐述。接下来看它的构造方法。

public ByteArrayOutputStream() {
this(32);
}

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

观察代码发现 ByteArrayOutputStream 的操作跟 ByteArrayInputStream 一样，也是通过缓冲数组完成。如果不指定缓冲数组的大小，默认为32。再来着重看看它的 write 方法。

//按字节写入
public synchronized void write(int b) {

int newcount = count + 1;

//判断下一次写入时长度如果超出缓冲数组的容量，则创建新的缓冲数组并将内容复制进入
if (newcount > buf.length) {
buf = Arrays.copyOf(buf, Math.max(buf.length << 1, newcount));
}

//关键-->写入操作
buf[count] = (byte) b;

count = newcount;
}

//按字节数组写入
public synchronized void write(byte b[], int off, int len) {
if ((off < 0) || (off > b.length) || (len < 0) || ((off + len) > b.length) || ((off + len) < 0)) {
throw new IndexOutOfBoundsException();
} else if (len == 0) {
return;
}

int newcount = count + len;

if (newcount > buf.length) {
buf = Arrays.copyOf(buf, Math.max(buf.length << 1, newcount));
}

//关键-->写入操作
System.arraycopy(b, off, buf, count, len);

count = newcount;
}

最后再来看看它的其他方法。

//重点 -->将内容输出到其他流
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);
}

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

//同字节数组输入流一样，不用关闭流
public void close() throws IOException {
}