问题背景

在实际应用中，我们会碰的一个功能的输出的字节流，是另一个功能输入字节流的情况。一般情况下，我们可以使用ByteArrayOutputStream和ByteArrayInputStream实现相应的功能。

来看下面的测试代码：

import java.io.ByteArrayInputStream;

import java.io.ByteArrayOutputStream;

import java.io.IOException;

import java.io.PrintWriter;

public class ByteArrayTest {

public static void main(String[] argv) throws IOException {

ByteArrayOutputStream output = new ByteArrayOutputStream();

PrintWriter ps = new PrintWriter(output);

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

ps.printf("This is line %d\n", i);

}

ps.close();

ByteArrayInputStream input = new ByteArrayInputStream(output.toByteArray());

byte[] buffer = new byte[1024];

int len = 0;

while ((len = input.read(buffer)) > 0) {

System.out.write(buffer, 0, len);

}

input.close();

}

}

在上面的代码中，我们通过ByteArrayOutputStream对象把输出转换为字节数组，在通过ByteArrayInputStream对象把字节数组转换为输入流。

当需要转换的字节流比较小时，上面的方法是一个简便的且行之有效的方法，然而当字符流比较大时，上面的代码会消耗大量的内存，甚至可能出现内存溢出的情况。

解决方法

为解决上一节提出的问题，本文实现一个字节流转换类，可以直接使用完成以上功能。基本原理是开辟一个缓冲区，通过对缓冲区并发的交互的读写操作实现内存复用和字节流的转换。

转换类代码如下：

import java.io.IOException;

import java.io.InputStream;

import java.io.OutputStream;

public class InputOutputTransferStream extends InputStream {

private byte[] buffer = new byte[4096];

private int byteLength = 0;

private boolean writeOver = false;

private boolean readOver = false;

private InputOutputStream outputStream = new InputOutputStream();

private Object lock = new Object();

public class InputOutputStream extends OutputStream {

@Override

public void write(int c) throws IOException {

synchronized(lock) {

if (byteLength < 0)

return;

while (byteLength >= buffer.length) {

try {

lock.wait();

} catch (InterruptedException e) {

//e.printStackTrace();

}

}

if (byteLength < buffer.length) {

buffer[byteLength] = (byte)c;

byteLength++;

}

lock.notify();

}

}

@Override

public void write(byte[] buf, int offset, int len) throws IOException {

synchronized(lock) {

if (readOver)

return;

while (len > 0) {

if (byteLength >= buffer.length) {

try {

lock.wait();

} catch (InterruptedException e) {

}

}

int nLeft = buffer.length - byteLength;

int nLen = Math.min(nLeft, len);

try {

System.arraycopy(buf, offset, buffer, byteLength, nLen);

} catch (Exception ex) {

}

offset += nLen;

len -= nLen;

byteLength += nLen;

lock.notify();

}

}

}

@Override

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

write(buffer, 0, buffer.length);

}

public void close() {

synchronized(lock) {

//byteLength = -1;

writeOver = true;

lock.notify();

}

}

}

public OutputStream getOutputStream() {

return outputStream;

}

@Override

public int read() throws IOException {

synchronized(lock) {

if (readOver)

return -1;

while (byteLength == 0) {

if (writeOver) {

throw new IOException("closed");

}

try {

lock.wait();

} catch (InterruptedException e) {

//e.printStackTrace();

}

}

if (byteLength < 0) {

return -1;

} else {

int nResult = buffer[0];

for (int i = 0; i < byteLength-1; i++) {

buffer[i] = buffer[i+1];

}

byteLength -= 1;

lock.notify();

return nResult;

}

}

}

@Override

public int read(byte[] buf, int offset, int len) throws IOException {

synchronized(lock) {

if (readOver)

return -1;

while (byteLength == 0) {

if (writeOver)

return -1;

try {

lock.wait();

} catch (InterruptedException e) {

//e.printStackTrace();

}

}

if (byteLength < 0) {

System.out.println("read -1");

return -1;

} else {

int nLen = Math.min(byteLength, len);

System.arraycopy(buffer, 0, buf, offset, nLen);

for (int i = 0; i < byteLength-nLen; i++) {

buffer[i] = buffer[i+nLen];

}

byteLength -= nLen;

lock.notify();

return nLen;

}

}

}

@Override

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

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

}

@Override

public void close() {

synchronized(lock) {

readOver = true;

//byteLength = -1;

lock.notify();

}

}

}

使用方法和测试

以下代码即可用于测试，也为该转换类使用方法的样例：

import java.io.IOException;

import java.io.PrintWriter;

public class InputOutputStreamTest {

public static void main(String[] argv) throws IOException {

final InputOutputTransferStream input = new InputOutputTransferStream();

final PrintWriter ps = new PrintWriter(input.getOutputStream());

new Thread() {

@Override

public void run() {

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

ps.printf("This is line %d\n", i);

}

ps.close();

try {

input.getOutputStream().close();

} catch (IOException e) {

// TODO Auto-generated catch block

e.printStackTrace();

}

}

}.start();

byte[] buffer = new byte[1024];

int len = 0;

while ((len = input.read(buffer)) >= 0) {

System.out.write(buffer, 0, len);

}

input.close();

}

}

运行该代码，与原始代码实现的结果相同，执行结果均为：

This is line 0

This is line 1

This is line 2

This is line 3

This is line 4

……

This is line 995

This is line 996

This is line 997

This is line 998

This is line 999