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());
        }
    }
}

public void deleteRecursivelySafe(Path root) throws IOException {
    // FileVisitor — интерфейс для обхода дерева с callback-методами
    Files.walkFileTree(root, new SimpleFileVisitor<Path>() {
        @Override
        public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) 
                throws IOException {
            Files.delete(file);
            return FileVisitResult.CONTINUE;
        }
        
        @Override
        public FileVisitResult postVisitDirectory(Path dir, IOException exc) 
                throws IOException {
            if (exc != null) {
                throw exc;  // ошибка при обходе поддиректории
            }
            Files.delete(dir);
            return FileVisitResult.CONTINUE;
        }
    });
}

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

public class Task150726 {
    public static void main(String[] args) throws IOException {
        Path source = Paths.get("file.txt");
        Path target = Paths.get("target.txt");

        Files.createFile(source);
        Files.createFile(target);

        try {
            Files.move(source, target);
            System.out.println("Moved");
        } catch (IOException e) {
            System.out.println(e.getClass().getSimpleName());
        }

        System.out.println(Files.exists(source));
    }
}

public class ThreadYield {
    private boolean flag = false;
    
    //Антипаттерн: yield() в цикле ожидания
    public void badWait() {
        while (!flag) {
            Thread.yield(); // Плохо: может никогда не сработать, а если сработает, то не факт
        }
        // Действие после флага
    }
    
    //Правильно: использование Lock или wait/notify
    private final Object lock = new Object();
    
    public void goodWait() throws InterruptedException {
        synchronized (lock) {
            while (!flag) {
                lock.wait(); // Блокируется до уведомления
            }
        }
    }
    
    public void setFlagTrue() {
        synchronized (lock) {
            flag = true;
            lock.notifyAll();
        }
    }
}

public class Task160726 {
    public static void main(String[] args) throws InterruptedException {
        Thread t1 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.print("A");
                Thread.yield();
            }
        });
        Thread t2 = new Thread(() -> {
            for (int i = 0; i < 10; i++) {
                System.out.print("B");
                Thread.yield();
            }
        });
        t1.start();
        t2.start();
        t1.join();
        t2.join();
    }
}

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

public class AttributesReader {
    
    public void printBasicAttributes(Path path) throws IOException {
        // Читаем базовые атрибуты
        // LinkOption.NOFOLLOW_LINKS — читаем атрибуты самой ссылки, а не цели
        BasicFileAttributes attrs = Files.readAttributes(
            path, 
            BasicFileAttributes.class,
            LinkOption.NOFOLLOW_LINKS
        );
        
        System.out.println("Файл: " + path.getFileName());
        System.out.println("Размер: " + attrs.size() + " байт");
        System.out.println("Создан: " + attrs.creationTime());
        System.out.println("Изменён: " + attrs.lastModifiedTime());
        System.out.println("Доступ: " + attrs.lastAccessTime());
        System.out.println("Директория: " + attrs.isDirectory());
        System.out.println("Обычный файл: " + attrs.isRegularFile());
        System.out.println("Символическая ссылка: " + attrs.isSymbolicLink());
    }
}

// Неэффективно: три системных вызова
long size = Files.size(path);
boolean isDir = Files.isDirectory(path);
FileTime modified = Files.getLastModifiedTime(path);

// Эффективно: один системный вызов
BasicFileAttributes attrs = Files.readAttributes(path, BasicFileAttributes.class);
long size = attrs.size();
boolean isDir = attrs.isDirectory();
FileTime modified = attrs.lastModifiedTime();

BasicFileAttributes attrs = Files.readAttributes(path, BasicFileAttributes.class);
long fileSize = attrs.size();

Object key = attrs.fileKey();
if (key != null) {
    System.out.println("Уникальный ключ файла: " + key);
}

import java.nio.file.*;
import java.nio.file.attribute.*;
import java.io.IOException;
import java.util.concurrent.TimeUnit;

public class FullAttributesReporter {
    
    public void report(Path path) throws IOException {
        // Определяем, какой тип атрибутов запрашивать
        // Сначала пробуем POSIX (Unix/Linux/macOS)
        if (FileSystems.getDefault().supportedFileAttributeViews().contains("posix")) {
            reportPosixAttributes(path);
        } else if (FileSystems.getDefault().supportedFileAttributeViews().contains("dos")) {
            reportDosAttributes(path);
        } else {
            reportBasicAttributes(path);
        }
    }
    
    private void reportBasicAttributes(Path path) throws IOException {
        BasicFileAttributes attrs = Files.readAttributes(path, BasicFileAttributes.class);
        
        System.out.println("=== Базовые атрибуты ===");
        System.out.println("Путь: " + path.toAbsolutePath());
        System.out.println("Размер: " + formatSize(attrs.size()));
        System.out.println("Создан: " + formatTime(attrs.creationTime()));
        System.out.println("Изменён: " + formatTime(attrs.lastModifiedTime()));
        System.out.println("Доступ: " + formatTime(attrs.lastAccessTime()));
        System.out.println("Тип: " + resolveType(attrs));
        System.out.println("Уникальный ключ: " + attrs.fileKey());
    }
    
    private void reportPosixAttributes(Path path) throws IOException {
        PosixFileAttributes attrs = Files.readAttributes(path, PosixFileAttributes.class);
        
        reportBasicAttributes(path);  // POSIX extends Basic
        
        System.out.println("=== POSIX-атрибуты ===");
        System.out.println("Владелец: " + attrs.owner().getName());
        System.out.println("Группа: " + attrs.group().getName());
        System.out.println("Права: " + PosixFilePermissions.toString(attrs.permissions()));
    }
    
    private void reportDosAttributes(Path path) throws IOException {
        DosFileAttributes attrs = Files.readAttributes(path, DosFileAttributes.class);
        
        reportBasicAttributes(path);  // DOS extends Basic
        
        System.out.println("=== DOS-атрибуты ===");
        System.out.println("Только чтение: " + attrs.isReadOnly());
        System.out.println("Скрытый: " + attrs.isHidden());
        System.out.println("Системный: " + attrs.isSystem());
        System.out.println("Архивный: " + attrs.isArchive());
    }
    
    private String formatSize(long bytes) {
        if (bytes < 1024) return bytes + " B";
        if (bytes < 1024 * 1024) return String.format("%.2f KB", bytes / 1024.0);
        if (bytes < 1024L * 1024 * 1024) return String.format("%.2f MB", bytes / (1024.0 * 1024));
        return String.format("%.2f GB", bytes / (1024.0 * 1024 * 1024));
    }
    
    private String formatTime(FileTime time) {
        // FileTime.toInstant() возвращает Instant — точку на временной шкале
        return time.toInstant().toString();
    }
    
    private String resolveType(BasicFileAttributes attrs) {
        if (attrs.isDirectory()) return "директория";
        if (attrs.isRegularFile()) return "обычный файл";
        if (attrs.isSymbolicLink()) return "символическая ссылка";
        return "другое";
    }
    
    public static void main(String[] args) {
        try {
            new FullAttributesReporter().report(Paths.get("/etc/passwd"));
        } catch (IOException e) {
            System.err.println("Ошибка чтения атрибутов: " + e.getMessage());
        }
    }
}

import java.nio.file.*;
import java.nio.file.attribute.FileTime;
import java.io.IOException;
import java.time.Instant;

public class ModificationTimeSetter {
    
    public void touchFile(Path path) throws IOException {
        // "Touch" — обновить время модификации до текущего момента
        FileTime now = FileTime.from(Instant.now());
        Files.setLastModifiedTime(path, now);
    }
    
    public void setSpecificTime(Path path, Instant instant) throws IOException {
        FileTime fileTime = FileTime.from(instant);
        Files.setLastModifiedTime(path, fileTime);
    }
    
    public void copyTimestamps(Path source, Path target) throws IOException {
        // Копируем временные метки с источника на назначение
        BasicFileAttributes sourceAttrs = Files.readAttributes(
            source, BasicFileAttributes.class
        );
        
        Files.setLastModifiedTime(target, sourceAttrs.lastModifiedTime());
        
        // Время создания и доступа устанавливаются через setAttribute
        Files.setAttribute(target, "basic:creationTime", sourceAttrs.creationTime());
        Files.setAttribute(target, "basic:lastAccessTime", sourceAttrs.lastAccessTime());
    }
}

// Установка времени модификации через универсальный метод
Files.setAttribute(path, "basic:lastModifiedTime", FileTime.from(Instant.now()));

// Установка POSIX-прав
Set<PosixFilePermission> perms = PosixFilePermissions.fromString("rwxr-xr-x");
Files.setAttribute(path, "posix:permissions", perms);

// Установка владельца (только Unix с соответствующими правами)
UserPrincipalLookupService lookup = FileSystems.getDefault().getUserPrincipalLookupService();
UserPrincipal newOwner = lookup.lookupPrincipalByName("admin");
Files.setAttribute(path, "posix:owner", newOwner);

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

public class PosixPermissionManager {
    
    public void setStrictPermissions(Path path) throws IOException {
        // rw------- — только владелец может читать и писать
        Set<PosixFilePermission> perms = PosixFilePermissions.fromString("rw-------");
        Files.setPosixFilePermissions(path, perms);
    }
    
    public void setExecutable(Path path) throws IOException {
        // Добавляем право на выполнение для владельца
        Set<PosixFilePermission> perms = Files.getPosixFilePermissions(path);
        perms.add(PosixFilePermission.OWNER_EXECUTE);
        Files.setPosixFilePermissions(path, perms);
    }
    
    public void setSharedReadOnly(Path path) throws IOException {
        // r--r--r-- — все могут читать, никто не может писать
        Set<PosixFilePermission> perms = PosixFilePermissions.fromString("r--r--r--");
        Files.setPosixFilePermissions(path, perms);
    }
    
    public void copyPermissions(Path source, Path target) throws IOException {
        // Копируем POSIX-права с одного файла на другой
        Set<PosixFilePermission> perms = Files.getPosixFilePermissions(source);
        Files.setPosixFilePermissions(target, perms);
    }
    
    public void createWithPermissions(Path path, String permString) throws IOException {
        Set<PosixFilePermission> perms = PosixFilePermissions.fromString(permString);
        FileAttribute<Set<PosixFilePermission>> attr = PosixFilePermissions.asFileAttribute(perms);
        
        // createFile с FileAttribute устанавливает права атомарно при создании
        Files.createFile(path, attr);
    }
}

import java.nio.file.*;
import java.nio.file.attribute.FileTime;
import java.io.IOException;
import java.time.Instant;

public class FileToucher {
    
    public void touch(Path path) throws IOException {
        if (Files.notExists(path)) {
            // Если файла нет — создаём пустой файл
            // и время модификации будет равно времени создания (сейчас)
            Files.createFile(path);
            System.out.println("Файл создан: " + path);
            return;
        }
        
        // Файл существует — обновляем только время модификации
        FileTime now = FileTime.from(Instant.now());
        Files.setLastModifiedTime(path, now);
        
        // Проверяем, что установилось
        FileTime verify = Files.getLastModifiedTime(path);
        if (verify.compareTo(now) >= 0) {
            System.out.println("Время модификации обновлено: " + verify);
        } else {
            throw new IOException("Не удалось обновить время модификации");
        }
    }
    
    public void touchWithAccessTime(Path path) throws IOException {
        // Обновляем и время модификации, и время доступа
        FileTime now = FileTime.from(Instant.now());
        
        Files.setAttribute(path, "basic:lastModifiedTime", now);
        Files.setAttribute(path, "basic:lastAccessTime", now);
        
        // Проверяем через readAttributes
        BasicFileAttributes attrs = Files.readAttributes(path, BasicFileAttributes.class);
        System.out.println("mtime: " + attrs.lastModifiedTime());
        System.out.println("atime: " + attrs.lastAccessTime());
    }
    
    public static void main(String[] args) {
        try {
            Path file = Paths.get("/tmp/test_touch.txt");
            new FileToucher().touch(file);
        } catch (IOException e) {
            System.err.println("Ошибка: " + e.getMessage());
        }
    }
}

// Проблемный код: храним все атрибуты в памяти
Map<Path, BasicFileAttributes> cache = new HashMap<>();
Files.walk(root).forEach(p -> {
    try {
        cache.put(p, Files.readAttributes(p, BasicFileAttributes.class));
    } catch (IOException e) { /* ignore */ }
});
// При миллионе файлов cache содержит миллион объектов BasicFileAttributes в Old Generation

// Оптимизированный код: извлекаем только размер и mtime, храним примитивы
Map<Path, Long> sizeCache = new HashMap<>();
Files.walk(root).forEach(p -> {
    try {
        BasicFileAttributes attrs = Files.readAttributes(p, BasicFileAttributes.class);
        sizeCache.put(p, attrs.size());  // только long, лёгкий объект
    } catch (IOException e) { /* ignore */ }
});
// Объект attrs становится мусором сразу после итерации

// Обход с минимальным потреблением памяти
try (DirectoryStream<Path> stream = Files.newDirectoryStream(dir)) {
    for (Path entry : stream) {
        BasicFileAttributes attrs = Files.readAttributes(entry, BasicFileAttributes.class);
        process(entry, attrs.size(), attrs.lastModifiedTime());
        // attrs собирается GC сразу после process()
    }
}