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(String[] args) {
        Path path = Paths.get("data.txt");

        if (Files.exists(path)) {
            System.out.println("Path exists");
        } else {
            System.out.println("Path does not exist");
        }
    }
}

This is the modern approach.

Check that it is specifically a regular file

Sometimes a path exists, but it is a directory instead of a file.

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("data.txt");

        if (Files.exists(path) && Files.isRegularFile(path)) {
            System.out.println("A real file exists here");
        } else {
            System.out.println("Missing file, or the path is not a regular file");
        }
    }
}

This is often better than checking existence alone.

Reading after checking

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

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

        if (Files.exists(path) && Files.isRegularFile(path)) {
            try {
                List<String> lines = Files.readAllLines(path);
                System.out.println(lines);
            } catch (IOException e) {
                System.out.println("Could not read file: " + e.getMessage());
            }
        } else {
            System.out.println("File not found");
        }
    }
}

Even after checking, the code still catches IOException. That is the correct pattern.

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 if statement checks the returned boolean.

   • If true, the program prints Found it.
   • If false, the program prints Missing.

Example outcomes

If report.txt is present:

Found it

If report.txt is not present:

Missing

Important note

If the path exists but points to a directory, Files.exists(path) still returns true. That is why Files.isRegularFile(path) is often a better follow-up check when you plan to read a normal file.

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

if (Files.exists(path) && Files.isRegularFile(path) && Files.isReadable(path)) {
    // safe candidate for reading
}

This is more realistic than checking existence only.

Why real code still handles errors

Between checking and reading, several things can change:

• the file can be deleted
• permissions can change
• the path can point to a directory
• the file can be locked or unreadable

That is why production code uses both validation and exception handling.

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:

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

3. Forgetting relative vs absolute paths

Broken expectation:

Path path = Paths.get("data.txt");

This checks the file relative to the program's current working directory, which may not be where you expect.

Better debugging approach:

System.out.println(path.toAbsolutePath());

4. Catching exceptions only to detect existence

Trying to open a file just to see whether it exists is usually less clear than an API designed for checking.

Use Files.exists(path) when the logic needs a boolean check.

5. Ignoring Files.notExists() semantics

Files.notExists(path) is not exactly the same as !Files.exists(path) in every low-level situation. If the system cannot determine the status, both can return false.

That means these methods reflect file-system knowledge, not perfect certainty.

File vs Path

exists() vs isRegularFile()

If your goal is to read a normal file, isRegularFile() is often more precise than exists() alone.

// 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

Files.exists(path)
Files.notExists(path)
Files.isRegularFile(path)
Files.isDirectory(path)
Files.isReadable(path)
path.toAbsolutePath()

Edge cases

• A path may exist but be a directory.
• A file may exist but not be readable.
• A file may disappear after the check.
• Existence checks help with logic, not guarantees.

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?

You may be using a relative path. Print path.toAbsolutePath() to see where Java is looking.

Is Files.notExists(path) the same as !Files.exists(path)?

Not always. In some situations, the file system may not be able to determine the status exactly.

• 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.