Read input stream twice

java

input-streams

io-utilities

stream-management

byAlex Kataev·Jan 16, 2025

To reuse an InputStream, first buffer its content into a ByteArrayOutputStream, and then create ByteArrayInputStream instances from that buffered content:

InputStream origStream = // your InputStream here
ByteArrayOutputStream baos = new ByteArrayOutputStream();
byte[] buffer = new byte[1024];
int len;
while ((len = origStream.read(buffer)) != -1) {
    baos.write(buffer, 0, len);
}
byte[] streamData = baos.toByteArray();
InputStream cloneStream1 = new ByteArrayInputStream(streamData);
InputStream cloneStream2 = new ByteArrayInputStream(streamData);

Now cloneStream1 and cloneStream2 are free to be read from the beginning. Question is, which one will you choose? Choose wisely.

Efficient duplication with IOUtils and custom streams

Let's elevate this with Apache Commons IO IOUtils.copy(). It can be your efficient scalpel for stream copying:

InputStream is = // your InputStream here
ByteArrayOutputStream baos = new ByteArrayOutputStream();
IOUtils.copy(is, baos); // Efficient copy wizardry here
byte[] dataBytes = baos.toByteArray();

Working with large data? Use PipedInputStream and PipedOutputStream to duplicate the stream. Just remember: stream consumption requires a separate thread. Don't mix up your threads!

For inline duplication during reads, you might try leveraging TeeInputStream or a TeeListOutputStream. It's like having twin spies, both seeing the same things but reporting to different bosses.

Taking advantage of mark and reset

Certain streams (the friendly ones) support mark and reset methods for multiple reads. Here's your secret handshake:

if(is.markSupported()) {
    is.mark(Integer.MAX_VALUE); // MARK! "I wuz here", said the InputStream
    // ...stream reading ensues...
    is.reset(); // And...like magic, we're back to the beginning
}

But fear not if you encounter a stream that's not friendly! Wrap it in a BufferedInputStream; it'll make it behave.

Handling non-supportive streams and memory considerations

Dealing with defiant streams? Ride the wave with a PushbackInputStream. It's like back to the future for bytes past:

PushbackInputStream pbis = new PushbackInputStream(is);

As you journey through the land of streams, be mindful of memory consumption. With a wise choice of custom input stream classes, your memory management will invite applause.

Essential stream etiquettes

Closing streams after use is your stream responsibility. Handle them kindly, and they'll treat you well:

try(InputStream inStream = // obtained InputStream) {
    // Stream duties here
} catch(IOException e) {
    // Oh well, you tried!
}

Advance tricks for cool folks

Rub elbows with the big leagues! Explore custom TryReadInputStream for automatic "unreading". It's like having an undo button for streams.

Remember: When dealing with rebellious PushbackInputStream, validate byte lengths. You wouldn't want a revolt in the byte kingdom.

explain-codes / Java / Read input stream twice

Linked

Convert InputStream to byte array in Java



How to make a copy of a file in Android?



Is it possible to create a File object from InputStream



Intersection and union of ArrayLists in Java



File to byte[] in Java



Byte[] to file in Java



How do I create a Java string from the contents of a file?



Efficient duplication with IOUtils and custom streams Taking advantage of mark and reset Handling non-supportive streams and memory considerations Essential stream etiquettes Advance tricks for cool folks