# Class ByteArrayOutputStream

java.lang.Object
java.io.OutputStream
java.io.ByteArrayOutputStream

All Implemented Interfaces:
  `Closeable, Flushable, AutoCloseable`

public class ByteArrayOutputStream extends OutputStream
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 data can be retrieved using `toByteArray()` and `toString()`.

Closing a `ByteArrayOutputStream` has no effect. The methods in this class can be called after the stream has been closed without generating an `IOException`.

Since:
  1.0

- ## Field Summary

  Fields
  Modifier and Type
  Field
  Description
  `protected byte[]`
  `buf`
  The buffer where data is stored.
  `protected int`
  `count`
  The number of valid bytes in the buffer.

- ## Constructor Summary

  Constructors
  Constructor
  Description
  `ByteArrayOutputStream()`
  Creates a new `ByteArrayOutputStream`.
  `ByteArrayOutputStream(int size)`
  Creates a new `ByteArrayOutputStream`, with a buffer capacity of the specified size, in bytes.

- ## Method Summary

  Modifier and Type
  Method
  Description
  `void`
  `close()`
  Closing a `ByteArrayOutputStream` has no effect.
  `void`
  `reset()`
  Resets the `count` field of this `ByteArrayOutputStream` to zero, so that all currently accumulated output in the output stream is discarded.
  `int`
  `size()`
  Returns the current size of the buffer.
  `byte[]`
  `toByteArray()`
  Creates a newly allocated byte array.
  `String`
  `toString()`
  Converts the buffer's contents into a string decoding bytes using the default charset.
  `String`
  `toString(int hibyte)`
  Deprecated.
  This method does not properly convert bytes into characters.
  `String`
  `toString(String charsetName)`
  Converts the buffer's contents into a string by decoding the bytes using the named `charset`.
  `String`
  `toString(Charset charset)`
  Converts the buffer's contents into a string by decoding the bytes using the specified `charset`.
  `void`
  `write(byte[] b, int off, int len)`
  Writes `len` bytes from the specified byte array starting at offset `off` to this `ByteArrayOutputStream`.
  `void`
  `write(int b)`
  Writes the specified byte to this `ByteArrayOutputStream`.
  `void`
  `writeBytes(byte[] b)`
  Writes the complete contents of the specified byte array to this `ByteArrayOutputStream`.
  `void`
  `writeTo(OutputStream out)`
  Writes the complete contents of this `ByteArrayOutputStream` to the specified output stream argument, as if by calling the output stream's write method using `out.write(buf, 0, count)`.

  ### Methods declared in class OutputStream

  `flush, nullOutputStream, write`
  Modifier and Type
  Method
  Description
  `void`
  `flush()`
  Flushes this output stream and forces any buffered output bytes to be written out.
  `static OutputStream`
  `nullOutputStream()`
  Returns a new `OutputStream` which discards all bytes.
  `void`
  `write(byte[] b)`
  Writes `b.length` bytes from the specified byte array to this output stream.

  ### Methods declared in class Object

  `clone, equals, finalize, getClass, hashCode, notify, notifyAll, wait, wait, wait`
  Modifier and Type
  Method
  Description
  `protected Object`
  `clone()`
  Creates and returns a copy of this object.
  `boolean`
  `equals(Object obj)`
  Indicates whether some other object is "equal to" this one.
  `protected void`
  `finalize()`
  Deprecated, for removal: This API element is subject to removal in a future version.
  Finalization is deprecated and subject to removal in a future release.
  `final Class<?>`
  `getClass()`
  Returns the runtime class of this `Object`.
  `int`
  `hashCode()`
  Returns a hash code value for this object.
  `final void`
  `notify()`
  Wakes up a single thread that is waiting on this object's monitor.
  `final void`
  `notifyAll()`
  Wakes up all threads that are waiting on this object's monitor.
  `final void`
  `wait()`
  Causes the current thread to wait until it is awakened, typically by being notified or interrupted.
  `final void`
  `wait(long timeoutMillis)`
  Causes the current thread to wait until it is awakened, typically by being notified or interrupted, or until a certain amount of real time has elapsed.
  `final void`
  `wait(long timeoutMillis, int nanos)`
  Causes the current thread to wait until it is awakened, typically by being notified or interrupted, or until a certain amount of real time has elapsed.

- ## Field Details

  - ### buf

    protected byte[] buf
    The buffer where data is stored.

  - ### count

    protected int count
    The number of valid bytes in the buffer.

- ## Constructor Details

  - ### ByteArrayOutputStream

    public ByteArrayOutputStream()
    Creates a new `ByteArrayOutputStream`. The buffer capacity is initially 32 bytes, though its size increases if necessary.

  - ### ByteArrayOutputStream

    public ByteArrayOutputStream(int size)
    Creates a new `ByteArrayOutputStream`, with a buffer capacity of the specified size, in bytes.
    Parameters:
      `size` - the initial size.
    Throws:
      `IllegalArgumentException` - if size is negative.

- ## Method Details

  - ### write

    public void write(int b)
    Writes the specified byte to this `ByteArrayOutputStream`.
    Specified by:
      `write` in class `OutputStream`
    Parameters:
      `b` - the byte to be written.

  - ### write

    public void write(byte[] b, int off, int len)
    Writes `len` bytes from the specified byte array starting at offset `off` to this `ByteArrayOutputStream`.
    Overrides:
      `write` in class `OutputStream`
    Parameters:
      `b` - the data.
      `off` - the start offset in the data.
      `len` - the number of bytes to write.
    Throws:
      `NullPointerException` - if `b` is `null`.
      `IndexOutOfBoundsException` - if `off` is negative, `len` is negative, or `len` is greater than `b.length - off`

  - ### writeBytes

    public void writeBytes(byte[] b)
    Writes the complete contents of the specified byte array to this `ByteArrayOutputStream`.
    API Note:
      This method is equivalent to `write(b, 0, b.length)`.
    Parameters:
      `b` - the data.
    Throws:
      `NullPointerException` - if `b` is `null`.
    Since:
      11

  - ### writeTo

    public void writeTo(OutputStream out) throws IOException
    Writes the complete contents of this `ByteArrayOutputStream` to the specified output stream argument, as if by calling the output stream's write method using `out.write(buf, 0, count)`.
    Parameters:
      `out` - the output stream to which to write the data.
    Throws:
      `NullPointerException` - if `out` is `null`.
      `IOException` - if an I/O error occurs.

  - ### reset

    public void reset()
    Resets the `count` field of this `ByteArrayOutputStream` to zero, so that all currently accumulated output in the output stream is discarded. The output stream can be used again, reusing the already allocated buffer space.
    See Also:
      - `ByteArrayInputStream.count`

  - ### toByteArray

    public byte[] toByteArray()
    Creates a newly allocated byte array. Its size is the current size of this output stream and the valid contents of the buffer have been copied into it.
    Returns:
      the current contents of this output stream, as a byte array.
    See Also:
      - `size()`

  - ### size

    public int size()
    Returns the current size of the buffer.
    Returns:
      the value of the `count` field, which is the number of valid bytes in this output stream.
    See Also:
      - `count`

  - ### toString

    public String toString()
    Converts the buffer's contents into a string decoding bytes using the default charset. The length of the new `String` is a function of the charset, and hence may not be equal to the size of the buffer.

    This method always replaces malformed-input and unmappable-character sequences with the default replacement string for the default charset. The CharsetDecoder class should be used when more control over the decoding process is required.

    Overrides:
      `toString` in class `Object`
    Returns:
      String decoded from the buffer's contents.
    Since:
      1.1
    See Also:
      - `Charset.defaultCharset()`

  - ### toString

    public String toString(String charsetName) throws UnsupportedEncodingException
    Converts the buffer's contents into a string by decoding the bytes using the named `charset`.

    This method is equivalent to `#toString(charset)` that takes a `charset`.

    An invocation of this method of the form

            ByteArrayOutputStream b;
            b.toString("UTF-8")

    behaves in exactly the same way as the expression

            ByteArrayOutputStream b;
            b.toString(StandardCharsets.UTF_8)

    Parameters:
      `charsetName` - the name of a supported `charset`
    Returns:
      String decoded from the buffer's contents.
    Throws:
      `UnsupportedEncodingException` - If the named charset is not supported
    Since:
      1.1

  - ### toString

    public String toString(Charset charset)
    Converts the buffer's contents into a string by decoding the bytes using the specified `charset`. The length of the new `String` is a function of the charset, and hence may not be equal to the length of the byte array.

    This method always replaces malformed-input and unmappable-character sequences with the charset's default replacement string. The `CharsetDecoder` class should be used when more control over the decoding process is required.

    Parameters:
      `charset` - the charset to be used to decode the `bytes`
    Returns:
      String decoded from the buffer's contents.
    Since:
      10

  - ### toString

    @Deprecated public String toString(int hibyte)
    Deprecated.
    This method does not properly convert bytes into characters. As of JDK 1.1, the preferred way to do this is via the `toString(String charsetName)` or `toString(Charset charset)` method, which takes an encoding-name or charset argument, or the `toString()` method, which uses the default charset.
    Creates a newly allocated string. Its size is the current size of the output stream and the valid contents of the buffer have been copied into it. Each character c in the resulting string is constructed from the corresponding element b in the byte array such that:

            c == (char)(((hibyte & 0xff) << 8) | (b & 0xff))

    Parameters:
      `hibyte` - the high byte of each resulting Unicode character.
    Returns:
      the current contents of the output stream, as a string.
    See Also:
      - `size()`
      - `toString(String)`
      - `toString()`
      - `Charset.defaultCharset()`

  - ### close

    public void close() throws IOException
    Closing a `ByteArrayOutputStream` has no effect. The methods in this class can be called after the stream has been closed without generating an `IOException`.
    Specified by:
      `close` in interface `AutoCloseable`
    Specified by:
      `close` in interface `Closeable`
    Overrides:
      `close` in class `OutputStream`
    Throws:
      `IOException` - if an I/O error occurs.