Java 日看一类（7）之IO包中的ByteArrayOutputStream类

所引入的包和继承关系：
引入java.util.Arrays文件
继承自OutputStream类

类的作用注释：
/**
* This class implements an output stream in which the data is
* written into a byte array. The buffer automatically grows as data
* is written to it.
* The data can be retrieved using <code>toByteArray()</code> and
* <code>toString()</code>.
* <p>
* Closing a <tt>ByteArrayOutputStream</tt> has no effect. The methods in
* this class can be called after the stream has been closed without
* generating an <tt>IOException</tt>.
*
* @author Arthur van Hoff
* @since JDK1.0
*/大意如下：这个类是一个输出流接口，会把数据写入到byte数组中。
缓冲区会自动增长，添加数据。
数据可以通过“toByteArray”和“toString”方法进行格式转换
关闭ByteArrayOutputStream是无效的。
close方法在这个类中只能在流已经被关闭后调用（不抛出IO异常）

这个类含有三个成员变量：
缓冲区：protected byte buf[];缓冲区有效长度：protected int count;最大数组长度：private static final int MAX_ARRAY_SIZE = Integer.MAX_VALUE - 8;
含有十五个方法：
构造函数（默认大小缓冲区）：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 void grow(int minCapacity) {
// overflow-conscious code
int oldCapacity = buf.length;
int newCapacity = oldCapacity << 1;//新容量为旧容量2倍
if (newCapacity - minCapacity < 0)//新容量小于最小需要容量
newCapacity = minCapacity;
if (newCapacity - MAX_ARRAY_SIZE > 0)//新容量超出系统数组所能容纳最大值（Int型）
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;
}将缓冲区内容写入输出流：public synchronized void writeTo(OutputStream out) throws IOException {
out.write(buf, 0, count);
}重置缓冲区：public synchronized void reset() {
count = 0;
}检查缓冲区内容（以Byte数组形式）：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);
}检查缓冲区内容（字符串形式，该String构造函数早已过时，我也不知道这个方法现在有啥用）：public synchronized String toString(int hibyte) {
return new String(buf, hibyte, 0, count);
}


（作者目前使用的JDK1.8）
关闭流（没啥用，和ByteArrayInputStream类相同）：public void close() throws IOException {
}

ByteArrayOutputStream仍是比ByteArrayInputStream简单，但相对于一般的OutputStream，由于其加入了缓冲区检测机制，所以功能会更为强大，准确率也更高。