How to Check If a File Exists in Java

By the end of this page, you will understand how to check whether a file exists in Java using both the older File API and the modern Path/Files API. You will also learn when existence checks are useful, why they can sometimes be misleading, and how real Java programs usually combine existence checks with proper exception handling.

In Java, checking whether a file exists means asking the operating system whether a path currently points to something on disk.

The two main ways to do this are:

• File.exists() from java.io.File
• Files.exists() from java.nio.file.Files

For modern Java code, Path and Files are usually preferred because they are newer, more flexible, and work better with other file-system operations.

A file existence check matters because programs often need to:

• read configuration files
• load user-uploaded content
• verify input files before processing
• avoid confusing error messages

However, there is an important detail: a file can exist when you check, and disappear before you open it. This means an existence check is useful for validation or user-friendly messaging, but it should not replace proper error handling.

So the safe idea is:

1. Check if the file exists when that helps your logic.
2. Still handle exceptions when actually opening or reading the file.

Think of a file path like a street address.

• exists() is like asking, "Is there currently a building at this address?"
• opening the file is like trying to walk into the building

Even if someone tells you the building exists, it might be locked, removed a moment later, or you may not have permission to enter.

So an existence check gives you useful information, but it is not a guarantee that the next operation will succeed.

The most common options are shown below.

Using File.exists()

import java.io.File;

public class Main {
    public static void main(String[] args) {
        File file = new File("data.txt");

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

This works and is simple, especially in older Java code.

Using Files.exists() with Path

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class Main {
    public static void main {
           Paths.get();

         (Files.exists(path)) {
            System.out.println();
        }  {
            System.out.println();
        }
    }
}

Consider this example:

import java.nio.file.Files;
import java.nio.file.Path;
import java.nio.file.Paths;

public class Main {
    public static void main(String[] args) {
        Path path = Paths.get("report.txt");

        if (Files.exists(path)) {
            System.out.println("Found it");
        } else {
            System.out.println("Missing");
        }
    }
}

Here is what happens step by step:

1. Paths.get("report.txt") creates a Path object.

   • This does not open the file.
   • It just represents the path.

2. Files.exists(path) asks the file system whether something exists at that path.

   • If yes, it returns true.
   • If no, it returns false.

3. The statement checks the returned boolean.

Checking whether a file exists is common in many types of Java programs.

Configuration loading

A desktop app or server may look for a config file like app.properties.

Path configPath = Paths.get("app.properties");
if (Files.exists(configPath)) {
    // load custom config
} else {
    // use default settings
}

Importing data files

A script may process customers.csv only if the file is available.

Handling user input

If a user enters a file path, the program can validate it before starting a long operation.

Log or report generation

A tool may check whether yesterday's report already exists before generating a new one.

API or batch jobs

Scheduled jobs often verify required input files before reading and parsing them.

In real projects, developers usually do more than just call exists().

Common patterns

Guard clause

Path path = Paths.get(fileName);
if (!Files.exists(path) || !Files.isRegularFile(path)) {
    throw new IllegalArgumentException("Input file is missing: " + fileName);
}

This stops invalid input early.

Validation before processing

if (Files.notExists(path)) {
    return;
}

Useful when a missing file is acceptable.

Existence check plus exception handling

if (Files.exists(path)) {
    try {
        String content = Files.readString(path);
        System.out.println(content);
    } catch (IOException e) {
        // handle unreadable file, permission issue, file removed, etc.
    }
}

This is common because existence alone does not guarantee successful reading.

Checking file type

1. Assuming exists() means the file can be read

Broken idea:

if (Files.exists(path)) {
    String content = Files.readString(path); // may still fail
}

Why it is a problem:

• the file may not be readable
• it may be deleted after the check
• it may be a directory

Better:

if (Files.exists(path) && Files.isRegularFile(path) && Files.isReadable(path)) {
    try {
        String content = Files.readString(path);
    } catch (IOException e) {
        System.out.println("Read failed: " + e.getMessage());
    }
}

2. Using exists() when you really need isRegularFile()

Broken code:

if (Files.exists(path)) {
    System.out.println("Ready to read file");
}

This may be a directory, not a normal file.

Better:

// Older API
File file = new File("data.txt");
boolean exists = file.exists();

// Modern API
Path path = Paths.get("data.txt");
boolean exists2 = Files.exists(path);

// Better when reading a normal file
boolean okToRead = Files.exists(path)
        && Files.isRegularFile(path)
        && Files.isReadable(path);

Quick rules

• Use Path + Files in new Java code.
• Files.exists(path) checks whether something exists.
• Files.isRegularFile(path) checks whether it is a normal file.
• Files.isReadable(path) checks readability.
• Still handle IOException when reading.
• Relative paths depend on the current working directory.

Useful methods

How do I check if a file exists in Java?

Use either new File("name").exists() or the modern API Files.exists(Paths.get("name")).

What is the best way to check file existence in modern Java?

Use Path and Files.exists(path). This is the preferred style in newer Java code.

Should I use File.exists() or Files.exists()?

For new code, prefer Files.exists() with Path. File.exists() is still valid, especially in older codebases.

Does exists() mean the file can be read?

No. The path may exist but still be unreadable, be a directory, or disappear before reading.

How do I check that the path is a real file and not a directory?

Use Files.isRegularFile(path).

Can I avoid exception handling if I already checked that the file exists?

No. You should still handle IOException when opening or reading the file.

Why does my program say the file does not exist when it does?

• Path — the modern way to represent file-system paths in Java.
• Files API — provides utility methods for checking, reading, writing, and managing files.
• IOException — important because file operations can still fail after existence checks.
• Relative vs absolute paths — explains why a file may not be found where you expect.
• isRegularFile and isDirectory — useful for distinguishing files from folders.
• File permissions — a file may exist but still not be readable.
• Try-catch — needed when performing actual file I/O.
• Reading files in Java — the next step after confirming a file is present.