Topic 14924 min readStructured Tutorial

Writing Files in Java

Quick Answer

Writing Files explains writing data to files is a fundamental task in many Java applications.

Learning Objectives

Explain the purpose of Writing Files in a practical learning context.
Identify the main ideas, terms, and decisions involved in Writing Files.
Apply Writing Files in a simple real-world scenario or practice task.

Introduction

Writing data to files is a fundamental task in many Java applications.

This tutorial covers the basics of writing files in Java using different classes and methods.

You will learn how to write text data efficiently and safely to files.

Data is the new oil, and writing it correctly is key to unlocking its value.

Using FileWriter to Write Files

FileWriter is a simple class for writing character files in Java.

It writes characters directly to a file and is suitable for writing small amounts of text.

Create a FileWriter object with the target file path.
Use the write() method to write strings or characters.
Always close the FileWriter to release system resources.

Example: Writing a Simple Text File

This example demonstrates writing a string to a file named 'output.txt' using FileWriter.

BufferedWriter for Efficient Writing

BufferedWriter wraps around FileWriter to buffer the output and improve performance.

It is recommended when writing larger amounts of data or writing in loops.

Wrap FileWriter with BufferedWriter.
Use write() or newLine() methods to write data and line breaks.
Flush and close BufferedWriter to ensure all data is written.

Example: Writing Multiple Lines with BufferedWriter

This example writes multiple lines to a file efficiently using BufferedWriter.

Using Files.write() for Simple File Writing

Java NIO Files class provides a convenient write() method to write bytes or lines to a file in one call.

It is useful for quick file writing without manually managing streams.

Use Files.write() with a Path object and byte array or list of strings.
Specify options like StandardOpenOption to control file behavior.
Automatically handles opening and closing the file.

Example: Writing Lines Using Files.write()

This example writes a list of strings to a file using Files.write().

Handling Exceptions When Writing Files

File writing operations can throw IOException, which must be handled or declared.

Proper exception handling ensures your program can respond to errors like missing permissions or disk issues.

Use try-with-resources to automatically close streams.
Catch IOException to handle errors gracefully.
Log or inform users when file writing fails.

Practical Example

This example creates a FileWriter to write a string to 'output.txt'. It uses try-with-resources to close the writer automatically.

This example uses BufferedWriter to write two lines to a file, adding a newline between them.

This example writes a list of strings to 'output.txt' using the Files.write() method.

Examples

Writing a Simple Text File with FileWriter

import java.io.FileWriter;
import java.io.IOException;

public class WriteFileExample {
    public static void main(String[] args) {
        try (FileWriter writer = new FileWriter("output.txt")) {
            writer.write("Hello, Java file writing!\n");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

This example creates a FileWriter to write a string to 'output.txt'. It uses try-with-resources to close the writer automatically.

Writing Multiple Lines with BufferedWriter

import java.io.BufferedWriter;
import java.io.FileWriter;
import java.io.IOException;

public class BufferedWriteExample {
    public static void main(String[] args) {
        try (BufferedWriter writer = new BufferedWriter(new FileWriter("output.txt"))) {
            writer.write("First line");
            writer.newLine();
            writer.write("Second line");
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

This example uses BufferedWriter to write two lines to a file, adding a newline between them.

Writing Lines Using Files.write()

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
import java.io.IOException;
import java.util.Arrays;
import java.util.List;

public class FilesWriteExample {
    public static void main(String[] args) {
        Path file = Paths.get("output.txt");
        List<String> lines = Arrays.asList("Line 1", "Line 2", "Line 3");
        try {
            Files.write(file, lines);
        } catch (IOException e) {
            e.printStackTrace();
        }
    }
}

This example writes a list of strings to 'output.txt' using the Files.write() method.

Best Practices

Always close file streams to avoid resource leaks; use try-with-resources.
Use BufferedWriter for better performance when writing multiple lines or large data.
Handle IOExceptions properly to make your application robust.
Use Files.write() for simple, small file writes to reduce boilerplate code.
Specify character encoding explicitly if your application requires it.

Common Mistakes

Forgetting to close the FileWriter or BufferedWriter, causing resource leaks.
Not handling IOExceptions, which can cause your program to crash unexpectedly.
Using FileWriter without buffering for large files, leading to poor performance.
Assuming Files.write() appends by default; it overwrites unless specified.
Writing binary data with character streams, which can corrupt the data.

Hands-on Exercise

Write a Log File

Create a Java program that writes multiple log entries to a file using BufferedWriter. Each entry should be on a new line.

Expected output: A text file with multiple log lines, each on its own line.

Hint: Use BufferedWriter's newLine() method to add line breaks.

Append Text to a File

Modify a file writing program to append text to an existing file instead of overwriting it.

Expected output: The file contains both old and new text after running the program.

Hint: Use FileWriter's constructor with the append flag set to true.

Interview Questions

What is the difference between FileWriter and BufferedWriter in Java?

Interview

FileWriter writes characters directly to a file, while BufferedWriter wraps a Writer like FileWriter to buffer the output, improving performance by reducing disk access.

How do you ensure a file stream is properly closed in Java?

Interview

Use try-with-resources syntax introduced in Java 7, which automatically closes streams when the try block exits.

What exception must you handle when writing files in Java?

Interview

You must handle or declare IOException, which covers input/output errors during file operations.