Loading…
Buffered Streams in Java:
Buffered streams are used to improve the performance of input/output operations by reducing the number of system calls. They achieve this by using an internal buffer to read from or write to the underlying input/output stream in larger chunks, rather than one byte or character at a time.
Buffered Input Stream Classes:
- `BufferedInputStream`: Provides buffering for input bytes, allowing the reading of data from an underlying input stream.
- `BufferedReader`: Reads text from a character-input stream, buffering characters to provide efficient reading of characters, arrays, and lines.
Buffered Output Stream Classes:
- `BufferedOutputStream`: Provides buffering for output bytes, allowing the writing of data to an underlying output stream.
- `BufferedWriter`: Writes text to a character-output stream, buffering characters to provide efficient writing of characters, arrays, and lines.
Example: Reading from a File using BufferedReader:
import java.io.BufferedReader;
import java.io.FileReader;
import java.io.IOException;
public class BufferedStreamExample {
public static void main(String[] args) {
try (BufferedReader reader = new BufferedReader(new FileReader("example.txt"))) {
String line;
while ((line = reader.readLine()) != null) {
System.out.println(line);
}
} catch (IOException e) {
e.printStackTrace();
}
}
}
Explanation:
- In this example, we use `BufferedReader` to read text from a file ("example.txt").
- We wrap a `FileReader` with a `BufferedReader` to buffer the input and improve reading performance.
- The `readLine()` method of `BufferedReader` reads a line of text from the input stream. If the end of the stream is reached, it returns `null`.
- We use a `try-with-resources` statement to automatically close the `BufferedReader` when the block ends, ensuring proper resource management.
Benefits of Buffered Streams:
- Reduced number of system calls: Buffered streams reduce the number of system calls by reading or writing data in larger chunks.
- Improved performance: Buffered streams typically provide faster read/write operations compared to their unbuffered counterparts.
- Convenient API: Buffered streams offer convenient methods for reading and writing data, such as `readLine()` in `BufferedReader` for reading lines of text.
------------------------
Here's an example demonstrating the usage of `BufferedWriter` in Java:
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class BufferedWriterExample {
public static void main(String[] args) {
String filename = "output.txt";
try (BufferedWriter writer = new BufferedWriter(new FileWriter(filename))) {
writer.write("Hello, World!");
writer.newLine(); // Write a newline character
// Writing multiple lines
writer.write("This is an example of BufferedWriter.");
writer.newLine();
writer.write("It provides efficient writing of characters, arrays, and lines.");
System.out.println("Data has been written to " + filename);
} catch (IOException e) {
e.printStackTrace();
}
}
}
Explanation:
- We create a `BufferedWriter` object and wrap it around a `FileWriter`, specifying the file name ("output.txt") to write to.
- Using the `write()` method, we write a string to the file. The `newLine()` method is called to insert a newline character after each line.
- Multiple lines of text are written to the file using separate `write()` calls.
- The `try-with-resources` statement is used to automatically close the `BufferedWriter` when the block ends, ensuring proper resource management.
- If any `IOException` occurs during the writing process, it is caught and the stack trace is printed.
This example demonstrates how `BufferedWriter` can efficiently write text data to a file by buffering the output, which can lead to improved performance compared to writing directly to the file.
----------------
Here's a program that reads input from the user using `BufferedReader` and writes it to a file using `BufferedWriter`:
import java.io.BufferedReader;
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
import java.io.InputStreamReader;
public class BufferedIOExample {
public static void main(String[] args) {
try (BufferedReader reader = new BufferedReader(new InputStreamReader(System.in));
BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
// Read input from the user
System.out.println("Enter text (type 'exit' to quit):");
String line;
while (!(line = reader.readLine()).equalsIgnoreCase("exit")) {
// Write input to a file
writer.write(line);
writer.newLine(); // Write a newline character
}
System.out.println("Data has been written to output.txt");
} catch (IOException e) {
e.printStackTrace();
}
}
}
Explanation:
- We create a `BufferedReader` object `reader` to read input from the user via `System.in`.
- We create a `BufferedWriter` object `writer` to write data to a file named "output.txt".
- Inside the `while` loop, we continuously read lines of input from the user using `reader.readLine()`.
- If the user types "exit", the loop terminates.
- For each line read from the user, we write it to the file using `writer.write(line)` and add a newline character using `writer.newLine()`.
- The `try-with-resources` statement ensures that both `reader` and `writer` are properly closed after use.
- If any `IOException` occurs during the process, it is caught and the stack trace is printed.
In summary, buffered streams in Java improve I/O performance by reducing system calls and providing efficient buffering of data. They are commonly used in applications where I/O performance is critical, such as reading/writing large files or network communication.
Comments
Post a Comment