import java.nio.file.*;
import java.io.IOException;
import java.nio.file.attribute.PosixFilePermission;
import java.nio.file.attribute.PosixFilePermissions;
import java.util.Set;

public class FileCreator {

    public void createEmptyFile(Path path) throws IOException {
        // Проверяем, существует ли родительская директория
        Path parent = path.getParent();
        if (parent != null && Files.notExists(parent)) {
            throw new NoSuchFileException(
                "Родительская директория не существует: " + parent
            );
        }

        // Создаём файл с правами доступа (только Unix)
        Set<PosixFilePermission> perms = PosixFilePermissions.fromString("rw-r--r--");
        FileAttribute<Set<PosixFilePermission>> attr = PosixFilePermissions.asFileAttribute(perms);

        Files.createFile(path, attr);
    }
}

public void createSingleDirectory(Path dir) throws IOException {
    // Создаём только конечную директорию
    // Предполагаем, что /var/log уже существует
    Path appLogs = Paths.get("/var/log/myapp");
    Files.createDirectory(appLogs);
}

public void createNestedStructure() throws IOException {
    Path deepPath = Paths.get("data", "books", "2024", "reviews");

    // Создаёт data/, data/books/, data/books/2024/, data/books/2024/reviews/
    Files.createDirectories(deepPath);

    // Проверяем, что создано
    System.out.println("Создана структура: " + deepPath.toAbsolutePath());
    System.out.println("Количество сегментов: " + deepPath.getNameCount());
}

Path tempFile = Files.createTempFile("report_", ".tmp");
// Результат: /tmp/report_1234567890.tmp

Path customDir = Paths.get("/app/temp");
Files.createDirectories(customDir);
Path tempInCustom = Files.createTempFile(customDir, "session_", ".dat");

Path tempDir = Files.createTempDirectory("batch_processing_");
// Результат: /tmp/batch_processing_1234567890/

Path workDir = Paths.get("/var/app/work");
Path tempWorkDir = Files.createTempDirectory(workDir, "job_");

Path src = Paths.get("/data/report.txt");
Path dst = Paths.get("/backup/report.txt");

Files.copy(src, dst);  // FileAlreadyExistsException, если dst существует

Files.copy(src, dst, StandardCopyOption.REPLACE_EXISTING);

Files.copy(src, dst, 
    StandardCopyOption.REPLACE_EXISTING,
    StandardCopyOption.COPY_ATTRIBUTES
);

import java.net.URL;

public void downloadFile(String urlString, Path target) throws IOException {
    URL url = new URL(urlString);
    try (InputStream in = url.openStream()) {
        // Копируем всё содержимое потока в файл
        // CREATE — создать файл, если нет
        // REPLACE_EXISTING — перезаписать, если есть
        long bytesCopied = Files.copy(in, target, 
            StandardCopyOption.REPLACE_EXISTING
        );
        System.out.println("Скопировано байт: " + bytesCopied);
    }
    // InputStream закрыт автоматически try-with-resources
}

public void streamFileToResponse(Path file, OutputStream responseOut) throws IOException {
    // Отправляем файл в HTTP-ответ
    // responseOut управляется внешним кодом (сервлет, фреймворк)
    long bytesSent = Files.copy(file, responseOut);
    responseOut.flush();  // явно сбрасываем буфер
}

import java.nio.file.*;
import java.io.IOException;
import java.util.stream.Stream;

public class DirectoryCopier {

    public void copyDirectory(Path source, Path target) throws IOException {
        // Проверяем, что источник — директория
        if (!Files.isDirectory(source)) {
            throw new NotDirectoryException(source.toString());
        }

        // Создаём корневую директорию назначения
        // createDirectories идемпотентен — не бросает исключение, если уже есть
        Files.createDirectories(target);

        // Обходим дерево источника
        try (Stream<Path> walk = Files.walk(source)) {
            walk.forEach(srcPath -> {
                try {
                    // Вычисляем относительный путь от корня источника
                    Path relative = source.relativize(srcPath);
                    // Резолвим его относительно корня назначения
                    Path dstPath = target.resolve(relative);

                    if (Files.isDirectory(srcPath)) {
                        // Создаём директорию
                        Files.createDirectories(dstPath);
                    } else {
                        // Копируем файл
                        Files.copy(srcPath, dstPath, 
                            StandardCopyOption.REPLACE_EXISTING,
                            StandardCopyOption.COPY_ATTRIBUTES
                        );
                    }
                } catch (IOException e) {
                    // Оборачиваем в unchecked для использования внутри forEach
                    throw new UncheckedIOException(e);
                }
            });
        }
    }
}

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

public class Task130726 {
    public static void main(String[] args) {
        boolean created1 = false;
        try {
            File file = new File("parent/child.txt");
            created1 = file.createNewFile();
        } catch (IOException e) {
            created1 = false;
        }
        System.out.print(created1 + " ");

        boolean created2 = false;
        try {
            Path path = Paths.get("parent/child2.txt");
            Files.createFile(path);
            created2 = true;
        } catch (IOException e) {
            created2 = false;
        }
        System.out.print(created2);
    }
}

public class LatchVsBarrier {
    
    public static void main(String[] args) throws InterruptedException {
        //CountDownLatch одноразовый
        CountDownLatch latch = new CountDownLatch(3);
        
        // Первая фаза: ожидаем 3 потока
        for (int i = 0; i < 3; i++) {
            new Thread(() -> {
                // работа
                latch.countDown();
            }).start();
        }
        latch.await(); // ждем завершения первой фазы
        System.out.println("Первая фаза завершена");
        
        // Попытка второй фазы — бессмысленна, latch уже на нуле
        // Новые потоки, вызывающие latch.await(), пройдут без ожидания
        // latch.countDown() не имеет эффекта
        
        //CyclicBarrier переиспользуется
        CyclicBarrier barrier = new CyclicBarrier(3, () -> 
            System.out.println("Барьер достигнут, выполняется действие"));
        
        Runnable task = () -> {
            try {
                // Первая итерация
                System.out.println(Thread.currentThread().getName() + " готов к фазе 1");
                barrier.await();
                // работа после барьера
                System.out.println(Thread.currentThread().getName() + " завершил фазу 1");
                
                // Вторая итерация — барьер сброшен автоматически
                System.out.println(Thread.currentThread().getName() + " готов к фазе 2");
                barrier.await();
                System.out.println(Thread.currentThread().getName() + " завершил фазу 2");
            } catch (InterruptedException | BrokenBarrierException e) {
                Thread.currentThread().interrupt();
            }
        };
        
        for (int i = 0; i < 3; i++) {
            new Thread(task).start();
        }
    }
}

import java.util.concurrent.CountDownLatch;

public class Task140726 {
    public static void main(String[] args) throws InterruptedException {
        CountDownLatch latch = new CountDownLatch(1);
        latch.countDown();
        
        for (int i = 0; i < 3; i++) {
            latch.await();
            System.out.print(i + " ");
        }
        System.out.print(latch.getCount());
    }
}

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

public class FileMover {
    
    public void renameFile(Path oldName, Path newName) throws IOException {
        // Простое переименование в той же директории
        Files.move(oldName, newName);
    }
    
    public void moveToArchive(Path file, Path archiveDir) throws IOException {
        // Перемещение в другую директорию
        Path target = archiveDir.resolve(file.getFileName());
        Files.move(file, target);
    }
}

Path src = Paths.get("/data/report_v1.txt");
Path dst = Paths.get("/data/report.txt");

// Перезаписываем старый отчёт новым
Files.move(src, dst, StandardCopyOption.REPLACE_EXISTING);

Path src = Paths.get("/data/temp_report.txt");
Path dst = Paths.get("/data/report.txt");

// Атомарное переименование: читатели либо видят старый файл, либо новый
Files.move(src, dst, StandardCopyOption.ATOMIC_MOVE);

import java.nio.file.*;
import java.io.IOException;
import java.time.Instant;
import java.time.ZoneId;
import java.time.format.DateTimeFormatter;

public class ArchiveMover {
    
    private static final DateTimeFormatter DATE_FORMAT = 
        DateTimeFormatter.ofPattern("yyyy-MM-dd").withZone(ZoneId.systemDefault());
    
    public void archiveProcessedFile(Path processedFile, Path archiveRoot) throws IOException {
        // Проверяем, что источник существует и является файлом
        if (!Files.isRegularFile(processedFile)) {
            throw new NoSuchFileException("Файл не найден или не является обычным файлом: " + processedFile);
        }
        
        // Создаём архивную директорию с текущей датой: /archive/2024-07-14/
        String today = DATE_FORMAT.format(Instant.now());
        Path datedArchive = archiveRoot.resolve(today);
        Files.createDirectories(datedArchive);
        
        // Формируем целевой путь
        String fileName = processedFile.getFileName().toString();
        Path target = datedArchive.resolve(fileName);
        
        // Если файл с таким именем уже есть в архиве — добавляем счётчик
        Path finalTarget = resolveUniqueName(target);
        
        // Атомарное перемещение
        Files.move(processedFile, finalTarget, StandardCopyOption.ATOMIC_MOVE);
        
        System.out.println("Файл перемещён в архив: " + finalTarget.toAbsolutePath());
    }
    
    private Path resolveUniqueName(Path target) {
        if (Files.notExists(target)) {
            return target;
        }
        
        // Генерируем уникальное имя: file.txt -> file_1.txt, file_2.txt
        String fileName = target.getFileName().toString();
        int lastDot = fileName.lastIndexOf('.');
        String base = lastDot > 0 ? fileName.substring(0, lastDot) : fileName;
        String ext = lastDot > 0 ? fileName.substring(lastDot) : "";
        Path parent = target.getParent();
        
        int counter = 1;
        Path candidate;
        do {
            candidate = parent.resolve(base + "_" + counter + ext);
            counter++;
        } while (Files.exists(candidate));
        
        return candidate;
    }
    
    public static void main(String[] args) {
        try {
            Path file = Paths.get("/app/inbox/order_12345.xml");
            Path archive = Paths.get("/app/archive");
            new ArchiveMover().archiveProcessedFile(file, archive);
        } catch (AtomicMoveNotSupportedException e) {
            System.err.println("Атомарное перемещение невозможно — источник и архив на разных разделах");
            // Fallback: копирование + удаление
        } catch (IOException e) {
            System.err.println("Ошибка архивирования: " + e.getMessage());
        }
    }
}

Path file = Paths.get("/tmp/old_data.tmp");
Files.delete(file);  // NoSuchFileException, если файла нет

Path tempFile = Paths.get("/tmp/session_abc123.tmp");
boolean wasDeleted = Files.deleteIfExists(tempFile);
if (wasDeleted) {
    System.out.println("Временный файл удалён");
} else {
    System.out.println("Файл уже был удалён или не существовал");
}

Path dir = Paths.get("/tmp/myapp");
try {
    Files.delete(dir);  // DirectoryNotEmptyException, если внутри есть файлы
} catch (DirectoryNotEmptyException e) {
    // Нужно сначала удалить содержимое
}

import java.nio.file.*;
import java.io.IOException;
import java.util.Comparator;
import java.util.stream.Stream;

public class TreeDeleter {
    
    public void deleteDirectoryRecursively(Path root) throws IOException {
        if (!Files.exists(root)) {
            return;  // Нечего удалять
        }
        
        // walk возвращает Stream<Path> в порядке pre-order (родитель до детей)
        // sorted(reverseOrder()) переворачивает: сначала глубокие пути, потом корень
        try (Stream<Path> walk = Files.walk(root)) {
            walk.sorted(Comparator.reverseOrder())
                .forEach(path -> {
                    try {
                        Files.delete(path);
                    } catch (IOException e) {
                        // Оборачиваем в UncheckedIOException для использования в forEach
                        throw new UncheckedIOException(
                            "Не удалось удалить: " + path, e
                        );
                    }
                });
        } catch (UncheckedIOException e) {
            // Распаковываем обратно в checked исключение
            throw e.getCause();
        }
    }
}

import java.nio.file.*;
import java.io.IOException;
import java.util.stream.Stream;

public class TempCleaner {
    
    private static final Path TEMP_DIR = Paths.get(System.getProperty("java.io.tmpdir"));
    
    public void cleanTempFiles() throws IOException {
        // Проверяем, что TEMP_DIR существует и является директорией
        if (!Files.isDirectory(TEMP_DIR)) {
            throw new NotDirectoryException(TEMP_DIR.toString());
        }
        
        // Обходим только верхний уровень временной директории
        // newDirectoryStream — более лёгкая альтернатива walk для одного уровня
        try (DirectoryStream<Path> stream = Files.newDirectoryStream(TEMP_DIR)) {
            for (Path entry : stream) {
                if (Files.isRegularFile(entry) && entry.toString().endsWith(".tmp")) {
                    try {
                        Files.delete(entry);
                        System.out.println("Удалён: " + entry.getFileName());
                    } catch (IOException e) {
                        // Логируем, но продолжаем удаление остальных
                        System.err.println("Не удалось удалить " + entry.getFileName() 
                            + ": " + e.getMessage());
                    }
                }
            }
        }
    }
    
    // Альтернатива: удаление .tmp файлов рекурсивно во всём поддереве
    public void cleanTempFilesRecursive(Path root) throws IOException {
        try (Stream<Path> walk = Files.walk(root)) {
            walk.filter(Files::isRegularFile)
                .filter(p -> p.toString().endsWith(".tmp"))
                .forEach(p -> {
                    try {
                        Files.delete(p);
                        System.out.println("Удалён: " + p);
                    } catch (IOException e) {
                        System.err.println("Ошибка удаления " + p + ": " + e.getMessage());
                    }
                });
        }
    }
    
    // Удаление .tmp файлов старше N дней
    public void cleanOldTempFiles(int daysOld) throws IOException {
        long cutoff = System.currentTimeMillis() - (daysOld * 24 * 60 * 60 * 1000L);
        
        try (Stream<Path> walk = Files.walk(TEMP_DIR)) {
            walk.filter(Files::isRegularFile)
                .filter(p -> p.toString().endsWith(".tmp"))
                .filter(p -> {
                    try {
                        return Files.getLastModifiedTime(p).toMillis() < cutoff;
                    } catch (IOException e) {
                        return false;  // Не удалось прочитать — пропускаем
                    }
                })
                .forEach(p -> {
                    try {
                        Files.delete(p);
                        System.out.println("Удалён старый файл: " + p.getFileName());
                    } catch (IOException e) {
                        System.err.println("Ошибка: " + e.getMessage());
                    }
                });
        }
    }
    
    public static void main(String[] args) {
        try {
            TempCleaner cleaner = new TempCleaner();
            cleaner.cleanTempFiles();
            cleaner.cleanOldTempFiles(7);  // удалить .tmp старше 7 дней
        } catch (IOException e) {
            System.err.println("Ошибка очистки: " + e.getMessage());
        }
    }
}