java.io: public class: BufferedOutputStream

java.io
public class: BufferedOutputStream [javadoc | source]

java.lang.Object
   java.io.OutputStream
      java.io.FilterOutputStream
         java.io.BufferedOutputStream

All Implemented Interfaces:
Flushable, Closeable

Wraps an existing OutputStream and buffers the output. Expensive interaction with the underlying input stream is minimized, since most (smaller) requests can be satisfied by accessing the buffer alone. The drawback is that some extra space is required to hold the buffer and that copying takes place when flushing that buffer, but this is usually outweighed by the performance benefits.

A typical application pattern for the class looks like this:

BufferedOutputStream buf = new BufferedOutputStream(new FileOutputStream("file.java"));

Also see:

BufferedInputStream

Field Summary
protected byte[]	buf	The buffer containing the bytes to be written to the target stream.
protected int	count	The total number of bytes inside the byte array {@code buf}.

Fields inherited from java.io.FilterOutputStream:
out

Constructor:

Constructor:
public BufferedOutputStream(OutputStream out) { super(out); buf = new byte[8192]; } Constructs a new {@code BufferedOutputStream} on the OutputStream {@code out}. The buffer size is set to the default value of 8 KB. Parameters: `out` - the {@code OutputStream} for which write operations are buffered.
public BufferedOutputStream(OutputStream out, int size) { super(out); if (size < = 0) { // luni.A3=size must be > 0 throw new IllegalArgumentException(Messages.getString("luni.A3")); //$NON-NLS-1$ } buf = new byte[size]; } Constructs a new {@code BufferedOutputStream} on the OutputStream {@code out}. The buffer size is set to {@code size}. Parameters: `out` - the output stream for which write operations are buffered. `size` - the size of the buffer in bytes. Throws: `IllegalArgumentException` - if {@code size <= 0}.

 public BufferedOutputStream(OutputStream out) {
        super(out);
        buf = new byte[8192];
}

OutputStream

Parameters:

out - the {@code OutputStream} for which write operations are buffered.

 public BufferedOutputStream(OutputStream out,
    int size) {
        super(out);
        if (size < = 0) {
            // luni.A3=size must be  > 0
            throw new IllegalArgumentException(Messages.getString("luni.A3")); //$NON-NLS-1$
        }
        buf = new byte[size];
}

OutputStream

Parameters:

out - the output stream for which write operations are buffered.

size - the size of the buffer in bytes.

Throws:

IllegalArgumentException - if {@code size <= 0}.

Method from java.io.BufferedOutputStream Summary:
close, flush, write, write

Methods from java.io.FilterOutputStream:
close, flush, write, write, write

Methods from java.io.OutputStream:
checkError, close, flush, write, write, write

Methods from java.lang.Object:
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

Method from java.io.BufferedOutputStream Detail:
public synchronized void close() throws IOException { if (buf == null) { return; } try { super.close(); } finally { buf = null; } }
public synchronized void flush() throws IOException { flushInternal(); out.flush(); } Flushes this stream to ensure all pending data is written out to the target stream. In addition, the target stream is flushed.
public synchronized void write(int oneByte) throws IOException { byte[] internalBuffer = buf; if (internalBuffer == null) { throw new IOException(Messages.getString("luni.24")); //$NON-NLS-1$ } if (count == internalBuffer.length) { out.write(internalBuffer, 0, count); count = 0; } internalBuffer[count++] = (byte) oneByte; } Writes one byte to this stream. Only the low order byte of the integer {@code oneByte} is written. If there is room in the buffer, the byte is copied into the buffer and the count incremented. Otherwise, the buffer plus {@code oneByte} are written to the target stream, the target is flushed, and the buffer is reset.
public synchronized void write(byte[] buffer, int offset, int length) throws IOException { byte[] internalBuffer = buf; if (internalBuffer == null) { throw new IOException(Messages.getString("luni.24")); //$NON-NLS-1$ } if (buffer == null) { // luni.11=buffer is null throw new NullPointerException(Messages.getString("luni.11")); //$NON-NLS-1$ } if (length >= internalBuffer.length) { flushInternal(); out.write(buffer, offset, length); return; } if (offset < 0 \|\| offset > buffer.length - length) { // luni.12=Offset out of bounds \: {0} throw new ArrayIndexOutOfBoundsException(Messages.getString("luni.12", offset)); //$NON-NLS-1$ } if (length < 0) { // luni.18=Length out of bounds \: {0} throw new ArrayIndexOutOfBoundsException(Messages.getString("luni.18", length)); //$NON-NLS-1$ } // flush the internal buffer first if we have not enough space left if (length >= (internalBuffer.length - count)) { flushInternal(); } // the length is always less than (internalBuffer.length - count) here so arraycopy is safe System.arraycopy(buffer, offset, internalBuffer, count, length); count += length; } Writes {@code count} bytes from the byte array {@code buffer} starting at {@code offset} to this stream. If there is room in the buffer to hold the bytes, they are copied in. If not, the buffered bytes plus the bytes in {@code buffer} are written to the target stream, the target is flushed, and the buffer is cleared.

Method from java.io.BufferedOutputStream Detail:

 public synchronized  void close() throws IOException {
        if (buf == null) {
            return;
        }
        try {
            super.close();
        } finally {
            buf = null;
        }
}

 public synchronized  void flush() throws IOException {
        flushInternal();
        out.flush();
}

Flushes this stream to ensure all pending data is written out to the target stream. In addition, the target stream is flushed.

 public synchronized  void write(int oneByte) throws IOException {
        byte[] internalBuffer = buf;
        if (internalBuffer == null) {
            throw new IOException(Messages.getString("luni.24")); //$NON-NLS-1$
        }
        if (count == internalBuffer.length) {
            out.write(internalBuffer, 0, count);
            count = 0;
        }
        internalBuffer[count++] = (byte) oneByte;
}

Writes one byte to this stream. Only the low order byte of the integer {@code oneByte} is written. If there is room in the buffer, the byte is copied into the buffer and the count incremented. Otherwise, the buffer plus {@code oneByte} are written to the target stream, the target is flushed, and the buffer is reset.

 public synchronized  void write(byte[] buffer,
    int offset,
    int length) throws IOException {
        byte[] internalBuffer = buf;
        if (internalBuffer == null) {
            throw new IOException(Messages.getString("luni.24")); //$NON-NLS-1$
        }
        if (buffer == null) {
            // luni.11=buffer is null
            throw new NullPointerException(Messages.getString("luni.11")); //$NON-NLS-1$
        }
        if (length  >= internalBuffer.length) {
            flushInternal();
            out.write(buffer, offset, length);
            return;
        }
        if (offset <  0 || offset  > buffer.length - length) {
            // luni.12=Offset out of bounds \: {0}
            throw new ArrayIndexOutOfBoundsException(Messages.getString("luni.12", offset)); //$NON-NLS-1$
        }
        if (length <  0) {
            // luni.18=Length out of bounds \: {0}
            throw new ArrayIndexOutOfBoundsException(Messages.getString("luni.18", length)); //$NON-NLS-1$
        }
        // flush the internal buffer first if we have not enough space left
        if (length  >= (internalBuffer.length - count)) {
            flushInternal();
        }
        // the length is always less than (internalBuffer.length - count) here so arraycopy is safe
        System.arraycopy(buffer, offset, internalBuffer, count, length);
        count += length;
}

Writes {@code count} bytes from the byte array {@code buffer} starting at {@code offset} to this stream. If there is room in the buffer to hold the bytes, they are copied in. If not, the buffered bytes plus the bytes in {@code buffer} are written to the target stream, the target is flushed, and the buffer is cleared.