Storing input stream in a buffer

Question

Hi, what is the best way to read an input stream and save it into a buffer?
Thanks,
Andrea

Answer 1

Not sure if any of the following are an improvement or not. But here are just a few thoughts. Why handle all the byte array allocation yourself? IMO, it would be easier to simply use a ByteArrayOutputStream at that point. The listeners can call toByteArray() and be passed an offset and length of what was read.
Now that I think about it, you could probably make it a bit more generic even than that. For example, here is a class I end up using all the time:
public final class Pipe
    /** Buffer size to read in and output. */
    private static final int DEFAULT_BUFFER_SIZE = 2048;
     * Private constructor.  Use public static facade methods instead.
    private Pipe()
        super();
     * Pipes the specified binary data to the specified output stream.
     * @param   target                      Binary data to output
     * @param   out                         Stream to write
     * @throws  IOException
    public static final void pipe(final byte[] target, final OutputStream out)
        throws IOException
        assert (target != null) : "Missing byte array";
        assert (out != null) : "Missing output stream";
        pipe(new ByteArrayInputStream(target), out, true);
     * Reads from the specified input stream and returns all data as an in-memory.
     * binary array.  Note:  Since streams may be of any arbitrary size, this
     * method requires that you wrap your original stream in a {@link FiniteInputStream}.
     * Please ensure that this method is only used to read in data under, say, 2mB.
     * @param   in                          Stream to read
     * @return  byte[]                      Binary data read
     * @throws  IOException
    public static final byte[] pipe(final FiniteInputStream in)
        throws IOException
        ByteArrayOutputStream byteOut = new ByteArrayOutputStream();
        pipe(in, byteOut, true);
        return byteOut.toByteArray();
     * Reads from the specified input stream and outputs immediately to the specified.
     * output stream.  <br>
     * <br>
     * If you have any confusion about which <code>Pipe</code> method to use, choose
     * this one.  It has the lowest memory overhead and is the most efficient.  Always
     * choose this method when streaming large amounts of data or content.
     * @param   in                          Input stream to read
     * @param   out                         Output stream to write
     * @param   close                       Close both stream if true
     * @return  long                        Byte count piped
     * @throws  IOException
    public static final long pipe(final InputStream in, final OutputStream out, final boolean close)
        throws IOException
        assert (in != null) : "Missing input stream";
        assert (out != null) : "Missing output stream";
        long bytesPiped = 0L;
        byte[] buffer = new byte[DEFAULT_BUFFER_SIZE];
        try
            int bytesRead = in.read(buffer);
            while (bytesRead >= 0)
                if (bytesRead > 0)
                    out.write(buffer, 0, bytesRead);
                    bytesPiped = bytesPiped + bytesRead;
                bytesRead = in.read(buffer);
            out.flush();
            return bytesPiped;
        finally
            if (close)
                IoHelper.close(in);
                IoHelper.close(out);
}You simply could add the listener feature (which I do think is useful and elegant). Note the FiniteInputStream and FiniteOutputStream are just sub-classes of FilterInputStream and FilterOutputStream that allow you to limit how many bytes are piped, if desired.
- Saish