How is the buffering mechanism of Java I/O streams implemented?

Java I/O stream provides buffering mechanism through BufferedInputStream and BufferedOutputStream to improve read and write performance. BufferedInputStream reads data from the underlying input stream and stores it in an internal buffer, improving performance on frequent reads of small data blocks. BufferedOutputStream writes data to an internal buffer and, when the buffer is full or needs to be flushed immediately, to the underlying output stream, optimizing performance for infrequent writes of large data blocks.

Buffering mechanism of Java I/O stream

Overview of buffering mechanism

Java I/O streams provide a buffering mechanism that improves read and write performance by storing blocks of data (buffers) in memory. When operating on a buffer, I/O operations are performed on the buffer rather than directly on the underlying file or stream. This saves system calls and context switching time.

Implementation of buffering mechanism

The buffering mechanism in Java I/O stream is input by using BufferedInputStream and BufferedOutputStream /output stream implementation. These streams contain internal buffers for storing blocks of data in memory.

BufferedInputStream

BufferedInputStream Reads in data and stores it in an internal buffer. When the buffer fills up, the stream reads another block of data from the underlying input stream, fills the buffer, and returns the first byte in the buffer. This improves performance on frequent reads of small data blocks.

BufferedOutputStream

BufferedOutputStream Writes data to an internal buffer. When the buffer is full or the data needs to be flushed immediately, the stream writes the data in the buffer to the underlying output stream. This optimizes performance for infrequent writes to large data blocks, reducing the number of system calls.

Practical Example

Consider the following code, which uses BufferedInputStream to read in a text file:

try (BufferedInputStream in = new BufferedInputStream(new FileInputStream("input.txt"))) {
    byte[] buf = new byte[1024];
    int bytesRead;

    while ((bytesRead = in.read(buf)) != -1) {
        System.out.write(buf, 0, bytesRead);
    }
} catch (IOException e) {
    e.printStackTrace();
}

In this example , BufferedInputStream Reads data into internal buffers in chunks, thereby improving the performance of frequent reads of small data chunks.

Points to note

• Buffer size will affect performance. Larger buffers reduce the number of system calls, but also consume more memory. The buffer for the
• BufferedInputStream and BufferedOutputStream classes is specified via java.io.BufferedInputStream.DEFAULT_BUFFER_SIZE (default is 8192 bytes), You can override this value when building the stream instance.
• When using the flush() method, BufferedOutputStream will immediately write the data in the buffer to the underlying output stream, while BufferedInputStream will The buffer is flushed when all data is read from the buffer or when the stream is closed.

The above is the detailed content of How is the buffering mechanism of Java I/O streams implemented?. For more information, please follow other related articles on the PHP Chinese website!