* The size of the internal buffer defaults to 32 and it is resized
* by doubling the size of the buffer. This default size can be
* overridden by using the
* gnu.java.io.ByteArrayOutputStream.initialBufferSize
* property.
*
* There is a constructor that specified the initial buffer size and * that is the preferred way to set that value because it it portable * across all Java class library implementations. *
* Note that this class also has methods that convert the byte array
* buffer to a
* This method does not convert bytes to characters in the proper way and
* so is deprecated in favor of the other overloaded String using either the system default or an
* application specified character encoding. Thus it can handle
* multibyte character encodings.
*
* @author Aaron M. Renn (arenn@urbanophile.com)
* @author Tom Tromey ByteArrayOutputStream
* with the default buffer size of 32 bytes. If a different initial
* buffer size is desired, see the constructor
* ByteArrayOutputStream(int size). For applications
* where the source code is not available, the default buffer size
* can be set using the system property
* gnu.java.io.ByteArrayOutputStream.initialBufferSize
*/
public ByteArrayOutputStream ()
{
this (initial_buffer_size);
}
/**
* This method initializes a new ByteArrayOutputStream with
* a specified initial buffer size.
*
* @param size The initial buffer size in bytes
*/
public ByteArrayOutputStream (int size)
{
buf = new byte[size];
count = 0;
}
/**
* This method discards all of the bytes that have been written to
* the internal buffer so far by setting the count
* variable to 0. The internal buffer remains at its currently
* allocated size.
*/
public synchronized void reset ()
{
count = 0;
}
/**
* This method returns the number of bytes that have been written to
* the buffer so far. This is the same as the value of the protected
* count variable. If the reset method is
* called, then this value is reset as well. Note that this method does
* not return the length of the internal buffer, but only the number
* of bytes that have been written to it.
*
* @return The number of bytes in the internal buffer
*
* @see #reset()
*/
public int size ()
{
return count;
}
/**
* This method returns a byte array containing the bytes that have been
* written to this stream so far. This array is a copy of the valid
* bytes in the internal buffer and its length is equal to the number of
* valid bytes, not necessarily to the the length of the current
* internal buffer. Note that since this method allocates a new array,
* it should be used with caution when the internal buffer is very large.
*/
public synchronized byte[] toByteArray ()
{
byte[] ret = new byte[count];
System.arraycopy(buf, 0, ret, 0, count);
return ret;
}
/**
* Returns the bytes in the internal array as a String. The
* bytes in the buffer are converted to characters using the system default
* encoding. There is an overloaded toString() method that
* allows an application specified character encoding to be used.
*
* @return A String containing the data written to this
* stream so far
*/
public String toString ()
{
return new String (buf, 0, count);
}
/**
* Returns the bytes in the internal array as a String. The
* bytes in the buffer are converted to characters using the specified
* encoding.
*
* @param enc The name of the character encoding to use
*
* @return A String containing the data written to this
* stream so far
*
* @exception UnsupportedEncodingException If the named encoding is
* not available
*/
public String toString (String enc) throws UnsupportedEncodingException
{
return new String (buf, 0, count, enc);
}
/**
* This method returns the bytes in the internal array as a
* String. It uses each byte in the array as the low
* order eight bits of the Unicode character value and the passed in
* parameter as the high eight bits.
* toString
* methods which use a true character encoding.
*
* @param hibyte The high eight bits to use for each character in
* the String
*
* @return A String containing the data written to this
* stream so far
*
* @deprecated
*/
public String toString (int hibyte)
{
return new String (buf, 0, count, hibyte);
}
// Resize buffer to accommodate new bytes.
private void resize (int add)
{
if (count + add >= buf.length)
{
int newlen = buf.length * 2;
if (count + add > newlen)
newlen = count + add;
byte[] newbuf = new byte[newlen];
System.arraycopy(buf, 0, newbuf, 0, count);
buf = newbuf;
}
}
/**
* This method writes the writes the specified byte into the internal
* buffer.
*
* @param oneByte The byte to be read passed as an int
*/
public synchronized void write (int oneByte)
{
resize (1);
buf[count++] = (byte) oneByte;
}
/**
* This method writes len bytes from the passed in array
* buf starting at index offset into the
* internal buffer.
*
* @param buffer The byte array to write data from
* @param offset The index into the buffer to start writing data from
* @param add The number of bytes to write
*/
public synchronized void write (byte[] buffer, int offset, int add)
{
// If ADD < 0 then arraycopy will throw the appropriate error for
// us.
if (add >= 0)
resize (add);
System.arraycopy(buffer, offset, buf, count, add);
count += add;
}
/**
* This method writes all the bytes that have been written to this stream
* from the internal buffer to the specified OutputStream.
*
* @param out The OutputStream to write to
*
* @exception IOException If an error occurs
*/
public synchronized void writeTo (OutputStream out) throws IOException
{
out.write(buf, 0, count);
}
/**
* The internal buffer where the data written is stored
*/
protected byte[] buf;
/**
* The number of bytes that have been written to the buffer
*/
protected int count;
/**
* The default initial buffer size. Specified by the JCL.
*/
private static final int DEFAULT_INITIAL_BUFFER_SIZE = 32;
// The default buffer size which can be overridden by the user.
private static final int initial_buffer_size;
static
{
int r
= Integer.getInteger ("gnu.java.io.ByteArrayOutputStream.initialBufferSize",
DEFAULT_INITIAL_BUFFER_SIZE).intValue ();
if (r <= 0)
r = DEFAULT_INITIAL_BUFFER_SIZE;
initial_buffer_size = r;
}
}