Of course! Deleting a file in Java is a common task. The modern and recommended approach is to use the java.nio.file package (introduced in Java 7), as it's more powerful and flexible than the legacy java.io.File.

Here’s a complete guide covering:

1. The Modern & Recommended Way (java.nio.file.Files)
2. The Legacy Way (java.io.File)
3. Handling Common Scenarios (Files not found, directories, etc.)
4. Deleting a Directory and its Contents

The Modern & Recommended Way: java.nio.file.Files (Java 7+)

This is the best practice for new code. The Files class provides static utility methods for file operations.

A. Deleting a Single File

The primary method is Files.delete(Path path). It's simple but has a crucial behavior: it throws an exception if the file doesn't exist.

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
public class DeleteFileExample {
    public static void main(String[] args) {
        // Define the path to the file you want to delete.
        // The path can be relative or absolute.
        Path path = Paths.get("my-document.txt");
        try {
            // The delete() method attempts to delete the file or directory.
            // It will throw an exception if the file does not exist.
            Files.delete(path);
            System.out.println("File deleted successfully: " + path.getFileName());
        } catch (NoSuchFileException e) {
            // This exception is thrown if the file does not exist.
            System.err.println("Error: File not found - " + path);
        } catch (DirectoryNotEmptyException e) {
            // This exception is thrown if the path is a directory that is not empty.
            System.err.println("Error: Directory is not empty - " + path);
        } catch (IOException e) {
            // This is a general IOException that could be thrown for other reasons
            // (e.g., no permission to delete the file).
            System.err.println("An error occurred while deleting the file: " + e.getMessage());
        }
    }
}

B. Safely Deleting a File (if it exists)

Often, you want to delete a file if it exists but don't want an error if it doesn't. For this, use Files.deleteIfExists(Path path). This method returns true if the file was deleted and false if it didn't exist.

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
public class SafeDeleteExample {
    public static void main(String[] args) {
        Path path = Paths.get("report-2025.pdf");
        try {
            // deleteIfExists() will not throw an exception if the file is not found.
            // It returns a boolean indicating the outcome.
            boolean deleted = Files.deleteIfExists(path);
            if (deleted) {
                System.out.println("File deleted successfully: " + path.getFileName());
            } else {
                System.out.println("File was not found, nothing to delete: " + path.getFileName());
            }
        } catch (IOException e) {
            // This can still be thrown for other I/O issues (e.g., permissions).
            System.err.println("An error occurred: " + e.getMessage());
        }
    }
}

The Legacy Way: java.io.File (Pre-Java 7)

Before Java 7, you used the File class. It's still functional but less robust. The delete() method returns true on success and false on failure, which can be ambiguous (is it false because the file didn't exist or because of a permission error?).

import java.io.File;
public class LegacyDeleteExample {
    public static void main(String[] args) {
        // Create a File object representing the file to be deleted.
        File fileToDelete = new File("old-data.log");
        // The delete() method returns true if deletion was successful,
        // and false if it failed.
        boolean isDeleted = fileToDelete.delete();
        if (isDeleted) {
            System.out.println("File deleted successfully: " + fileToDelete.getName());
        } else {
            // We need to manually check why it failed.
            if (!fileToDelete.exists()) {
                System.out.println("File was not found: " + fileToDelete.getName());
            } else {
                System.out.println("Failed to delete the file. It might be in use or you lack permissions.");
            }
        }
    }
}

Recommendation: Use the java.nio.file approach for all new development.

Handling Common Scenarios

Deleting a Directory

You cannot delete a directory using Files.delete() unless it is empty.

• To delete an empty directory: Files.delete(path) works perfectly.
• To delete a directory and all its contents: You must first delete all the files and subdirectories inside it. The easiest way is to use a recursive helper method.

import java.io.IOException;
import java.nio.file.FileVisitResult;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.SimpleFileVisitor;
import java.nio.file.attribute.BasicFileAttributes;
public class DeleteDirectoryExample {
    public static void main(String[] args) {
        Path directoryToDelete = Paths.get("my-folder");
        try {
            // Use the deleteRecursively helper method
            deleteRecursively(directoryToDelete);
            System.out.println("Directory and its contents deleted successfully.");
        } catch (IOException e) {
            System.err.println("Failed to delete directory: " + e.getMessage());
        }
    }
    /**
     * Deletes a directory and all its contents (files and subdirectories).
     * @param path The path to the directory to delete.
     * @throws IOException If an I/O error occurs.
     */
    public static void deleteRecursively(Path path) throws IOException {
        // This is the key: Files.walk() traverses the file tree.
        // Files.walkFileTree() allows you to perform an action on each file/directory.
        Files.walkFileTree(path, new SimpleFileVisitor<Path>() {
            @Override
            public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) throws IOException {
                // For each file, delete it.
                Files.delete(file);
                System.out.println("Deleted file: " + file);
                return FileVisitResult.CONTINUE;
            }
            @Override
            public FileVisitResult postVisitDirectory(Path dir, IOException exc) throws IOException {
                // After visiting all files in a directory, delete the directory itself.
                if (exc == null) {
                    Files.delete(dir);
                    System.out.println("Deleted directory: " + dir);
                    return FileVisitResult.CONTINUE;
                }
                // If an exception occurred during directory visit, re-throw it.
                throw exc;
            }
        });
    }
}

Deleting with Files.deleteIfExists() on a Directory

Files.deleteIfExists() works on directories too, but only if they are empty.

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;
public class DeleteEmptyDirectoryExample {
    public static void main(String[] args) {
        Path emptyDir = Paths.get("empty-folder");
        try {
            boolean deleted = Files.deleteIfExists(emptyDir);
            if (deleted) {
                System.out.println("Empty directory deleted.");
            } else {
                System.out.println("Directory was not empty or did not exist.");
            }
        } catch (IOException e) {
            System.err.println("Error deleting directory: " + e.getMessage());
        }
    }
}

Summary: Which Method to Use?