Java Path

last modified August 22, 2026

In this article we learn how to work with file and directory paths in Java. We create paths, inspect their components, combine paths, normalize them, and use them with the Files class.

The Path interface from the java.nio.file package represents a path in a file system. A path can identify an existing file or directory, or it can describe a location that does not exist yet.

Path replaces much of the path-handling work that was traditionally done with java.io.File. A Path describes a location; the Files class performs operations such as reading, writing, copying, and deleting at that location.

The examples use Java 25's compact source-file syntax. With an earlier Java version, place the code inside a class and use a conventional public static void main(String[] args) method.

Creating a Path

The Path.of method creates a Path from one or more strings. The path is interpreted using the conventions of the operating system on which the program runs.

import java.nio.file.Path;

void main() {

    var file = Path.of("reports", "2026", "summary.txt");
    var directory = Path.of("reports", "2026");

    System.out.println(file);
    System.out.println(directory);
}

The path is built from separate components instead of manually joining strings. Java uses the correct separator for the current operating system when it prints the path.

The Path.of factory method was added in Java 11. In earlier Java versions, use Paths.get from java.nio.file.Paths for the same purpose.

Relative and absolute paths

A relative path is interpreted from the program's current working directory. An absolute path identifies a location from the file system root. The isAbsolute method tells us which kind of path we have, and toAbsolutePath converts a relative path to an absolute one.

import java.nio.file.Path;

void main() {

    var relativePath = Path.of("data", "report.txt");
    var absolutePath = relativePath.toAbsolutePath();

    System.out.println(relativePath.isAbsolute());
    System.out.println(absolutePath.isAbsolute());
    System.out.println(absolutePath);
}

The first path depends on the process working directory. The second path contains the absolute location obtained from that working directory.

toAbsolutePath does not check whether the path exists. It only resolves a relative path against the current working directory.

Path components

A path consists of components that can be inspected individually. The getFileName method returns the final component, while getParent returns the path without that component.

import java.nio.file.Path;

void main() {

    var path = Path.of("documents", "notes", "today.txt");

    System.out.println(path.getFileName());
    System.out.println(path.getParent());
    System.out.println(path.getNameCount());
    System.out.println(path.getName(0));
}

The getFileName call prints today.txt, and getParent returns documents/notes using the platform's separator. The name count does not include a root component.

The getRoot method returns the root component of an absolute path. It returns null for a relative path, so check the result before using it.

Combining paths with resolve

The resolve method appends one path to another. It is useful when a program has a base directory and needs to access a file below that directory.

import java.nio.file.Path;

void main() {

    var reports = Path.of("reports");
    var summary = reports.resolve("2026").resolve("summary.txt");

    System.out.println(summary);
}

The result is reports/2026/summary.txt on systems that use a forward slash as the separator. The original reports path is not modified because Path objects are immutable.

If the argument passed to resolve is absolute, it replaces the original path. This behavior is useful to know when path components come from external input.

Resolving a sibling

The resolveSibling method replaces the final component of a path. It is convenient when a file needs a related name in the same directory.

var source = Path.of("reports", "summary.txt");
var backup = source.resolveSibling("summary.bak");

The value of backup is reports/summary.bak. The parent directory remains unchanged while the final file name is replaced.

Normalizing a path

The normalize method removes redundant path components. It eliminates . components and resolves .. components when the result can be determined from the path itself.

import java.nio.file.Path;

void main() {

    var path = Path.of("reports", "2026", "..", "archive", ".", "summary.txt");

    System.out.println(path);
    System.out.println(path.normalize());
}

The original path contains redundant components. Its normalized form is reports/archive/summary.txt. Normalization is a lexical operation; it does not access the file system and does not verify that the result exists.

Relativizing paths

The relativize method computes the path needed to travel from one path to another. Both paths should be absolute or both should be relative, and they must use compatible roots.

import java.nio.file.Path;

void main() {

    var source = Path.of("project", "src");
    var target = Path.of("project", "test");
    var relativePath = source.relativize(target);

    System.out.println(relativePath);
}

The result is ../test. Starting in project/src, we move up to project and then down into test.

Checking a Path

The Path object only describes a location. The Files class checks the current state of that location.

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;

void main() throws IOException {

    var path = Path.of("notes.txt");

    System.out.println(Files.exists(path));
    System.out.println(Files.isRegularFile(path));
    System.out.println(Files.isDirectory(path));

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

Files.exists checks whether the path exists, isRegularFile checks for an ordinary file, and isDirectory checks for a directory. The size is read only after the path has been confirmed to exist.

File-system state can change immediately after a check. For operations that matter, handle the exception from the operation itself instead of relying only on a preliminary existence check.

Reading and writing with Path

Many methods in Files accept a Path. The following example writes text to a file and reads it back.

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;

void main() throws IOException {

    var path = Path.of("notes.txt");

    Files.writeString(path, "A note written with Path and Files.");
    var contents = Files.readString(path);

    System.out.println(contents);
}

If notes.txt does not exist, writeString creates it. If it already exists, the default behavior replaces its contents. Use the overloads that accept OpenOption values when a different behavior is needed, such as appending instead of replacing.

Comparing paths

The equals method compares the path objects according to the path syntax used by the file system. It does not generally prove that two paths refer to the same existing file.

Use Files.isSameFile when the question concerns two existing file system objects. The method follows links as needed and can throw an IOException.

import java.io.IOException;
import java.nio.file.Files;
import java.nio.file.Path;

void main() throws IOException {

    var first = Path.of("notes.txt");
    var second = Path.of(".", "notes.txt");

    System.out.println(first.equals(second));

    if (Files.exists(first) && Files.exists(second)) {
        System.out.println(Files.isSameFile(first, second));
    }
}

The two paths may have different textual forms even though they identify the same location after normalization. Files.isSameFile performs the file-system comparison when both paths exist.

Converting Path and File

The older java.io.File API and the newer java.nio.file.Path API can be converted into each other. This is useful when code still depends on a library that accepts File.

import java.io.File;
import java.nio.file.Path;

void main() {

    var path = Path.of("reports", "summary.txt");
    var file = path.toFile();
    var samePath = file.toPath();

    System.out.println(file);
    System.out.println(samePath);
}

The conversions do not create, read, or modify the referenced file. They only create objects representing the same path in the two APIs.

Path and SimpleFileVisitor

The SimpleFileVisitor callbacks receive Path objects. Together with Files.walkFileTree, they provide a structured way to process files and directories recursively.

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;

void main() throws IOException {

    var root = Path.of("reports");

    Files.walkFileTree(root, new SimpleFileVisitor<Path>() {
        @Override
        public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
            System.out.println(file.getFileName());
            return FileVisitResult.CONTINUE;
        }
    });
}

The visitor receives each file as a Path, so path operations such as getFileName, resolve, and toAbsolutePath can be used directly during the traversal.

Path best practices

• Use Path.of or resolve instead of joining path strings manually.
• Use Files for file-system operations; a Path alone does not access the file system.
• Prefer relative paths only when the working directory is controlled and well understood.
• Do not treat normalize as a security check; validate untrusted paths against the intended root.
• Handle IOException and related exceptions around the operation that accesses the file system.

Source

Java Path - language reference

Java Files - language reference

Java SimpleFileVisitor - language reference

Author

My name is Jan Bodnar, and I am a passionate programmer with extensive programming experience. I have been writing programming articles since 2007. To date, I have authored over 1,400 articles and 8 e-books. I possess more than ten years of experience in teaching programming.

List all Java tutorials.