Java BufferedWriter Methods: A Complete Guide
Working with text files is a common task in Java development—whether you're generating reports, logging program activity, storing configuration details, or exporting data. While Java provides several classes for file I/O, BufferedWriter stands out as one of the most efficient options for writing text to character-based output streams.
BufferedWriter is part of the java.io package. It enhances performance by reducing the number of physical write operations. The class achieves this by storing characters in an internal buffer and writing them to the file in chunks.
In this article, we’ll explore BufferedWriter in depth and examine every important method it offers—complete with explanations, examples, and best use cases.
1. Introduction to BufferedWriter
BufferedWriter is a subclass of Writer, providing a character-oriented approach to writing text. It is typically paired with FileWriter, though it can wrap any Writer instance.
Why Use BufferedWriter?
Without buffering, every write() call results in direct interaction with the file system. This can be slow and inefficient. BufferedWriter solves this problem by:
- Minimizing disk or stream operations
- Improving performance for large text output
- Supporting convenient methods like
newLine()
Basic Syntax
BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"));
You should always close the writer after use or use try-with-resources:
try (BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
writer.write("Hello, world!");
}
2. Key BufferedWriter Methods
BufferedWriter provides several methods inherited from Writer and a few of its own. Let’s explore them one by one.
3. write(String str) Method
Description
This method writes a string to the buffer. It does not automatically append a newline character.
Syntax
public void write(String str) throws IOException
Example
writer.write("Java BufferedWriter Tutorial");
writer.write(" - No newline included automatically.");
When to Use
Use this when writing standard text data without needing manual character-level control.
4. write(char[] cbuf) Method
Description
Writes a character array to the buffer. Efficient for scenarios where data is already stored as a char array.
Syntax
public void write(char[] cbuf) throws IOException
Example
char[] data = {'H', 'e', 'l', 'l', 'o'};
writer.write(data);
5. write(char[] cbuf, int off, int len) Method
Description
Writes a portion of a character array. Useful when dealing with large arrays
where only part of them needs writing.
Syntax
public void write(char[] cbuf, int off, int len) throws IOException
Example
char[] letters = {'A','B','C','D','E','F'};
writer.write(letters, 2, 3); // Writes "CDE"
6. write(int c) Method
Description
Writes a single character (represented by an integer). This is rarely used in bulk writing, but helpful for low-level operations.
Syntax
public void write(int c) throws IOException
Example
writer.write('A');
writer.write(65); // Also writes 'A'
7. write(String str, int
off, int len)
Description
Writes a specific portion of a string.
Syntax
public void write(String str, int off, int len) throws IOException
Example
String message = "BufferedWriter Methods in Java";
writer.write(message, 0, 11); // writes "BufferedWri"
Use Case
Great for partial content writing or
when slicing repeated output.
8. newLine() Method
Description
Inserts the system-dependent line separator into the output. This is a major advantage over using "\n" because newLine() adjusts automatically to:
- Windows →
\r\n - macOS/Linux/Unix →
\n
Syntax
public void newLine() throws IOException
Example
writer.write("First Line");
writer.newLine();
writer.write("Second Line");
9. flush() Method
Description
Forces any buffered output to be written immediately. If the buffer isn’t full yet,
data may still be sitting in memory.
Syntax
public void flush() throws IOException
Example
writer.write("Important Data");
writer.flush(); // Ensure it gets written immediately
When to Use
- Before closing the writer
- When writing data that must be saved in real time
- When writing logs that require immediate persistence
10. close() Method
Description
Closes the stream and releases system resources. It also automatically flushes the buffer.
Syntax
public void close() throws IOException
Example
writer.close();
Important Note
Once closed, you cannot reopen or reuse the same BufferedWriter object.
11. Full Example Program Using BufferedWriter Methods
Below is a working example
demonstrating multiple methods together.
import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;
public class BufferedWriterDemo {
public static void main(String[] args) {
try (BufferedWriter writer = new BufferedWriter(new FileWriter("example.txt"))) {
writer.write("Java BufferedWriter Methods");
writer.newLine();
char[] array = {'H','e','l','l','o'};
writer.write(array);
writer.newLine();
writer.write(array, 1, 3); // "ell"
writer.newLine();
writer.write("BufferedWriter Example", 0, 10); // "BufferedWr"
writer.newLine();
writer.write(65); // 'A'
writer.newLine();
writer.flush(); // Ensures all content is written
} catch (IOException e) {
e.printStackTrace();
}
}
}
This generates a file containing multiple types of outputs using different write methods.
12. When Should You Use BufferedWriter?
BufferedWriter is ideal when:
✔ Writing large amounts of text
Its buffering minimizes disk I/O operations.
✔ Writing log files
Frequent log entries benefit from
buffer-based batching.
✔ Handling character-based data
Perfect for text files, configuration
files, or code generation.
✔ Adding system-independent new lines
newLine() ensures portability.
13. Advantages of BufferedWriter
1. Faster Performance
Buffering reduces the number of write operations, significantly improving speed.
2. System-dependent New Line
newLine() saves you from hardcoding line breaks.
3. Flexibility with Writer Objects
Can wrap:
- FileWriter
- OutputStreamWriter
- PrintWriter
4. Easy to Use
Simple API with intuitive methods.
14. Limitations of BufferedWriter
1. Character-only Data
BufferedWriter works with characters—not binary data.
2. Must Be Closed Properly
Failure to close it may cause
data loss due to unflushed buffers.
3. No Built-in Formatting
Unlike PrintWriter, BufferedWriter doesn’t provide formatted output like printf().
15. BufferedWriter vs FileWriter
| Feature | FileWriter | BufferedWriter |
|---|---|---|
| Performance | Slower | Faster due to buffering |
| Buffer | No | Yes |
| Methods | Basic | Includes newLine() |
| Best For | Small writes | Large text writes |
16. Best Practices
✔ Use try-with-resources
Ensures flushing and closing automatically.
✔ Combine with PrintWriter When Needed
If formatting is needed:
PrintWriter p = new PrintWriter(new BufferedWriter(new FileWriter("text.txt")));
✔ Call flush() When Writing Critical Data
✔ Avoid Excessive write() Calls in Loops
Accumulate text when possible.
Conclusion
BufferedWriter is one of the most powerful and efficient tools for writing text files in Java. Its buffering mechanism significantly enhances performance, especially for large-scale output operations. With useful methods like write(), newLine(), flush(), and close(), BufferedWriter provides an easy-to-use yet highly flexible API for developers.
Whether you're creating logs, exporting data, writing reports, or generating text-based files, mastering BufferedWriter methods will greatly improve the quality and performance of your file-handling code.
.jpeg "Python Power: Effortless Audiobook Creation with Google Text-to-Speech (gTTS)")
.jpeg)
