Java tutorials > Input/Output (I/O) and Networking > Streams and File I/O > What are buffered streams and why use them?

What are buffered streams and why use them?

This tutorial explains buffered streams in Java, covering their purpose, benefits, and usage with examples. Buffered streams enhance the performance of I/O operations by reducing the number of physical read/write operations.

Introduction to Buffered Streams

Buffered streams are a type of stream in Java's I/O library that improves performance by reading or writing data in larger chunks, minimizing the number of interactions with the underlying physical storage (e.g., disk). They wrap around other streams (like `FileInputStream`, `FileOutputStream`, `FileReader`, `FileWriter`). The buffering mechanism reduces overhead associated with each read/write operation.

Basic Concept: Buffering

The core idea behind buffering is to read a large block of data from the source into an internal buffer, and then provide the data to the application from this buffer. Similarly, for writing, data is first accumulated in the buffer and then written to the destination in a single operation when the buffer is full or explicitly flushed. This significantly reduces the number of costly I/O operations.

Example: Using BufferedInputStream and BufferedOutputStream

This example demonstrates copying data from an input file (`input.txt`) to an output file (`output.txt`) using `BufferedInputStream` and `BufferedOutputStream`. The `try-with-resources` statement ensures that the streams are closed automatically. The `read()` method of `BufferedInputStream` reads data from the buffer (or refills the buffer from the file if it's empty). The `write()` method of `BufferedOutputStream` writes data to the buffer, and the buffer is flushed to the file when it's full. The `flush()` method is called optionally to write any remaining data in the buffer to the output file.

import java.io.*;

public class BufferedStreamExample {
    public static void main(String[] args) {
        try (FileInputStream fis = new FileInputStream("input.txt");
             BufferedInputStream bis = new BufferedInputStream(fis);
             FileOutputStream fos = new FileOutputStream("output.txt");
             BufferedOutputStream bos = new BufferedOutputStream(fos)) {

            int data;
            while ((data = bis.read()) != -1) {
                bos.write(data);
            }

            // bos.flush(); // Optional, but good practice to ensure all data is written

        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

Concepts behind the snippet

  • FileInputStream/FileOutputStream: These provide low-level access to files.
  • BufferedInputStream/BufferedOutputStream: These wrap the file streams, adding buffering capabilities.
  • try-with-resources: Ensures resources (streams) are automatically closed after use, preventing resource leaks.
  • read() and write(): These are fundamental methods for reading from and writing to the streams, respectively.
  • flush(): Forces any buffered output bytes to be written to the output stream. It is called automatically when the stream is closed, but it can be manually called if you want to ensure that data is written to disk immediately.

Real-Life Use Case

Buffered streams are commonly used when reading or writing large files, such as image processing, video encoding/decoding, and database operations. Imagine reading a large CSV file to load data into a database. Using a buffered stream to read chunks of data can dramatically improve the overall performance compared to unbuffered reads. Also, in network applications, when dealing with socket communication, buffered streams improve throughput when sending and receiving data in chunks.

Best Practices

  • Always wrap low-level streams: Use buffered streams with underlying streams like `FileInputStream`, `FileOutputStream`, `FileReader`, `FileWriter`, etc.
  • Use try-with-resources: Ensure that streams are properly closed to prevent resource leaks.
  • Consider buffer size: While the default buffer size is generally good, you might tune it based on your application's needs and the size of the data being processed. Use the constructor `new BufferedInputStream(inputStream, bufferSize)` to specify the size.
  • Call flush() when necessary: Explicitly flush the buffer, especially when you want to ensure data is written to the destination immediately.

Interview Tip

When asked about performance optimization in Java I/O, mentioning buffered streams is a key point. Be prepared to explain how they work and why they are important. You can also mention the trade-off between memory usage and I/O performance. Also, be prepared to provide an example.

When to use them

Use buffered streams when:
  • You are dealing with frequent read/write operations to a file or network socket.
  • Performance is critical, and you want to minimize the number of I/O operations.
  • You are working with large amounts of data that can be efficiently processed in chunks.

Memory footprint

Buffered streams consume additional memory due to the internal buffer. The default buffer size is typically 8KB, but you can customize it. It's important to consider the memory limitations of your application when choosing the buffer size. A larger buffer can improve performance but consumes more memory.

Alternatives

Alternatives to buffered streams include:
  • NIO (New I/O): Provides non-blocking I/O operations and is suitable for high-performance applications.
  • Memory-mapped files: Allow you to map a file directly into memory, which can improve performance for certain types of operations.
  • Channels and Buffers (NIO): More advanced constructs that allow you to interact directly with the operating system to manage I/O.

Pros

  • Improved performance: Reduced number of physical I/O operations.
  • Simplified code: Easy to use with existing streams.

Cons

  • Increased memory usage: Requires additional memory for the buffer.
  • Data loss potential: If the program crashes before the buffer is flushed, data may be lost ( mitigated by using flush() more often).

← Main classes for file I/O? What are byte streams and character streams? →

FAQ

  • What is the default buffer size for BufferedInputStream and BufferedOutputStream?

    The default buffer size is 8192 bytes (8KB).
  • Do I need to call `flush()` on a BufferedOutputStream?

    It's a good practice to call `flush()` to ensure that all buffered data is written to the underlying stream, especially before closing the stream. However, the stream will automatically be flushed when closed.
  • Can I use buffered streams with network sockets?

    Yes, you can wrap `InputStream` and `OutputStream` obtained from a `Socket` with `BufferedInputStream` and `BufferedOutputStream` to improve network I/O performance.