JavaRush /Курсы /Java Syntax Pro /Работа с файлами в Java

Работа с файлами в Java

Java Syntax Pro
15 уровень , 5 лекция
Открыта

1. Класс Files

Класс Files

Чтобы работать с файлами, есть шикарный утилитный класс — java.nio.file.Files. У него есть методы просто на все случаи жизни. Все методы этого класса статические и работают с объектами типа Path. Методов очень много, поэтому мы рассмотрим только основные:

Метод Описание
Path createFile(Path path)
Создает новый файл с путем path
Path createDirectory(Path path)
Создает новую директорию
Path createDirectories(Path path)
Создает несколько директорий
Path createTempFile(prefix, suffix)
Создает временный файл
Path createTempDirectory(prefix)
Создает временную директорию
void delete(Path path)
Удаляет файл или директорию, если она пуста
Path copy(Path src, Path dest)
Копирует файл
Path move(Path src, Path dest)
Перемещает файл
boolean isDirectory(Path path)
Проверяет, что путь — это директория, а не файл
boolean isRegularFile(Path path)
Проверяет, что путь — это файл, а не директория
boolean exists(Path path)
Проверяет, что объект по заданному пути существует
long size(Path path)
Возвращает размер файла
byte[] readAllBytes(Path path)
Возвращает все содержимое файла в виде массива байт
String readString(Path path)
Возвращает все содержимое файла в виде строки
List<String> readAllLines(Path path)
Возвращает все содержимое файла в виде списка строк
Path write(Path path, byte[])
Записывает в файл массив байт
Path writeString(Path path, String str)
Записывает в файл строку
DirectoryStream<Path> newDirectoryStream(Path dir)
Возвращает коллекцию файлов (и поддиректорий) из заданной директории

2. Создание файлов и директорий

Файлы и директории создавать очень просто. Убедимся на примерах:

Код Примечание
Files.createFile(Path.of("c:\\readme.txt"));
Создает файл
Files.createDirectory(Path.of("c:\\test"));
Создает директорию
Files.createDirectories(Path.of("c:\\test\\1\\2\\3"));
Создает директорию и все нужные поддиректории, если их не существует.

3. Копирование, перемещение и удаление

Копировать, перемещать и удалять файлы так же легко. На директории это тоже распространяется, но они должны быть пустые.

Код Примечание
Path path1 = Path.of("c:\\readme.txt");
Path path2 = Path.of("c:\\readme-copy.txt");
Files.copy(path1, path2);
Копирует файл
Path path1 = Path.of("c:\\readme.txt");
Path path2 = Path.of("d:\\readme-new.txt");
Files.move(path1, path2);
Перемещает и переименовывает файл
Path path = Path.of("d:\\readme-new.txt");
Files.delete(path);
Удаляет файл

4. Проверка типа файла и факта существования

Когда у вас есть какой-то путь, полученный извне, вы бы хотели знать, это файл или директория. Ну и вообще: существует такой файл/директория или нет?

Для этого тоже есть специальные методы. Так же можно легко узнать длину файла:

Код Примечание
Files.isRegularFile(Path.of("c:\\readme.txt"));
true
Files.isDirectory(Path.of("c:\\test"));
true
 Files.exists(Path.of("c:\\test\\1\\2\\3"));
false
Files.size(Path.of("c:\\readme.txt"));
10112

5. Работа с содержимым файла

И наконец, есть целая серия методов, которые позволяют легко прочитать или записать содержимое файла. Пример:

Код Описание
Path path = Path.of("c:\\readme.txt");
List<String> list = Files.readAllLines(path);

for (String str : list)
   System.out.println(str);

Читаем содержимое файла в виде списка строк.

Выводим строки на экран


6. Получение содержимого директории

Остался еще самый интересный метод — получение файлов и поддиректорий в заданной директории.

Для этого есть специальный метод — newDirectoryStream(), который возвращает специальный объект типа DirectoryStream<Path>. У него есть итератор(!), и с помощью этого итератора можно получить все файлы и поддиректории заданной директории.

Выглядит проще, чем кажется:

Код Описание
Path path = Path.of("c:\\windows");

try (DirectoryStream<Path> files = Files.newDirectoryStream(path)) {
   for (Path path : files)
      System.out.println(path);
}


Получаем объект со списком файлов
Цикл по списку файлов

Объект DirectoryStream<Path> обладает двумя свойствами. Во-первых, у него есть итератор, который возвращает пути к файлам, и мы можем этот объект использовать внутри цикла for-each.

А во-вторых, этот объект является потоком данных, и его нужно закрывать с помощью метода close(), ну или использовать внутри try-with-resources.



7. Метод Files.newInputStream

Начиная с Java 5 классы FileInputStream и FileOutputStream стали считаться устаревшими. Одним из их минусов было то, что при создании объекта этих классов сразу происходит создание файлов на диске. И потенциально выбрасываются все ошибки, связанные с созданием файлов.

Впоследствии это было признано не самым хорошим решением. Поэтому для создания объектов-файлов рекомендуется использовать методы утилитного класса – java.nio.Files.

Вот сравнение старого подхода к созданию файлов и нового:

Было
String src = "c:\\projects\\log.txt";
InputStream input = new FileInputStream( src );
Стало
String src = "c:\\projects\\log.txt";
InputStream input = Files.newInputStream( Path.of( src ) );

Аналогично замена и для FileOutputStream:

Было
String src = "c:\\projects\\log.txt";
OutputStream  output = new FileOutputStream( src );
Стало
String src = "c:\\projects\\log.txt";
OutputStream  output = Files.newOutputStream( Path.of( src ) );

Комментарии (389)
ЧТОБЫ ПОСМОТРЕТЬ ВСЕ КОММЕНТАРИИ ИЛИ ОСТАВИТЬ КОММЕНТАРИЙ,
ПЕРЕЙДИТЕ В ПОЛНУЮ ВЕРСИЮ
Grigoryvvv Уровень 19 Expert
25 апреля 2026
26.04.2026 / 16 уровень 1. ❌ Методы Files не использующие потоки (работают только с файловой системой) createFile createDirectory createDirectories createTempFile createTempDirectory delete copy move isDirectory isRegularFile exists size newDirectoryStream 👉 Эти методы управляют файлами, но не читают их содержимое. Не создают потоки InputStream / Reader. Работают через NIO (Path + файловая система). 2. ✅ Методы Files ИСПОЛЬЗУЮЩИЕ каналы и потоки (работа с содержимым) Рассмотрим методы Files с реальной внутренней логикой под капотом. • Уровень абстракции 🟡⚪⚪ Низкий Метод Files (java.nio) Возвращает Реализация внутри обычно Files.newInputStream(Path) InputStream FileChannelImpl → ChannelInputStream Files.newOutputStream(Path) OutputStream FileChannelImpl → ChannelOutputStream До появления Java 7 для чтения и записи байтов в файл использовались исключительно объекты-потоки классов FileInputStream и FileOutputStream из пакета java.io. В дальнейшем к примеру уже объект-поток класса FileInputStream можно обернуть в объект-поток класса InputStreamReader а после в объект-поток класса BufferedReader. Проблемы использования классов FileInputStream и FileOutputStream из пакета java.io: - Жесткая привязка к диску (Отсутствие гибкости). Класс FileOutputStream и FileOutputStream умеет работать только с физическими файлами на жестком диске компьютера. Если приложению нужно записать данные в ZIP-архив, в облачное хранилище или в виртуальную файловую систему в оперативной памяти, FileOutputStream использовать физически невозможно. - Намертво зависающие потоки (Многопоточность). Если один из потоков вашей программы начал запись через FileOutputStream и завис (например, из-за медленной флэшки или зависшего сетевого диска), его нельзя прервать. Поток останется заблокированным и будет впустую тратить память компьютера.
Grigoryvvv Уровень 19 Expert
25 апреля 2026
Современное java.nio использует канальную архитектуру. Вначале создается объект-канал. API Path + Files позволяет напрямую работать с этим объектом-каналом или же обернуть его в объекты-потоки, в том числе из старого пакета java.io. В некоторых операциях Files может даже использовать нативные вызовы операционной системы, минуя явное создание Java-объектов Каналы и Потоки, опираясь на системные I/O вызовы самой ОС. Плюсы использования нового API Path + Files из пакета java.nio: - Независимость от типа файловой системы (Гибкость). API Path представляет путь как абстракцию и работает не только с обычными файлами на диске, но и с ZIP-файловыми системами, сетевыми ресурсами и другими реализациями FileSystem. Это позволяет не привязываться к конкретному типу хранилища. - Поддержка различных моделей I/O. В зависимости от задачи Files может использовать канальную модель (FileChannel), потоковые API (InputStream / OutputStream) поверх канальной, либо внутренние механизмы файловой системы ОС. - Лучшая поддержка многопоточности и прерывания операций. Многие классы NIO лучше приспособлены для многопоточной работы. Некоторые блокирующие операции могут быть прерваны закрытием канала и прерыванием потока, что позволяет избежать ситуаций с «намертво зависшими» потоками. После появления NIO возникла необходимость совместить новую канальную модель ввода-вывода с существующей экосистемой классов java.io, которая уже содержала множество полезных обёрток (например, BufferedInputStream, BufferedOutputStream, InputStreamReader, OutputStreamWriter). Были добавлены методы-адаптеры Files.newInputStream() и Files.newOutputStream() для совместимости с классами java.io в API Files. Они возвращают обычные объекты InputStream и OutputStream, позволяя использовать поверх них существующие обёртки (BufferedInputStream, BufferedOutputStream, InputStreamReader, OutputStreamWriter и др.).
Grigoryvvv Уровень 19 Expert
26 апреля 2026
Рассмотрим метод Files.newOutputStream() подробнее: При вызове метода Files.newOutputStream() под капотом создается сначала объект-канал, затем создается объект-поток обертка который оборачивает канал. Пошаговый алгоритм работы JVM: Создание объекта-канал: - Поиск провайдера: Метод Files.newOutputStream(path) определяет, с какой файловой системой мы работаем и определяет тип источника (например, локальный файл или zip-архив) через класс FileSystemProvider. - Открытие канала: Провайдер открывает файл на диске и создает современный скоростной канал — в интерфейсе SeekableByteChannel выбирается абстрактный класс FileChannel (в случае обычной файловой системы), в нем класс FileChannelImpl. Создается объект-канал класса FileChannelImpl с ссылкой типа FileChannel. Создание объекта-поток обертка: - Создание объекта: Прямо внутри метода Files создается объект-поток обертка класса ChannelOutputStream. Далее объект-поток обертка оборачивает наш объект-канал new ChannelOutputStream(fileChannel). Созданному объекту класса ChannelOutputStream присваивается ссылка типа OutputStream в выражении OutputStream out = Files.newOutputStream(); Класс ChannelOutputStream в отличии от старого класса FileOutputStream создан чтобы выступать в роли обертки каналов. Он так же как и старый класс FileOutputStream наследуется от абстрактного родительского класса OutputStream и так-же содержит аналогичные методы write() и close() и т.д. sun.nio.ch.ChannelOutputStream это закрытый не доступным внутренний класс, Пакеты, начинающиеся с sun.* — это внутренняя «кухня» разработчиков самой Java. Мы не можем создать объект new ChannelOutputStream. Нам это и не нужно. Так же не нужно запоминать всю цепочку под капотом Files.newOutputStream(path), достаточно знать что он возвращает тип ссылки OutputStream.
Grigoryvvv Уровень 19 Expert
31 мая 2026
При вызове метода Files.newOutputStream(path) нам возвращается тип ссылки OutputStream для вновь созданного объекта. Благодаря этому Files.newOutputStream(path) позволяет передавать созданный с помощью современного NIO поток в старые библиотеки IO. Старые потоки пакета java.io используемые совместно с новым пакетом java.nio: Классы пакета java.io InputStreamReader, OutputStreamWriter, BufferedReader и BufferedWriter могут работать как со старыми потоками FileInputStream и FileOutputStream, так и с современным потоком, возвращаемым Files.newInputStream() и Files.newOutputStream() благодаря полиморфизму InputStream и OutputStream. Теперь в качестве источника байт в них можно использовать не только FileInputStream и FileOutputStream, но и канальный ChannelInputStream и ChannelOutputStream. Именно поэтому переход от старого IO к NIO оказался таким безболезненным.

Пример на реальном коде:

Старый способ
byte[] data = {65, 66, 67};
OutputStream fileOut = new FileOutputStream("file.txt");
fileOut.write(data);

если с буферизацией
byte[] data = {65, 66, 67};
OutputStream fileOut = new FileOutputStream("file.txt");
BufferedOutputStream bufferedOut = new BufferedOutputStream(fileOut);
bufferedOut.write(data);



Современный способ
byte[] data = {65, 66, 67};
OutputStream channelOut = Files.newOutputStream(Path.of("file.txt"));
channelOut.write(data);

если с буферизацией
byte[] data = {65, 66, 67};
OutputStream channelOut = Files.newOutputStream(Path.of("file.txt"));
BufferedOutputStream bufferedOut = new BufferedOutputStream(channelOut);
bufferedOut.write(data);
Grigoryvvv Уровень 19 Expert
4 июня 2026
• Уровень абстракции 🟡🟡⚪ Средний Метод Files (java.nio) Возвращает Files.newBufferedReader(path, charset) BufferedReader Реализация внутри new BufferedReader( new InputStreamReader( Files.newInputStream(path), charset.newDecoder())); Метод Files (java.nio) Возвращает Files.newBufferedWriter(path, charset) BufferedWriter Реализация внутри new BufferedWriter( new OutputStreamWriter( Files.newOutputStream(path), charset.newEncoder())); Методы Files.newBufferedReader(path, charset) и Files.newBufferedWriter(path, charset) под капотом используют канальный байтовый поток пакета java.nio, далее используя классы из пакета java.io оборачивают байтовые потоки и преобразуют байты в символы и наоборот, оборачивают символьные потоки для буферизации и добавления методов работы со строками (readLine(), newLine()) Обратите внимание, у метода есть не обязательный аргумент charset (кодировка). Если не указать аргумент charset, то будет использована кодировка по умолчанию. То есть в любом случае внутри реализации будут вызываться дефолтные методы charset.newDecoder() и charset.newEncoder() для декодирования и кодирования байтов в символы и наоборот Начиная с Java 18, эти методы по умолчанию используют кодировку UTF-8. До Java 18 использовалась дефолтная кодировка операционной системы (что часто приводило к багам с «кракозябрами» при переносе кода с Linux на Windows).

Пример использования метода:

try (BufferedReader reader = Files.newBufferedReader(Path.of("file.txt"))) 
// по умолчанию UTF-8
{
    String line = reader.readLine();
    System.out.println(line); 
}
Grigoryvvv Уровень 19 Expert
11 июня 2026
• Уровень абстракции 🟡🟡🟡 Высокий Во всех высокоуровневых методах под капотом обязательно используется конструктор try-with-resources (или блок try-finally). Поскольку эти методы сами открывают каналы или потоки (FileChannel, BufferedReader, OutputStream), они обязаны сами их и закрывать, чтобы не было утечки ресурсов. Фишка высокого уровня абстракции — разработчику не нужно писать .close() вручную. ЧТЕНИЕ Метод Files (java.nio) Возвращает Files.readAllBytes(Path) byte[] Реализация внутри try-with-resources │ ⮟ FileChannelImpl (тип ссылки: SeekableByteChannel) │ ├─ FileChannelImpl.size() → запрос в ОС │ ⮟ new byte[size] ← создание массива нужного размера │ ⮟ ├─ FileChannelImpl.read(byte[]) → заполнение массива (через ОС) │ ⮟ return byte[] │ ⮟ auto close() Сначала создаётся канал доступа к файлу (FileChannelImpl), который используется через интерфейс SeekableByteChannel. Через него выполняется запрос размера файла в операционной системе (FileChannelImpl.size()), чтобы определить объём данных. Далее на стороне JVM выделяется массив byte[] нужного размера. После этого данные читаются из файла через канал методом FileChannelImpl.read(byte[]), который заполняет созданный массив, используя системные вызовы операционной системы. Происходит работа напрямую с каналом без всяких оберток. В конце метод Files.readAllBytes() возвращает заполненный массив byte[], после чего ресурс автоматически закрывается благодаря конструкции try-with-resources. Коротко про ограничения метода Files.readAllBytes(Path): 📏 Ограничение размера: файл должен помещаться в byte[] → максимум Integer.MAX_VALUE (~2 GB) 🧠 Память: сразу выделяется массив целиком → не подходит для больших файлов (риск OutOfMemoryError) ⏳ Читает весь файл целиком, нельзя обрабатывать “по частям”
Grigoryvvv Уровень 19 Expert
12 июня 2026
Метод Files (java.nio) Возвращает Files.readString(Path) String Реализация внутри try-with-resources │ ⮟ FileChannelImpl (тип ссылки: SeekableByteChannel) │ ├─ FileChannelImpl.size() → запрос в ОС │ ⮟ new byte[size] ← создание массива нужного размера │ ⮟ ├─ FileChannelImpl.read(byte[]) → заполнение массива (через ОС) │ ⮟ new String(byte[], UTF-8) ← декодирование байтов в символы │ ⮟ return String │ ⮟ auto close() Также создаётся канал доступа к файлу (FileChannelImpl), который используется через интерфейс SeekableByteChannel. Через него определяется размер файла (size()), после чего создаётся массив byte[] нужного размера. Далее метод read() считывает содержимое файла в массив байтов. После чтения, декодирование байтов в текст выполняется самим классом String. По умолчанию с использованием кодировки UTF-8. В конце метод возвращает весь файл одной готовой строкой, а канал автоматически закрывается благодаря конструкции try-with-resources. Если у файла другая кодировка, то указываем Charset. К примеру UTF_16: String text = Files.readString(path, StandardCharsets.UTF_16); Приведем пример. Дан тестовый файл: Java Python Go После применения метода String text = Files.readString(path); получим одну строку: "Java\nPython\nGo" - все строки файла попадают в один объект String; - символы перевода строки (\n, \r\n) сохраняются; Ограничения метода Files.readString(Path): 📏 Размер файла должен помещаться в память целиком. 🧠 Сначала создаётся byte[], затем String, поэтому памяти требуется больше, чем для одного массива байтов. ⏳ Весь файл читается целиком, нельзя обрабатывать “по частям” 🔤 Корректность результата зависит от используемой кодировки (по умолчанию UTF-8).
Grigoryvvv Уровень 19 Expert
16 июня 2026
Метод Files (java.nio) Возвращает Files.readAllLines(Path) List<String> Реализация внутри try-with-resources │ ⮟ FileChannelImpl │ ⮟ ChannelInputStream → поток-адаптер java.nio → java.io │ ⮟ InputStreamReader (java.io) → декодирование byte → char │ ⮟ BufferedReader.readLine() │ ⮟ String line │ ⮟ List<String>.add(line) ← цикл по всем строкам │ ⮟ return List<String> │ ⮟ auto close() Метод Files.readAllLines(Path) открывает файл и создаёт цепочку чтения текста. FileChannelImpl получает доступ к файлу, а ChannelInputStream выступает адаптером между API java.nio и java.io. Далее InputStreamReader выполняет декодирование полученных байтов в символы с использованием указанной кодировки. BufferedReader.readLine() читает файл построчно и возвращает каждую строку в виде объекта String. Каждая полученная строка добавляется в List<String> через add() внутри цикла. После завершения чтения метод возвращает заполненную коллекцию строк List<String>, а все открытые ресурсы автоматически закрываются благодаря конструкции try-with-resources. Приведем пример. Дан тестовый файл: Java Python Go После применения метода List<String> lines = Files.readAllLines(path); получим объект List<String> — коллекцию строк: ["Java", "Python", "Go"] Ограничения метода Files.readAllLines(Path) 🧠 Память: все строки файла одновременно сохраняются в List<String> → для больших файлов может возникнуть OutOfMemoryError. 📏 Размер файла: файл должен полностью помещаться в оперативной памяти JVM. ⏳ Нельзя обрабатывать строки по мере чтения — сначала весь файл загружается в коллекцию. 📚 Накладные расходы коллекции: кроме самих данных, создаётся List<String> и отдельные объекты String для каждой строки.
Grigoryvvv Уровень 19 Expert
17 июня 2026
ЗАПИСЬ Метод Files (java.nio) Возвращает Files.write(Path, byte[]) Path Реализация внутри try-with-resources │ ⮟ FileChannelImpl (тип ссылки: SeekableByteChannel) │ ⮟ FileChannelImpl.write(byte[]) │ ⮟ запись байтов через ОС │ ⮟ файл на диске │ ⮟ return Path │ ⮟ auto close() Метод Files.write(Path, byte[]) открывает канал доступа к файлу (FileChannelImpl), который используется для записи данных. Переданный массив byte[] передаётся в метод записи канала write(). Канал преобразует запрос в системный вызов операционной системы, после чего байты записываются в файл. После успешной записи метод возвращает исходный объект Path, а открытый ресурс автоматически закрывается благодаря конструкции try-with-resources. Files.write(Path, byte[]) : byte[] → файл, это зеркальный аналог метода Files.readAllBytes(Path) : файл → byte[] Ограничения метода Files.write(Path, byte[]) 🧠 Память: данные уже должны находиться в byte[] целиком. 📏 Размер: ограничен размером массива byte[] (Integer.MAX_VALUE). ⏳ Нет поэтапной передачи данных: метод принимает готовый byte[] целиком. 🔄 Перезапись: по умолчанию файл создаётся или заменяется (если не указаны дополнительные OpenOption).
Grigoryvvv Уровень 19 Expert
17 июня 2026
Метод Files (java.nio) Возвращает Files.writeString(Path, String) Path Реализация внутри try-with-resources │ ⮟ FileChannelImpl (тип ссылки: SeekableByteChannel) │ ⮟ String str │ ⮟ str.getBytes(StandardCharsets.UTF_8) ← кодирование символов в байты │ ⮟ byte[] │ ⮟ FileChannelImpl.write(byte[]) → передача байтов в ОС │ ⮟ файл на диске │ ⮟ return Path │ ⮟ auto close() Метод Files.writeString(Path, String) сначала открывает канал записи FileChannelImpl через конструкцию try-with-resources. После открытия канала переданная строка String str преобразуется в массив байтов byte[] с кодировкой UTF-8 с помощью метода класса String str.getBytes(StandardCharsets.UTF_8). Полученные байты передаются в FileChannelImpl.write(byte[]), который выполняет запись данных через операционную систему в файл. После успешной записи метод возвращает исходный объект Path, а открытый канал автоматически закрывается благодаря try-with-resources. Files.writeString(Path, String) : String → файл это текстовый аналог метода Files.write(Path, byte[]) : byte[] → файл и зеркальный аналог метода Files.readString(Path) : файл → String Ограничения метода Files.write(Path, byte[]) 📏 Размер: ограничен размером строки String и доступной памятью JVM. При записи больших объёмов текста может потребоваться дополнительная память для преобразования символов в byte[]. ⏳ Нет поэтапной передачи текста: метод принимает готовый String целиком. 🔄 Перезапись: по умолчанию файл создаётся или заменяется (если не указаны дополнительные OpenOption).
Grigoryvvv Уровень 19 Expert
17 июня 2026
3. Связь более старого API пакета java.io с более современным API пакетом java.nio java.nio — это современный API для работы с файлами и вводом-выводом. java.io — более старый API, основанный на потоках. Files (java.nio.file.Files) — часть современного API пакета java.nio (NIO), а InputStream и OutputStream — часть более старого API java.io (IO) Класс Files (java.nio.file.Files) предоставляет высокоуровневый API пакет java.nio и внутри "под капотом" больше не использует старые IO потоки FileReader, FileWriter, FileInputStream, FileOutputStream заменяя их на канальную архитектуру. С созданными каналами работают напрямую или оборачивают их в потоки-адаптеры ChannelInputStream, ChannelOutputStream и с помощью полиморфизма присваивают им ссылки типа InputStream и OutputStream. Далее, с помощью того же полиморфизма, с ними могут работать потоки старых классов java.io InputStreamReader, OutputStreamWriter, BufferedReader и BufferedWriter. Старые IO потоки FileReader, FileWriter, FileInputStream, FileOutputStream с новым java.nio не используются. По сути, потоки-адаптеры ChannelInputStream, ChannelOutputStream заменяют старые классы FileInputStream FileOutputStream, имеют схожие методы и позволяют соединить канальную архитектуру java.nio с потоками java.io Методы Files предоставляют более высокие уровни абстракции, при необходимости позволяя одним методом проделать под капотом всю работу, но имеют ограничения по размеру файлов.
Underdante Уровень 46
15 марта 2026
если кому не лень объясните почему валидатор не пропускает решение задачи фаиловые операции

if ( Files.notExists(filePath) ) {
			Files.createFile(filePath);
		}

if ( Files.notExists(fileNewPath) ) {
		Files.move(filePath, fileNewPath);
	} else {
		Files.delete(filePath);
	}
ведь после первого иф фаил есть в любом случае. не проходит второи пункт теста
FromZeroToHero Уровень 35
15 марта 2026
после первого if добавь else а так у тебя получается второй if срабатывает не учитывая существует ли файл по первому пути
Underdante Уровень 46
17 марта 2026
ты прав , я не понял задачи. спасибо
Anton Zorin Уровень 27
16 сентября 2025
Для себя решил прояснить, что вообще происходит. Без AI. Path resolve = targetDirectory.resolve(path.getFileName()); 1. Таргет дир - "c:\\windows\\projects"; 2. Из итератора path.getFileName() - text.txt; имя файла 3. resolve - крафтим абсолютли путь c:\\windows\\projects\\text.txt - но файла тут нет, если бы был, программа выбросит эксепшн. 4. Из итератора path, который содержит "D:\\windows\\projects\\text.txt" из директории sourceDirectory D:\\windows\\projects, мы копируем файл в абсолютли путь из шага 3.
NinaInfinity Уровень 21
26 июля 2025
Одна из самых понятных лекций и самых логичных задач за последнее время..,)
Exaltyr777 Уровень 25
23 июля 2025
почему-то мне GPT говорит что nio.files появился с Java 7, а не 5
I'll kick them all Уровень 5
28 июля 2025
Можете щелкнуть в Idea по имени Files в вашем коде с зажатой кнопкой Ctrl и увидеть, что такой класс действительно существует с Java 7. Такой метод значительно надежнее ChatGPT.
Exaltyr777 Уровень 25
31 июля 2025
Я так кликаю обычно чтобы понять че делает неизвестный мне метод в классе) Благо знание английского позволяет. Буду знать теперь что такие вещи тоже там можно найти, спасибо.
Виктор Уровень 28
17 июля 2025
Сначала создае́м обьект Path путь к файлу, а потом сам файл через метод. Затупил на этом капец).
Anonymous #3585174 Уровень 33
16 июля 2025
like
Aura Уровень 23
5 июня 2025
Задача "Файловые операции" это просто а******, чуть ли не идеал задачи для закрепления материала, дали такую задачу, в которой надо использовать половину изученных в этой лекции методов. Жаль, что слишком легкая была, не на подумать.
Артур Уровень 12
26 мая 2025
Кто как ,но на этой странице я застрял на 2 недели.
Emillionaire Уровень 23
13 апреля 2025
Такое ощущение что кто-то издевается. Почему это всё идет сейчас?! А не две темы назад, когда я просто в шоке был от того что ничего не понимаю и в задачах требуют то что я вижу первый раз!
@itArarat Уровень 32
2 декабря 2025
нужно уметь гуглить ,и это главная задача ,читать документацию... вы хотите чтобы вам с Hello world обяснили что такое System.in ?
Elisbeth Уровень 28
13 января 2026
Тут человек жалуется, что лекции в уровне перепутаны все местами, и так оно и есть, причём тут ваш System.in? Как мне надоели вы, умники, которые постоянно пишут про то, что надо гуглить😵 гуглить хорошо, конечно, но по этой логике можно вообще подписку не покупать, не сидеть на конкретном сайте, а только и лазить по разным статьям и документации И да, покупая подписку и выказывая своё доверие джаварашу, нет никакого желания гуглить в 10 раз больше, чем сидеть на самом джавараше, но с такими лекторами и организацией теории - приходится. И это не моя проблема, что я "гуглить не умею", а тех, кто эти лекции пишет