File Operations

Intermediate ~30 min read

Working with files and directories is a fundamental skill in Java programming. The File class from the java.io package provides methods to create, delete, rename, and get information about files and directories. Understanding file operations is essential for building applications that need to persist data or work with the file system.

The File Class

The File class represents a file or directory pathname. It's important to note that creating a File object doesn't actually create a file on disk—it just represents a path. The file is only created when you explicitly call methods like createNewFile().

Key Points about File Class

Represents a file or directory path, not the actual file
Provides methods to check file existence, properties, and perform operations
Part of java.io package (import needed)
Works with both absolute and relative paths

Creating a File Object

You can create a File object using a file path (string):

import java.io.File;

// Create File object for a file
File file = new File("example.txt");

// Create File object with absolute path
File absoluteFile = new File("/path/to/file.txt");

// Create File object with parent directory and filename
File fileWithParent = new File("directory", "file.txt");

import java.io.File;

public class IoFile {
    public static void main(String[] args) {
        // Create a File object (doesn't create actual file)
        File file = new File("example.txt");
        
        // Check if file exists
        if (file.exists()) {
            System.out.println("File exists!");
            System.out.println("File name: " + file.getName());
            System.out.println("Absolute path: " + file.getAbsolutePath());
            System.out.println("File size: " + file.length() + " bytes");
            System.out.println("Is file: " + file.isFile());
            System.out.println("Is directory: " + file.isDirectory());
            System.out.println("Can read: " + file.canRead());
            System.out.println("Can write: " + file.canWrite());
        } else {
            System.out.println("File does not exist.");
        }
        
        // Create a new file
        try {
            boolean created = file.createNewFile();
            if (created) {
                System.out.println("\nFile created successfully!");
            } else {
                System.out.println("\nFile already exists or cannot be created.");
            }
        } catch (Exception e) {
            System.out.println("Error creating file: " + e.getMessage());
        }
        
        // Get file information after creation
        if (file.exists()) {
            System.out.println("\nAfter creation:");
            System.out.println("File name: " + file.getName());
            System.out.println("File size: " + file.length() + " bytes");
        }
    }
}

Output

Click Run to execute your code

Checking File Existence

Before performing operations on a file, it's often necessary to check if it exists:

File file = new File("data.txt");

if (file.exists()) {
    System.out.println("File exists!");
} else {
    System.out.println("File does not exist.");
}

Always Check Before Operations

Always check if a file exists before trying to read from it or perform operations on it. This prevents FileNotFoundException and other errors.

Getting File Information

The File class provides many methods to get information about a file:

Method	Description
`getName()`	Returns the name of the file or directory
`getAbsolutePath()`	Returns the absolute pathname string
`length()`	Returns the length of the file in bytes
`isFile()`	Tests if the file denoted by this pathname is a normal file
`isDirectory()`	Tests if the file denoted by this pathname is a directory
`canRead()`	Tests whether the application can read the file
`canWrite()`	Tests whether the application can modify the file
`lastModified()`	Returns the time that the file was last modified (milliseconds since epoch)

Creating Files

To actually create a file on disk, use the createNewFile() method:

File file = new File("newfile.txt");

try {
    boolean created = file.createNewFile();
    if (created) {
        System.out.println("File created successfully!");
    } else {
        System.out.println("File already exists.");
    }
} catch (IOException e) {
    System.out.println("Error creating file: " + e.getMessage());
}

Exception Handling

The createNewFile() method can throw an IOException if the file cannot be created (e.g., due to permission issues or invalid path). Always wrap it in a try-catch block.

Working with Directories

You can also work with directories using the File class:

import java.io.File;

public class IoDirectories {
    public static void main(String[] args) {
        // Create a File object for a directory
        File dir = new File("test_directory");
        
        // Check if directory exists
        if (dir.exists()) {
            System.out.println("Directory exists!");
            System.out.println("Is directory: " + dir.isDirectory());
        } else {
            System.out.println("Directory does not exist.");
        }
        
        // Create directory
        boolean created = dir.mkdir();
        if (created) {
            System.out.println("\nDirectory created successfully!");
        } else {
            System.out.println("\nDirectory already exists or cannot be created.");
        }
        
        // Create nested directories
        File nestedDir = new File("parent/child/grandchild");
        boolean createdNested = nestedDir.mkdirs();  // Creates parent directories if needed
        if (createdNested) {
            System.out.println("Nested directories created!");
        }
        
        // List files in current directory
        File currentDir = new File(".");
        System.out.println("\nFiles and directories in current directory:");
        String[] files = currentDir.list();
        if (files != null) {
            for (String fileName : files) {
                File file = new File(currentDir, fileName);
                if (file.isDirectory()) {
                    System.out.println("[DIR] " + fileName);
                } else {
                    System.out.println("[FILE] " + fileName);
                }
            }
        }
        
        // Delete directory (must be empty)
        if (dir.exists() && dir.isDirectory()) {
            // First delete any files inside
            File[] dirFiles = dir.listFiles();
            if (dirFiles != null) {
                for (File f : dirFiles) {
                    f.delete();
                }
            }
            // Then delete the directory
            boolean deleted = dir.delete();
            if (deleted) {
                System.out.println("\nDirectory deleted successfully!");
            }
        }
    }
}

Output

Click Run to execute your code

Directory Operations

mkdir() - Creates the directory (returns true if successful)
mkdirs() - Creates the directory including any necessary parent directories
list() - Returns an array of strings naming the files and directories in the directory
listFiles() - Returns an array of File objects
delete() - Deletes the file or directory (directory must be empty)

mkdir() vs mkdirs()

Use mkdir() when you know the parent directory exists. Use mkdirs() to create nested directories in one call, as it creates parent directories if they don't exist.

Deleting Files and Directories

To delete a file or directory, use the delete() method:

File file = new File("file.txt");

if (file.exists()) {
    boolean deleted = file.delete();
    if (deleted) {
        System.out.println("File deleted successfully!");
    } else {
        System.out.println("Failed to delete file.");
    }
}

// For directories, they must be empty
File dir = new File("mydir");
if (dir.exists() && dir.isDirectory()) {
    // Delete all files inside first
    File[] files = dir.listFiles();
    if (files != null) {
        for (File f : files) {
            f.delete();
        }
    }
    // Then delete the directory
    dir.delete();
}

Common Mistakes

1. Assuming File object creates a file

// Wrong - File object doesn't create the file
File file = new File("data.txt");
// File doesn't exist yet!

// Correct - explicitly create the file
File file = new File("data.txt");
file.createNewFile();  // Now the file exists

2. Not checking file existence before operations

// Wrong - may throw exception if file doesn't exist
File file = new File("data.txt");
long size = file.length();  // May cause issues

// Correct - check existence first
File file = new File("data.txt");
if (file.exists()) {
    long size = file.length();
}

3. Not handling IOException

// Wrong - unhandled exception
File file = new File("data.txt");
file.createNewFile();  // May throw IOException

// Correct - handle the exception
try {
    File file = new File("data.txt");
    file.createNewFile();
} catch (IOException e) {
    System.out.println("Error: " + e.getMessage());
}

4. Trying to delete non-empty directory

// Wrong - delete() fails for non-empty directories
File dir = new File("mydir");
dir.delete();  // Returns false if directory has files

// Correct - delete files first, then directory
File dir = new File("mydir");
File[] files = dir.listFiles();
if (files != null) {
    for (File f : files) {
        f.delete();
    }
}
dir.delete();  // Now it will work

Exercise: File Manager

Task: Create a program that:

Creates a directory called "exercise"
Creates a file "info.txt" inside that directory
Checks if the file exists and displays its properties
Lists all files in the directory

Output

Click Run to execute your code

Show Solution

import java.io.File;

public class Exercise {
    public static void main(String[] args) {
        // Create directory
        File dir = new File("exercise");
        dir.mkdir();
        
        // Create file inside directory
        File file = new File(dir, "info.txt");
        try {
            file.createNewFile();
            
            // Check if file exists and display properties
            if (file.exists()) {
                System.out.println("File exists!");
                System.out.println("Name: " + file.getName());
                System.out.println("Path: " + file.getAbsolutePath());
                System.out.println("Size: " + file.length() + " bytes");
            }
            
            // List files in directory
            System.out.println("\nFiles in directory:");
            File[] files = dir.listFiles();
            if (files != null) {
                for (File f : files) {
                    System.out.println("- " + f.getName());
                }
            }
        } catch (Exception e) {
            System.out.println("Error: " + e.getMessage());
        }
    }
}

Summary

The File class represents a file or directory pathname
Creating a File object doesn't create the actual file
Use exists() to check if a file exists
Use createNewFile() to create a new file
Use mkdir() or mkdirs() to create directories
Use list() or listFiles() to get directory contents
Always handle IOException when creating files
Directories must be empty before deletion

What's Next?

Now that you understand file operations, the next lesson covers Reading Files, which shows you how to read content from files using FileReader and BufferedReader.

Previous ← Exception Best Practices

Next Reading Files →

The File Class

Key Points about File Class

Creating a File Object

Checking File Existence

Always Check Before Operations

Getting File Information

Creating Files

Exception Handling

Working with Directories

Directory Operations

mkdir() vs mkdirs()

Deleting Files and Directories

Common Mistakes

1. Assuming File object creates a file

2. Not checking file existence before operations

3. Not handling IOException

4. Trying to delete non-empty directory

Exercise: File Manager

Summary

What's Next?

Enjoying these tutorials?