OpenJDK 1.22 · java.io.ByteArrayInputStream · APIdia, the JavaDoc alternative

Modifier and Type	Field and Description
protected byte[]	buf An array of bytes that was provided by the creator of the stream.
protected int	count The index one greater than the last valid byte in the input stream buffer.
protected int	mark The currently marked position in the stream.
private static final int	MAX_TRANSFER_SIZE
protected int	pos The index of the next byte to read from the input stream buffer.

Access	Constructor and Description
public	ByteArrayInputStream(byte[] the input buffer. buf) Creates a `ByteArrayInputStream` so that it uses `buf` as its buffer array.
public	ByteArrayInputStream(byte[] the input buffer. buf, int the offset in the buffer of the first byte to read. offset, int the maximum number of bytes to read from the buffer. length) Creates `ByteArrayInputStream` that uses `buf` as its buffer array.

Method Summary

Modifier and Type	Method and Description
public synchronized int	Returns: the number of remaining bytes that can be read (or skipped over) from this input stream without blocking. available() Overrides java.io.InputStream.available. Returns the number of remaining bytes that can be read (or skipped over) from this input stream.
public void	close() Overrides java.io.InputStream.close. Implements java.io.Closeable.close. Closing a `ByteArrayInputStream` has no effect.
public void	mark(int the maximum limit of bytes that can be read before the mark position becomes invalid. readAheadLimit) Overrides java.io.InputStream.mark. Set the current marked position in the stream.
public boolean	Returns: true markSupported() Overrides java.io.InputStream.markSupported. Tests if this `InputStream` supports mark/reset.
public synchronized int	Returns: the next byte of data, or `-1` if the end of the stream is reached. read() Implements abstract java.io.InputStream.read. Reads the next byte of data from this input stream.
public synchronized int	Returns: the total number of bytes read into the buffer, or `-1` if there is no more data because the end of the stream has been reached. read(byte[] the buffer into which the data is read. b, int the start offset in array `b` at which the data is written. off, int the maximum number of bytes to read. len) Overrides java.io.InputStream.read. Reads up to `len` bytes of data into an array of bytes from this input stream.
public synchronized byte[]	readAllBytes() Overrides java.io.InputStream.readAllBytes. Reads all remaining bytes from the input stream.
public int	readNBytes(byte[] the byte array into which the data is read b, int the start offset in `b` at which the data is written off, int the maximum number of bytes to read len) Overrides java.io.InputStream.readNBytes. Reads the requested number of bytes from the input stream into the given byte array.
public synchronized void	reset() Overrides java.io.InputStream.reset. Resets the buffer to the marked position.
public synchronized long	Returns: the actual number of bytes skipped. skip(long the number of bytes to be skipped. n) Overrides java.io.InputStream.skip. Skips `n` bytes of input from this input stream.
public synchronized long	transferTo(OutputStream the output stream, non-null out) Overrides java.io.InputStream.transferTo. Reads all bytes from this input stream and writes the bytes to the given output stream in the order that they are read.

Inherited from java.io.InputStream:: nullInputStream read readNBytes skipNBytes

buf	back to summary
protected byte[] buf An array of bytes that was provided by the creator of the stream. Elements `buf[0]` through `buf[count-1]` are the only bytes that can ever be read from the stream; element `buf[pos]` is the next byte to be read.

count	back to summary
protected int count The index one greater than the last valid byte in the input stream buffer. This value should always be nonnegative and not larger than the length of `buf`. It is one greater than the position of the last byte within `buf` that can ever be read from the input stream buffer.

mark	back to summary
protected int mark The currently marked position in the stream. ByteArrayInputStream objects are marked at position zero by default when constructed. They may be marked at another position within the buffer by the `mark()` method. The current buffer position is set to this point by the `reset()` method. If no mark has been set, then the value of mark is the offset passed to the constructor (or 0 if the offset was not supplied). Since 1.1

MAX_TRANSFER_SIZE	back to summary
private static final int MAX_TRANSFER_SIZE

pos	back to summary
protected int pos The index of the next byte to read from the input stream buffer. This value should always be nonnegative and not larger than the value of `count`. The next byte to be read from the input stream buffer will be `buf[pos]`.

ByteArrayInputStream	back to summary
public ByteArrayInputStream(byte[] buf) Creates a `ByteArrayInputStream` so that it uses `buf` as its buffer array. The buffer array is not copied. The initial value of `pos` is `0` and the initial value of `count` is the length of `buf`. Parameters buf:byte[] the input buffer.

ByteArrayInputStream	back to summary
public ByteArrayInputStream(byte[] buf, int offset, int length) Creates `ByteArrayInputStream` that uses `buf` as its buffer array. The initial value of `pos` is `offset` and the initial value of `count` is the minimum of `offset+length` and `buf.length`. The buffer array is not copied. The buffer's mark is set to the specified offset. Parameters buf:byte[] the input buffer. offset:int the offset in the buffer of the first byte to read. length:int the maximum number of bytes to read from the buffer.

Method Detail

available back to summary

available	back to summary
public synchronized int available() Overrides java.io.InputStream.available. Returns the number of remaining bytes that can be read (or skipped over) from this input stream. The value returned is `count - pos`, which is the number of bytes remaining to be read from the input buffer. Returns:int the number of remaining bytes that can be read (or skipped over) from this input stream without blocking. Annotations @Override

public synchronized int available()

Overrides java.io.InputStream.available.

Returns the number of remaining bytes that can be read (or skipped over) from this input stream.

The value returned is count - pos, which is the number of bytes remaining to be read from the input buffer.

Returns:int

the number of remaining bytes that can be read (or skipped over) from this input stream without blocking.

Annotations

@Override

close back to summary

close	back to summary
public void close() throws IOException Overrides java.io.InputStream.close. Implements java.io.Closeable.close. Closing a `ByteArrayInputStream` has no effect. The methods in this class can be called after the stream has been closed without generating an `IOException`. Annotations @Override Exceptions IOException: Doc from java.io.InputStream.close. if an I/O error occurs.

public void close() throws IOException

Overrides java.io.InputStream.close.

Implements java.io.Closeable.close.

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

Annotations

@Override

Exceptions

IOException:

Doc from java.io.InputStream.close.

if an I/O error occurs.

mark back to summary

mark	back to summary
public void mark(int readAheadLimit) Overrides java.io.InputStream.mark. Set the current marked position in the stream. ByteArrayInputStream objects are marked at position zero by default when constructed. They may be marked at another position within the buffer by this method. If no mark has been set, then the value of the mark is the offset passed to the constructor (or 0 if the offset was not supplied). Note The `readAheadLimit` for this class has no meaning. Parameters readAheadLimit:int Doc from java.io.InputStream.mark. the maximum limit of bytes that can be read before the mark position becomes invalid. Annotations @Override Since 1.1

public void mark(int readAheadLimit)

Overrides java.io.InputStream.mark.

Set the current marked position in the stream. ByteArrayInputStream objects are marked at position zero by default when constructed. They may be marked at another position within the buffer by this method.

If no mark has been set, then the value of the mark is the offset passed to the constructor (or 0 if the offset was not supplied).

Note

The readAheadLimit for this class has no meaning.

Parameters

readAheadLimit:int

Doc from java.io.InputStream.mark.

the maximum limit of bytes that can be read before the mark position becomes invalid.

Annotations

@Override

Since

1.1

markSupported back to summary

markSupported	back to summary
public boolean markSupported() Overrides java.io.InputStream.markSupported. Tests if this `InputStream` supports mark/reset. Implementation Specification The `markSupported` method of `ByteArrayInputStream` always returns `true`. Returns:boolean true Annotations @Override Since 1.1

public boolean markSupported()

Overrides java.io.InputStream.markSupported.

Tests if this InputStream supports mark/reset.

Implementation Specification

The markSupported method of ByteArrayInputStream always returns true.

Returns:boolean

true

Annotations

@Override

Since

1.1

read back to summary

read	back to summary
public synchronized int read() Implements abstract java.io.InputStream.read. Reads the next byte of data from this input stream. The value byte is returned as an `int` in the range `0` to `255`. If no byte is available because the end of the stream has been reached, the value `-1` is returned. This `read` method cannot block. Returns:int Doc from java.io.InputStream.read. the next byte of data, or `-1` if the end of the stream is reached. Annotations @Override

public synchronized int read()

Implements abstract java.io.InputStream.read.

Reads the next byte of data from this input stream. The value byte is returned as an int in the range 0 to 255. If no byte is available because the end of the stream has been reached, the value -1 is returned.

This read method cannot block.

Returns:int

Doc from java.io.InputStream.read.

the next byte of data, or -1 if the end of the stream is reached.

Annotations

@Override

read back to summary

read	back to summary
public synchronized int read(byte[] b, int off, int len) Overrides java.io.InputStream.read. Reads up to `len` bytes of data into an array of bytes from this input stream. If `pos` equals `count`, then `-1` is returned to indicate end of file. Otherwise, the number `k` of bytes read is equal to the smaller of `len` and `count-pos`. If `k` is positive, then bytes `buf[pos]` through `buf[pos+k-1]` are copied into `b[off]` through `b[off+k-1]` in the manner performed by `System.arraycopy`. The value `k` is added into `pos` and `k` is returned. Unlike the `overridden method` of `InputStream`, this method returns `-1` instead of zero if the end of the stream has been reached and `len == 0`. This `read` method cannot block. Parameters b:byte[] Doc from java.io.InputStream.read. the buffer into which the data is read. off:int Doc from java.io.InputStream.read. the start offset in array `b` at which the data is written. len:int Doc from java.io.InputStream.read. the maximum number of bytes to read. Returns:int Doc from java.io.InputStream.read. the total number of bytes read into the buffer, or `-1` if there is no more data because the end of the stream has been reached. Annotations @Override Exceptions NullPointerException: If `b` is `null`. IndexOutOfBoundsException: If `off` is negative, `len` is negative, or `len` is greater than `b.length - off`

public synchronized int read(byte[] b, int off, int len)

Overrides java.io.InputStream.read.

Reads up to len bytes of data into an array of bytes from this input stream. If pos equals count, then -1 is returned to indicate end of file. Otherwise, the number k of bytes read is equal to the smaller of len and count-pos. If k is positive, then bytes buf[pos] through buf[pos+k-1] are copied into b[off] through b[off+k-1] in the manner performed by System.arraycopy. The value k is added into pos and k is returned.

Unlike the overridden method of InputStream, this method returns -1 instead of zero if the end of the stream has been reached and len == 0.

This read method cannot block.

Parameters

b:byte[]

Doc from java.io.InputStream.read.

the buffer into which the data is read.

off:int

Doc from java.io.InputStream.read.

the start offset in array b at which the data is written.

len:int

Doc from java.io.InputStream.read.

the maximum number of bytes to read.

Returns:int

Doc from java.io.InputStream.read.

the total number of bytes read into the buffer, or -1 if there is no more data because the end of the stream has been reached.

Annotations

@Override

Exceptions

NullPointerException:: If b is null.
IndexOutOfBoundsException:: If off is negative, len is negative, or len is greater than b.length - off

readAllBytes	back to summary
public synchronized byte[] readAllBytes() Overrides java.io.InputStream.readAllBytes. Doc from java.io.InputStream.readAllBytes. Reads all remaining bytes from the input stream. This method blocks until all remaining bytes have been read and end of stream is detected, or an exception is thrown. This method does not close the input stream. When this stream reaches end of stream, further invocations of this method will return an empty byte array. Note that this method is intended for simple cases where it is convenient to read all bytes into a byte array. It is not intended for reading input streams with large amounts of data. The behavior for the case where the input stream is asynchronously closed, or the thread interrupted during the read, is highly input stream specific, and therefore not specified. If an I/O error occurs reading from the input stream, then it may do so after some, but not all, bytes have been read. Consequently the input stream may not be at end of stream and may be in an inconsistent state. It is strongly recommended that the stream be promptly closed if an I/O error occurs. Returns:byte[] a byte array containing the bytes read from this input stream Annotations @Override

readAllBytes

back to summary

public synchronized byte[] readAllBytes()

Overrides java.io.InputStream.readAllBytes.

Doc from java.io.InputStream.readAllBytes.

Reads all remaining bytes from the input stream. This method blocks until all remaining bytes have been read and end of stream is detected, or an exception is thrown. This method does not close the input stream.

When this stream reaches end of stream, further invocations of this method will return an empty byte array.

Note that this method is intended for simple cases where it is convenient to read all bytes into a byte array. It is not intended for reading input streams with large amounts of data.

The behavior for the case where the input stream is asynchronously closed, or the thread interrupted during the read, is highly input stream specific, and therefore not specified.

If an I/O error occurs reading from the input stream, then it may do so after some, but not all, bytes have been read. Consequently the input stream may not be at end of stream and may be in an inconsistent state. It is strongly recommended that the stream be promptly closed if an I/O error occurs.

Returns:byte[]

a byte array containing the bytes read from this input stream

Annotations

@Override

readNBytes back to summary

readNBytes	back to summary
public int readNBytes(byte[] b, int off, int len) Overrides java.io.InputStream.readNBytes. Doc from java.io.InputStream.readNBytes. Reads the requested number of bytes from the input stream into the given byte array. This method blocks until `len` bytes of input data have been read, end of stream is detected, or an exception is thrown. The number of bytes actually read, possibly zero, is returned. This method does not close the input stream. In the case where end of stream is reached before `len` bytes have been read, then the actual number of bytes read will be returned. When this stream reaches end of stream, further invocations of this method will return zero. If `len` is zero, then no bytes are read and `0` is returned; otherwise, there is an attempt to read up to `len` bytes. The first byte read is stored into element `b[off]`, the next one in to `b[off+1]`, and so on. The number of bytes read is, at most, equal to `len`. Let k be the number of bytes actually read; these bytes will be stored in elements `b[off]` through `b[off+`k`-1]`, leaving elements `b[off+`k `]` through `b[off+len-1]` unaffected. The behavior for the case where the input stream is asynchronously closed, or the thread interrupted during the read, is highly input stream specific, and therefore not specified. If an I/O error occurs reading from the input stream, then it may do so after some, but not all, bytes of `b` have been updated with data from the input stream. Consequently the input stream and `b` may be in an inconsistent state. It is strongly recommended that the stream be promptly closed if an I/O error occurs. Parameters b:byte[] the byte array into which the data is read off:int the start offset in `b` at which the data is written len:int the maximum number of bytes to read Returns:int the actual number of bytes read into the buffer Annotations @Override

public int readNBytes(byte[] b, int off, int len)

Overrides java.io.InputStream.readNBytes.

Doc from java.io.InputStream.readNBytes.

Reads the requested number of bytes from the input stream into the given byte array. This method blocks until len bytes of input data have been read, end of stream is detected, or an exception is thrown. The number of bytes actually read, possibly zero, is returned. This method does not close the input stream.

In the case where end of stream is reached before len bytes have been read, then the actual number of bytes read will be returned. When this stream reaches end of stream, further invocations of this method will return zero.

If len is zero, then no bytes are read and 0 is returned; otherwise, there is an attempt to read up to len bytes.

The first byte read is stored into element b[off], the next one in to b[off+1], and so on. The number of bytes read is, at most, equal to len. Let k be the number of bytes actually read; these bytes will be stored in elements b[off] through b[off+k-1], leaving elements b[off+k ] through b[off+len-1] unaffected.

The behavior for the case where the input stream is asynchronously closed, or the thread interrupted during the read, is highly input stream specific, and therefore not specified.

If an I/O error occurs reading from the input stream, then it may do so after some, but not all, bytes of b have been updated with data from the input stream. Consequently the input stream and b may be in an inconsistent state. It is strongly recommended that the stream be promptly closed if an I/O error occurs.

Parameters

b:byte[]: the byte array into which the data is read
off:int: the start offset in b at which the data is written
len:int: the maximum number of bytes to read

Returns:int

the actual number of bytes read into the buffer

Annotations

@Override

reset	back to summary
public synchronized void reset() Overrides java.io.InputStream.reset. Resets the buffer to the marked position. The marked position is 0 unless another position was marked or an offset was specified in the constructor. Annotations @Override

reset

back to summary

public synchronized void reset()

Overrides java.io.InputStream.reset.

Resets the buffer to the marked position. The marked position is 0 unless another position was marked or an offset was specified in the constructor.

Annotations

@Override

skip back to summary

skip	back to summary
public synchronized long skip(long n) Overrides java.io.InputStream.skip. Skips `n` bytes of input from this input stream. Fewer bytes might be skipped if the end of the input stream is reached. The actual number `k` of bytes to be skipped is equal to the smaller of `n` and `count-pos`. The value `k` is added into `pos` and `k` is returned. Parameters n:long Doc from java.io.InputStream.skip. the number of bytes to be skipped. Returns:long the actual number of bytes skipped. Annotations @Override

public synchronized long skip(long n)

Overrides java.io.InputStream.skip.

Skips n bytes of input from this input stream. Fewer bytes might be skipped if the end of the input stream is reached. The actual number k of bytes to be skipped is equal to the smaller of n and count-pos. The value k is added into pos and k is returned.

Parameters

n:long

Doc from java.io.InputStream.skip.

the number of bytes to be skipped.

Returns:long

the actual number of bytes skipped.

Annotations

@Override

transferTo back to summary

transferTo	back to summary
public synchronized long transferTo(OutputStream out) throws IOException Overrides java.io.InputStream.transferTo. Doc from java.io.InputStream.transferTo. Reads all bytes from this input stream and writes the bytes to the given output stream in the order that they are read. On return, this input stream will be at end of stream. This method does not close either stream. This method may block indefinitely reading from the input stream, or writing to the output stream. The behavior for the case where the input and/or output stream is asynchronously closed, or the thread interrupted during the transfer, is highly input and output stream specific, and therefore not specified. If the total number of bytes transferred is greater than Long#MAX_VALUE, then `Long.MAX_VALUE` will be returned. If an I/O error occurs reading from the input stream or writing to the output stream, then it may do so after some bytes have been read or written. Consequently the input stream may not be at end of stream and one, or both, streams may be in an inconsistent state. It is strongly recommended that both streams be promptly closed if an I/O error occurs. Parameters out:OutputStream the output stream, non-null Returns:long the number of bytes transferred Annotations @Override Exceptions IOException: if an I/O error occurs when reading or writing

public synchronized long transferTo(OutputStream out) throws IOException

Overrides java.io.InputStream.transferTo.

Doc from java.io.InputStream.transferTo.

Reads all bytes from this input stream and writes the bytes to the given output stream in the order that they are read. On return, this input stream will be at end of stream. This method does not close either stream.

This method may block indefinitely reading from the input stream, or writing to the output stream. The behavior for the case where the input and/or output stream is asynchronously closed, or the thread interrupted during the transfer, is highly input and output stream specific, and therefore not specified.

If the total number of bytes transferred is greater than Long#MAX_VALUE, then Long.MAX_VALUE will be returned.

If an I/O error occurs reading from the input stream or writing to the output stream, then it may do so after some bytes have been read or written. Consequently the input stream may not be at end of stream and one, or both, streams may be in an inconsistent state. It is strongly recommended that both streams be promptly closed if an I/O error occurs.

Parameters

out:OutputStream: the output stream, non-null

Returns:long

the number of bytes transferred

Annotations

@Override

Exceptions

IOException:: if an I/O error occurs when reading or writing

public Class ByteArrayInputStream

Field Summary

Constructor Summary

Method Summary

Field Detail

Constructor Detail

Method Detail