public class FastBufferedOutputStream extends MeasurableOutputStream implements RepositionableStream
This class provides buffering for output streams, but it does so with
purposes and an internal logic that are radically different from the ones
adopted in BufferedOutputStream. The main features follow.
All methods are unsychronized.
As an additional feature, this class implements the RepositionableStream and MeasurableStream interfaces.
An instance of this class will try to cast
the underlying byte stream to a RepositionableStream and to fetch by
reflection the FileChannel underlying the given
output stream, in this order. If either reference can be successfully
fetched, you can use position(long) to reposition the stream.
Much in the same way, an instance of this class will try to cast the
the underlying byte stream to a MeasurableStream, and if this
operation is successful, or if a FileChannel can
be detected, then position() and length() will work as expected.
| Modifier and Type | Field and Description |
|---|---|
static int |
DEFAULT_BUFFER_SIZE
The default size of the internal buffer in bytes (8Ki).
|
| Constructor and Description |
|---|
FastBufferedOutputStream(OutputStream os)
Creates a new fast buffered ouptut stream by wrapping a given output stream with a buffer of
DEFAULT_BUFFER_SIZE bytes. |
FastBufferedOutputStream(OutputStream os,
byte[] buffer)
Creates a new fast buffered output stream by wrapping a given output stream with a given buffer.
|
FastBufferedOutputStream(OutputStream os,
int bufferSize)
Creates a new fast buffered output stream by wrapping a given output stream with a given buffer size.
|
| Modifier and Type | Method and Description |
|---|---|
void |
close()
Closes this output stream and releases any system resources
associated with this stream.
|
void |
flush()
Flushes this output stream and forces any buffered output bytes
to be written out.
|
long |
length()
Returns the length of the underlying output stream, if it is measurable.
|
long |
position()
Returns the current stream position.
|
void |
position(long newPosition)
Repositions the stream.
|
void |
write(byte[] b,
int offset,
int length)
Writes
len bytes from the specified byte array
starting at offset off to this output stream. |
void |
write(int b)
Writes the specified byte to this output stream.
|
writepublic static final int DEFAULT_BUFFER_SIZE
public FastBufferedOutputStream(OutputStream os, byte[] buffer)
os - an output stream to wrap.buffer - a buffer of positive length.public FastBufferedOutputStream(OutputStream os, int bufferSize)
os - an output stream to wrap.bufferSize - the size in bytes of the internal buffer.public FastBufferedOutputStream(OutputStream os)
DEFAULT_BUFFER_SIZE bytes.os - an output stream to wrap.public void write(int b)
throws IOException
java.io.OutputStreamwrite is that one byte is written
to the output stream. The byte to be written is the eight
low-order bits of the argument b. The 24
high-order bits of b are ignored.
Subclasses of OutputStream must provide an
implementation for this method.
write in class OutputStreamb - the byte.IOException - if an I/O error occurs. In particular,
an IOException may be thrown if the
output stream has been closed.public void write(byte[] b,
int offset,
int length)
throws IOException
java.io.OutputStreamlen bytes from the specified byte array
starting at offset off to this output stream.
The general contract for write(b, off, len) is that
some of the bytes in the array b are written to the
output stream in order; element b[off] is the first
byte written and b[off+len-1] is the last byte written
by this operation.
The write method of OutputStream calls
the write method of one argument on each of the bytes to be
written out. Subclasses are encouraged to override this method and
provide a more efficient implementation.
If b is null, a
NullPointerException is thrown.
If off is negative, or len is negative, or
off+len is greater than the length of the array
b, then an IndexOutOfBoundsException is thrown.
write in class OutputStreamb - the data.offset - the start offset in the data.length - the number of bytes to write.IOException - if an I/O error occurs. In particular,
an IOException is thrown if the output
stream is closed.public void flush()
throws IOException
java.io.OutputStreamflush is
that calling it is an indication that, if any bytes previously
written have been buffered by the implementation of the output
stream, such bytes should immediately be written to their
intended destination.
If the intended destination of this stream is an abstraction provided by the underlying operating system, for example a file, then flushing the stream guarantees only that bytes previously written to the stream are passed to the operating system for writing; it does not guarantee that they are actually written to a physical device such as a disk drive.
The flush method of OutputStream does nothing.
flush in interface Flushableflush in class OutputStreamIOException - if an I/O error occurs.public void close()
throws IOException
java.io.OutputStreamclose
is that it closes the output stream. A closed stream cannot perform
output operations and cannot be reopened.
The close method of OutputStream does nothing.
close in interface Closeableclose in interface AutoCloseableclose in class OutputStreamIOException - if an I/O error occurs.public long position()
throws IOException
RepositionableStreamposition in interface MeasurableStreamposition in interface RepositionableStreamIOExceptionpublic void position(long newPosition)
throws IOException
Note that this method performs a flush() before changing the underlying stream position.
position in interface RepositionableStreamnewPosition - the new stream position.IOExceptionpublic long length()
throws IOException
Note that this method performs a flush() before detecting the length.
length in interface MeasurableStreamUnsupportedOperationException - if the underlying output stream is not measurable and
cannot provide a FileChannel.IOException