java.io.BufferedInputStream
BufferedInputStream is a class which takes an input stream and
buffers the input. In this way, costly interaction with the
original input stream can be minimized by reading buffered amounts of data
infrequently. The drawback is that extra space is required to hold the buffer
and that copying takes place when reading that buffer.
Summary
Fields
| protected |
|
|
byte[] |
buf |
The buffer containing the current bytes read from the target InputStream. |
| protected |
|
|
int |
count |
The total number of bytes inside the byte array buf. |
| protected |
|
|
int |
marklimit |
The current limit, which when passed, invalidates the current mark. |
| protected |
|
|
int |
markpos |
The currently marked position. |
| protected |
|
|
int |
pos |
The current position within the byte array buf. |
Public Constructors
Public Methods
| |
synchronized |
|
|
int |
available() |
| |
synchronized |
|
|
void |
close() |
| |
synchronized |
|
|
void |
mark(int readlimit) |
| |
|
|
|
boolean |
markSupported() |
| |
synchronized |
|
|
int |
read(byte[] buffer, int offset, int length) |
| |
synchronized |
|
|
int |
read() |
| |
synchronized |
|
|
void |
reset() |
| |
synchronized |
|
|
long |
skip(long amount) |
clone,
equals,
finalize,
getClass,
hashCode,
notify,
notifyAll,
toString,
wait,
wait,
wait
Details
Fields
protected
byte[]
buf
The buffer containing the current bytes read from the target InputStream.
protected
int
count
The total number of bytes inside the byte array buf.
protected
int
marklimit
The current limit, which when passed, invalidates the current mark.
protected
int
markpos
The currently marked position. -1 indicates no mark has been set or the
mark has been invalidated.
protected
int
pos
The current position within the byte array buf.
Public Constructors
public
BufferedInputStream(InputStream in)
Constructs a new
BufferedInputStream on the InputStream
in. The default buffer size (8Kb) is allocated and all
reads can now be filtered through this stream.
Parameters
| in
| the InputStream to buffer reads on.
|
public
BufferedInputStream(InputStream in, int size)
Constructs a new BufferedInputStream on the InputStream
in.
The buffer size is specified by the parameter
size and all
reads can now be filtered through this BufferedInputStream.
Parameters
| in
| the InputStream to buffer reads on. |
| size
| the size of buffer to allocate.
|
Public Methods
public
synchronized
int
available()
Answers an int representing the number of bytes that are available before
this BufferedInputStream will block. This method returns the number of
bytes available in the buffer plus those available in the target stream.
Returns
- the number of bytes available before blocking.
public
synchronized
void
close()
Close this BufferedInputStream. This implementation closes the target
stream and releases any resources associated with it.
Throws
| IOException
| If an error occurs attempting to close this stream.
|
public
synchronized
void
mark(int readlimit)
Set a Mark position in this BufferedInputStream. The parameter
readLimit indicates how many bytes can be read before a
mark is invalidated. Sending reset() will reposition the Stream back to
the marked position provided
readLimit has not been
surpassed. The underlying buffer may be increased in size to allow
readlimit number of bytes to be supported.
Parameters
| readlimit
| the number of bytes to be able to read before invalidating the
mark.
|
public
boolean
markSupported()
Answers a boolean indicating whether or not this BufferedInputStream
supports mark() and reset(). This implementation answers
true.
Returns
true for BufferedInputStreams.
public
synchronized
int
read(byte[] buffer, int offset, int length)
Reads at most
length bytes from this BufferedInputStream
and stores them in byte array
buffer starting at offset
offset. Answer the number of bytes actually read or -1 if
no bytes were read and end of stream was encountered. If all the buffered
bytes have been used, a mark has not been set, and the requested number
of bytes is larger than the receiver's buffer size, this implementation
bypasses the buffer and simply places the results directly into
buffer.
Parameters
| buffer
| the byte array in which to store the read bytes. |
| offset
| the offset in buffer to store the read bytes. |
| length
| the maximum number of bytes to store in buffer. |
Returns
- the number of bytes actually read or -1 if end of stream.
Throws
| IOException
| If the stream is already closed or another IOException
occurs.
|
public
synchronized
int
read()
Reads a single byte from this BufferedInputStream and returns the result
as an int. The low-order byte is returned or -1 of the end of stream was
encountered. If the underlying buffer does not contain any available
bytes then it is filled and the first byte is returned.
Returns
- the byte read or -1 if end of stream.
Throws
| IOException
| If the stream is already closed or another IOException
occurs.
|
public
synchronized
void
reset()
Reset this BufferedInputStream to the last marked location. If the
readlimit has been passed or no
mark has
been set, throw IOException. This implementation resets the target
stream.
Throws
| IOException
| If the stream is already closed or another IOException
occurs.
|
public
synchronized
long
skip(long amount)
Skips
amount number of bytes in this BufferedInputStream.
Subsequent
read()'s will not return these bytes unless
reset() is used.
Parameters
| amount
| the number of bytes to skip. |
Returns
- the number of bytes actually skipped.
Throws
| IOException
| If the stream is already closed or another IOException
occurs.
|