Java NIO Path и Paths | W3Docs Learn Java

Path — это современная замена java.io.File. Он представляет путь файловой системы — упорядоченную последовательность компонентов имён, опционально начинающуюся с / или C:\ — и ничего больше. Он не читает файл. Он не проверяет существование файла. Он ничего не блокирует. Операции с байтами на диске находятся в Files (следующая глава). Path — это существительное; Files — это глагол.

Если вы использовали java.io.File, разница двоякая: Path неизменяем (каждая операция возвращает новый Path), и он чётко разделяет «строку пути» и «то, что находится на диске по этому пути». Большинство современных API — Files, FileChannel, перегрузки BufferedReader.lines() — принимают Path, а не File. Новый код использует Path.

Создание `Path`

Path p = Path.of("logs", "2025", "app.log");         // joins components with the platform separator
Path q = Path.of("/etc/hosts");                       // absolute Unix path
Path r = Paths.get("C:", "Users", "vaz");             // older factory — same behaviour
Path s = Path.of(URI.create("file:///etc/hosts"));    // from a URI

Path.of(...) — современная фабрика; Paths.get(...) — более старая и по-прежнему работает. Обе создают объект пути без обращения к файловой системе. Path.of("nope/nope/nope") выполняется успешно, даже если такой файл не существует.

Path.of объединяет аргументы переменной длины с помощью File.separator платформы — / на Unix, \ на Windows. Это делает строковый путь, который вы пишете, переносимым: Path.of("src", "main", "java") создаёт правильный путь на обеих платформах. Как только вы напишете Path.of("src/main/java") с жёстко заданными слэшами, вы случайно сделаете его специфичным для Unix.

Изучение пути

Методы доступа к компонентам для Path.of("/var/log/app/today.log"):

Метод	Возвращает	Пример
`getFileName()`	последний компонент как `Path`	`today.log`
`getParent()`	всё, кроме последнего	`/var/log/app`
`getRoot()`	корень, или `null` если относительный	`/`
`getNameCount()`	количество компонентов имени	`4`
`getName(int i)`	i-й компонент	`getName(0)` → `var`
`subpath(b, e)`	компоненты имён `[b, e)`	`subpath(1, 3)` → `log/app`
`isAbsolute()`	имеет ли путь корень	`true`
`toString()`	отформатированная строка платформы	`/var/log/app/today.log`

Эти методы чистые: они смотрят на внутренний список имён объекта пути и возвращают его срезы. Ни один из них не обращается к диску.

`resolve`, `resolveSibling` и ловушка абсолютного аргумента

resolve(other) означает «объединить this и other»:

Path base = Path.of("/var/log");
base.resolve("app.log");                              // /var/log/app.log
base.resolve("app/today.log");                        // /var/log/app/today.log

Ловушка: если other является абсолютным, resolve возвращает other без изменений:

base.resolve("/etc/hosts");                           // /etc/hosts  -- base is discarded
base.resolve(Path.of("/etc/hosts"));                  // same: /etc/hosts

Это задокументированное поведение, и каждый Java-программист попадается на него однажды. Если вы принимаете имя файла из пользовательского ввода и разрешаете его относительно настроенного базового каталога, злоумышленник, который передаёт "/etc/passwd", получает свой абсолютный путь — выходя за пределы базы. Всегда проверяйте или нормализуйте внешний ввод перед resolve.

resolveSibling(other) заменяет последний компонент:

Path p = Path.of("/var/log/today.log");
p.resolveSibling("yesterday.log");                    // /var/log/yesterday.log

Это getParent().resolve(other) со встроенной проверкой на null. Полезно для «записи вывода рядом со входом».

`relativize`: обратная операция

Зная базу и цель, base.relativize(target) возвращает относительный путь от base до target:

Path base = Path.of("/var/log");
Path target = Path.of("/var/log/app/today.log");
base.relativize(target);                              // app/today.log
target.relativize(base);                              // ../..

Контракт: base.resolve(base.relativize(target)) эквивалентен target (с учётом normalize). Именно так вы превращаете абсолютную цель в короткую относительную ссылку внутри базового каталога — полезно для строк лога, записей архива и URL.

Оба пути должны быть одного типа (оба абсолютные или оба относительные) и оба должны принадлежать одной FileSystem. Смешение вызывает IllegalArgumentException.

`normalize`: удаление `.` и `..`

Объекты Path допускают компоненты . и .. — Path.of("/var/log/../tmp") является допустимым Path. normalize() удаляет их синтаксически:

Path.of("/var/log/../tmp").normalize();               // /var/tmp
Path.of("./a/./b/../c").normalize();                  // a/c

Слово «синтаксически» важно: normalize работает на уровне строк. Он не спрашивает файловую систему, куда фактически указывает ... Если /var/log является символической ссылкой на /tmp/logs, то на диске /var/log/.. — это /tmp, а не /var. normalize() этого не знает — он просто удаляет ...

Когда вам нужен реальный путь на диске (с разрешёнными символическими ссылками и правильно интерпретированным ..), используйте toRealPath(), которая обращается к файловой системе:

Path real = Path.of("/var/log/../tmp").toRealPath(); // resolves symlinks, throws if the file doesn't exist

Для проверки равенства путей и сравнения строк используйте normalize(). Для «канонического имени файла на диске прямо сейчас» используйте toRealPath().

Равенство основано на строках

path1.equals(path2) сравнивает пути как строки (компонент за компонентом). Он не нормализует, не разрешает символические ссылки, не проверяет файловую систему:

Path.of("/var/log").equals(Path.of("/var/log/."));            // false  -- one has a trailing '.' component
Path.of("/var/log/.").equals(Path.of("/var/log/.").normalize()); // false -- normalize() dropped the '.'
Path.of("/var/log").equals(Path.of("/var/log").normalize());  // true   -- already normalized, no change
Path.of("/var/log").equals(Path.of("/var/log"));              // true

Чтобы сравнить два пути как «указывают ли они на один и тот же файл», нормализуйте оба и сравните, или вызовите Files.isSameFile(p1, p2) (обращается к файловой системе, единственная полностью корректная проверка). Для сортировки и ключей HashSet строковое равенство — это то, что даёт Path; это подходит для большинства случаев, но не означает «один и тот же файл на диске».

Совместимость с `File`

Path и File взаимно конвертируются:

File f = Path.of("/etc/hosts").toFile();
Path p = new File("/etc/hosts").toPath();

Это понадобится, когда старый API принимает File, а новый — Path (или наоборот). Не храните пути как File; конвертируйте на границе API и держите Path в своём коде.

Подробный пример: объединение, resolve, relativize, normalize

Программа ниже проходит через каждую операцию Path, представленную в этой главе, на конкретных путях. Вывод делает наглядным разницу между resolve и resolveSibling, между normalize и toRealPath, а также между абсолютным и относительным аргументом resolve.

java— editable, runs on the server

import java.io.IOException;
import java.nio.file.*;

public class PathDemo {
  public static void main(String[] args) throws IOException {
    // --- 1. Build paths and inspect components ---
    Path log = Path.of("/var", "log", "app", "today.log");    // platform separator joined
    System.out.println("path           = " + log);
    System.out.println("  fileName     = " + log.getFileName());
    System.out.println("  parent       = " + log.getParent());
    System.out.println("  root         = " + log.getRoot());
    System.out.println("  nameCount    = " + log.getNameCount());
    System.out.println("  name(0)      = " + log.getName(0));
    System.out.println("  subpath(1,3) = " + log.subpath(1, 3));
    System.out.println("  isAbsolute   = " + log.isAbsolute());

// --- 2. resolve: joining and the absolute-argument trap ---
    Path base = Path.of("/var/log");
    System.out.println("\nresolve:");
    System.out.println("  base.resolve('app.log')        = " + base.resolve("app.log"));
    System.out.println("  base.resolve('app/today.log')  = " + base.resolve("app/today.log"));
    System.out.println("  base.resolve('/etc/hosts')     = " + base.resolve("/etc/hosts")
        + "  <-- absolute argument REPLACES base");

// --- 3. resolveSibling: replace the last component ---
    Path file = Path.of("/var/log/today.log");
    System.out.println("\nresolveSibling:");
    System.out.println("  file.resolveSibling('yesterday.log') = " + file.resolveSibling("yesterday.log"));

// --- 4. relativize: the inverse of resolve ---
    Path target = Path.of("/var/log/app/today.log");
    System.out.println("\nrelativize:");
    System.out.println("  base.relativize(target)        = " + base.relativize(target));
    System.out.println("  target.relativize(base)        = " + target.relativize(base));
    System.out.println("  round trip resolve(relativize) = " + base.resolve(base.relativize(target)));

// --- 5. normalize: collapse . and .. SYNTACTICALLY ---
    Path messy = Path.of("/var/log/../tmp/./a/b/../c");
    System.out.println("\nnormalize:");
    System.out.println("  before = " + messy);
    System.out.println("  after  = " + messy.normalize());

// --- 6. normalize vs toRealPath on an actual file we just created ---
    Path tmp = Files.createTempDirectory("path-demo-");
    tmp.toFile().deleteOnExit();
    Path actual = Files.createFile(tmp.resolve("hello.txt"));
    actual.toFile().deleteOnExit();
    Path sub = Files.createDirectory(tmp.resolve("sub")); // must exist: toRealPath checks every component
    sub.toFile().deleteOnExit();

Path withDotDot = tmp.resolve("sub/../hello.txt");   // a path string pointing at hello.txt via sub
    System.out.println("\nnormalize() is string-only; toRealPath() touches disk:");
    System.out.println("  withDotDot               = " + withDotDot);
    System.out.println("  withDotDot.normalize()   = " + withDotDot.normalize());
    System.out.println("  withDotDot.toRealPath()  = " + withDotDot.toRealPath());

// --- 7. equals is string-based; Files.isSameFile touches the filesystem ---
    Path a = Path.of("/var/log");
    Path b = Path.of("/var", "log");
    Path c = Path.of("/var/log/.");
    System.out.println("\nequality:");
    System.out.println("  a.equals(b)  (same string)        = " + a.equals(b));
    System.out.println("  a.equals(c)  ('/var/log' vs '/var/log/.') = " + a.equals(c));
  }
}

Что нужно понять из выполнения:

Path.of(\"/var\", \"log\", \"app\", \"today.log\") создал /var/log/app/today.log на Unix и \\var\\log\\app\\today.log на Windows. Позволить фабрике с переменными аргументами объединять компоненты — это переносимый способ; жёстко заданные / или \ во входной строке — непереносимый. Используйте фабрику.
Строка resolve(\"/etc/hosts\") отбросила base и вернула /etc/hosts. Это поведение с абсолютным аргументом — наиболее частый источник вопроса «но я же указал базовый каталог, почему запись идёт в /etc/hosts?». Всегда проверяйте имена файлов, поступающие от пользователей, перед resolve. Защитная форма: base.resolve(other).normalize().startsWith(base) — и даже у неё есть тонкие проблемы при наличии символических ссылок.
base.relativize(target) вернул app/today.log. Конкатенация обратно с base.resolve(...) дала исходную цель — тождество кругового обхода. Используйте это, когда пишете строку лога или запись архива, которой нужна короткая относительная форма длинного абсолютного пути.
Path.of(\"/var/log/../tmp/./a/b/../c\").normalize() дал /var/tmp/a/c. Преобразование было чисто строковым: каждый . удалён, каждая пара name/.. удалена. Файловая система не запрашивалась. toRealPath в следующей строке запросил файловую систему — поэтому результат оказался каноническим именем реального файла на диске, с разрешёнными символическими ссылками. (На macOS вы увидите, что путь к временному каталогу начинается с /private/var/folders/..., а не /var/folders/...: toRealPath следовал реальной символической ссылке /var → /private/var, чего normalize никогда не сделает.) Поскольку toRealPath проверяет каждый компонент, промежуточный каталог sub в примере должен реально существовать — именно поэтому программа создаёт его заранее.
Две проверки equals: Path.of(\"/var/log\") и Path.of(\"/var\", \"log\") были равны (одинаковая внутренняя последовательность имён, одинаковая строка); Path.of(\"/var/log\") и Path.of(\"/var/log/.\") — нет (у одного есть конечный компонент ., у другого нет). Вывод: equals — это строковое сравнение. Для проверки «указывают ли эти два пути на один и тот же файл?» используйте Files.isSameFile(a, b) из следующей главы — это единственная проверка, которая обращается к файловой системе.

Что дальше

Path — это существительное. Следующая глава, Класс Java Files, охватывает глагол — Files, огромный утилитарный класс с однострочными операциями над файловой системой: readString, writeString, createDirectories, copy, move, delete, walk и остальные.

Практика

`base` равен `Path.of('/srv/uploads')`, а `userInput` — строка `'/etc/passwd'` (значение, контролируемое злоумышленником). Ваш код выполняет `base.resolve(userInput)` для вычисления целевого пути. Каков результирующий путь и какой урок по безопасности из этого следует?

`/etc/passwd` — `resolve` возвращает абсолютный аргумент без изменений, отбрасывая базу. Урок: никогда не применяйте `resolve` к непроверенному абсолютному пути из пользовательского ввода; отклоняйте абсолютные пути (или нормализуйте и перепроверяйте `startsWith(base)`) на границе`/srv/uploads/etc/passwd` — `resolve` всегда добавляет базу в начало независимо от аргумента`IllegalArgumentException` — `resolve` отклоняет абсолютные аргументы`/srv/uploads` — `resolve` отбрасывает абсолютный аргумент и возвращается к базе

Создание Path