ByteArrayOutputStream（int size）中的缓冲区到底是什么？

Question

I understand what a buffer is when writing to a file - OS-file-writing (calling native API - one method call for one char) is costly, so many chars/bytes are collected in a buffer and a buffer is written to file with one OS API call.

But what buffer is meant here? And why?

ByteArrayOutputStream(int size) - Creates a new byte array output stream, with a buffer capacity of the specified size , in bytes.

ByteArrayOutputStream() has 32 bytes buffer by default, that is why Apache Commons have exactly same class org.apache.commons.io.output.ByteArrayOutputStream different only by buffer size and mechanism: "The original implementation only allocates 32 bytes at the beginning. As this class is designed for heavy duty it starts at 1024 bytes. In contrast to the original it doesn't reallocate the whole memory block but allocates additional buffers. This way no buffers need to be garbage collected and the contents don't have to be copied to the new buffer. This class is designed to behave exactly like the original. "

Besides in ByteArrayInputStream(byte[] buf) as I understand that "buf" (buffer) is actually a source of data (bytes) to be fed into InputStream (ByteArrayInputStream emulates InputStream from byte array), so the word buffer here is confusing in my opinion.

Answer 1

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 two bold terms are synonymous. The buffer is the byte[] array that holds the bytes written to the stream.

The buffer size is analogous to the capacity of an ArrayList . If you write more than 32 bytes to the stream then it has to grow the buffer, which involves allocating a new array and copying the bytes from old to new. A default "capacity" of 32 is inefficient if you know you'll be writing more than that.

Answer 2

The Javadoc says:

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.

So in the space of two sentences, it has used two different terms. There are numerous other examples in the same doc.

On the one hand, this might be confusing if you don't know that they are referring to the same thing; it might be clearer if it said something like:

is written to a buffer, implemented as a byte array.

But I think it's a simple fact that, once you know (or assume, since this is quite a common thing) they refer to the same thing, is no longer especially confusing.