File Handling in Java

File handling in Java is the process of creating, reading, writing, updating, and deleting files using a Java program.

File handling allows a program to store data permanently. Unlike variables, data written to a file remains available after the program stops running.

Java provides file-handling classes through the java.io and java.nio.file packages. The modern Path and Files APIs provide simple methods for common file operations.

Common File-Handling Classes

Class or Interface	Purpose
`Path`	Represents the location of a file or directory
`Files`	Provides methods to create, read, write, and delete files
`File`	Represents a file or directory using the older I/O API
`FileWriter`	Writes character data to a file
`BufferedReader`	Reads text efficiently
`Scanner`	Reads text from a file in a beginner-friendly way

This article uses Path and Files for simple text-file operations.

File handling in java

Creating and Writing to a File

The Files.writeString() method writes text to a file. If the file does not exist, Java creates it. If it already exists, its previous contents are replaced by default.

1import java.io.IOException;
2import java.nio.file.Files;
3import java.nio.file.Path;
4
5public class Main {
6    public static void main(String[] args) {
7
8        // Create a Path representing the file location
9        Path filePath = Path.of("notes.txt");
10
11        try {
12            // Create the file if required and write text into it
13            Files.writeString(
14                    filePath,
15                    "Learning Java File Handling"
16            );
17
18            // Confirm that the writing operation completed
19            System.out.println("File created and data written."); // Output :- File created and data written.
20
21        } catch (IOException exception) {
22
23            // Handle problems such as invalid paths or permissions
24            System.out.println("Unable to write the file.");
25        }
26    }
27}

The file is created in the program’s current working directory because only a filename is provided.

Creating and Writing to a File

Reading a File in Java

The Files.readString() method reads the complete contents of a small text file as a string.

1import java.io.IOException;
2import java.nio.file.Files;
3import java.nio.file.Path;
4
5public class Main {
6    public static void main(String[] args) {
7
8        // Create a Path for the existing file
9        Path filePath = Path.of("notes.txt");
10
11        try {
12            // Read the complete file contents
13            String content = Files.readString(filePath);
14
15            // Display the data read from the file
16            System.out.println(content); // Output :- Learning Java File Handling
17
18        } catch (IOException exception) {
19
20            // Handle a missing or unreadable file
21            System.out.println("Unable to read the file.");
22        }
23    }
24}

readString() is convenient for small text files. Large files should normally be read gradually using a buffered reader or stream.

Reading a File

Appending Data to a File

Appending adds new data to the end of a file without deleting its existing contents.

Use StandardOpenOption.APPEND to open the file in append mode.

1import java.io.IOException;
2import java.nio.file.Files;
3import java.nio.file.Path;
4import java.nio.file.StandardOpenOption;
5
6public class Main {
7    public static void main(String[] args) {
8
9        // Path of the file created earlier
10        Path filePath = Path.of("notes.txt");
11
12        try {
13            // Add a new line without replacing existing content
14            Files.writeString(
15                    filePath,
16                    System.lineSeparator() + "This is the second line.",
17                    StandardOpenOption.APPEND
18            );
19
20            // Confirm that new data was added
21            System.out.println("Data appended successfully."); // Output :- Data appended successfully.
22
23        } catch (IOException exception) {
24
25            // Handle errors while appending data
26            System.out.println("Unable to append data.");
27        }
28    }
29}

The file now contains its original text followed by the newly appended line.

Appending data to a File

Deleting a File in Java

The Files.deleteIfExists() method deletes a file when it exists. It returns true when the file is deleted and false when the file is not found.

1import java.io.IOException;
2import java.nio.file.Files;
3import java.nio.file.Path;
4
5public class Main {
6    public static void main(String[] args) {
7
8        // Specify the file that should be deleted
9        Path filePath = Path.of("notes.txt");
10
11        try {
12            // Delete the file if it exists
13            boolean deleted = Files.deleteIfExists(filePath);
14
15            // Check whether deletion was successful
16            if (deleted) {
17                System.out.println("File deleted successfully."); // Output :- File deleted successfully.
18            } else {
19                System.out.println("File does not exist.");
20            }
21
22        } catch (IOException exception) {
23
24            // Handle permission or file-system errors
25            System.out.println("Unable to delete the file.");
26        }
27    }
28}

Deleting a File

File Paths in Java

Java supports two types of file paths:

Relative path: Describes a location relative to the program’s current working directory.
Absolute path: Provides the complete location of the file.

1// Relative path
2Path relativePath = Path.of("notes.txt");
3
4// Example absolute path on Windows
5Path absolutePath = Path.of("C:", "data", "notes.txt");

Using Path.of() with separate path parts helps Java construct the path using the operating system’s correct separators.

Why Is IOException Handled?

File operations may fail because:

The file does not exist
The path is invalid
The program lacks permission
The storage device is unavailable
Another application is using the file

Many file methods throw IOException, so the operation should be handled using try-catch or declared using throws.

Summary

File handling in Java allows programs to store and retrieve data from files.

The Path interface represents a file location, while the Files class provides convenient methods to write, read, append, and delete files. File operations should be placed inside exception-handling code because they may produce an IOException.

File Handling in Java