PrintWriter vs. FileWriter in Java

1. Overview

The Java standard library provides API for file manipulation. The PrintWriter and FileWriter classes help to write characters to a file. However, the two classes are intended for different use cases.

In this tutorial, we’ll explore details about PrintWriter and FileWriter with respect to their use cases. Also, we’ll see the differences and similarities between the two classes.

2. PrintWriter

The PrintWriter class helps write formatted text to an output stream like file and console.

Moreover, methods in the PrintWriter class don’t throw IOExceptions. Instead, it has the checkError() method to know the state of the write operation. The checkError() method returns false if the write operation passes, and true if it failed due to an error.

Additionally, the checkError() flushes the stream if it’s not closed before checking the error state.

Furthermore, PrintWriter provides a method named flush() to explicitly flush the stream after write operations. However, when used with the try-with-resources block, there’s no need to explicitly flush the stream.

2.1. PrintWriter.println()

The println() method writes a string to the output stream and terminates with a new line. It can’t write formatted text to an output stream.

Also, PrintWriter provides the print() method in case we decide not to terminate a string with a new line.

Here’s an example using the println() method to write a string to a file:

@Test
void whenWritingToTextFileUsingPrintWriterPrintln_thenTextMatches() throws IOException {
    String result = "I'm going to Alabama\nAlabama is a state in the US\n";
    try (PrintWriter pw = new PrintWriter("alabama.txt");) {
        pw.println("I'm going to Alabama");
        pw.println("Alabama is a state in the US");
    }
    Path path = Paths.get("alabama.txt");
    String actualData = new String(Files.readAllBytes(path));
    assertEquals(result, actualData);
}

Here, we create a PrintWriter object which takes the file path as an argument. Next, we invoke the println() method on the PrintWriter object to write characters to the file.

Finally, we assert that the expected result is equal to the file content.

Notably, PrintWriter also provides a write() method to write text to file, and we can use it in place of the print() method.

2.2. PrintWriter.printf()

The printf() method helps to write a formatted text to an output stream. We can use format specifiers like %s, %d, .2f, etc. to write different data types to an output stream.

Let’s see some sample code using printf() to write formatted data to a file:

@Test
void whenWritingToTextFileUsingPrintWriterPrintf_thenTextMatches() throws IOException {
    String result = "Dreams from My Father by Barack Obama";
    File file = new File("dream.txt");
    try (PrintWriter pw = new PrintWriter(file);) {
        String author = "Barack Obama";
        pw.printf("Dreams from My Father by %s", author);
        assertTrue(!pw.checkError());
    }
    try (BufferedReader reader = new BufferedReader(new FileReader(file));) {
        String actualData = reader.readLine();
        assertEquals(result, actualData);
    }
}

In the code above, we write formatted text to a file. We use the %s identifier to directly add a String data type to the text.

Also, we create an instance of BufferedReader that takes the FileReader object as an argument to read the content of a file.

Since the method doesn’t throw an IOException, we invoke the checkError() method to know the state of the write operation. In this case, checkError() returns false, indicating no errors.

3. FileWriter

The FileWriter class extends the Writer class. It provides a convenient method to write characters to a file using a preset buffer size.

FileWriter doesn’t flush the buffer automatically. We need to invoke the flush() method. However, when FileWriter is used with the try-with-resources block, it automatically flushes and closes the stream when exiting the block.

Furthermore, it throws an IOException in the case of a missing file, when a file cannot be opened, etc.

Unlike PrintWriter, it can’t write formatted text to a file.

Let’s see an example using the write() method in FileWriter class to write characters to a File:

@Test
void whenWritingToTextFileUsingFileWriter_thenTextMatches() throws IOException {
    String result = "Harry Potter and the Chamber of Secrets";
    File file = new File("potter.txt");
    try (FileWriter fw = new FileWriter(file);) {
        fw.write("Harry Potter and the Chamber of Secrets");
    }
    try (BufferedReader reader = new BufferedReader(new FileReader(file));) {
        String actualData = reader.readLine();
        assertEquals(result, actualData);
    }
}

In the code above, we create an instance of a File and pass it to a FileWriter object. Next, we invoke the write() method on the FileWriter object to write a string of characters to a file.

Finally, we assert that the expected result is equal to the content of the file.

4. Conclusion

In this article, we learned the basic usage of FileWriter and PrintWriter with example code.

The primary purpose of a FileWriter is to write characters to a file. However, PrintWriter has more functionalities. It can write to other output streams apart from a file. Also, it provides a method to write formatted text to a file or console.