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

public class LineReader {
    
    public void readLines(Path file) throws IOException {
        // Stream<String> — ленивое чтение, строки появляются по мере обхода
        try (Stream<String> lines = Files.lines(file)) {
            lines.forEach(line -> System.out.println(line));
        }
        // BufferedReader закрыт автоматически try-with-resources
    }
}

import java.nio.charset.StandardCharsets;

public void readWithEncoding(Path file) throws IOException {
    // Явное указание кодировки — обязательно для файлов не в UTF-8
    try (Stream<String> lines = Files.lines(file, StandardCharsets.ISO_8859_1)) {
        lines.forEach(System.out::println);
    }
}

public void processHugeFile(Path file) throws IOException {
    try (Stream<String> lines = Files.lines(file)) {
        // Фильтрация и подсчёт — каждая строка обрабатывается и отбрасывается
        long errorCount = lines.filter(line -> line.contains("ERROR"))
                               .count();
        System.out.println("Ошибок: " + errorCount);
        // Память не зависит от размера файла — только от длины одной строки
    }
}

import java.nio.file.*;

public class WatchServiceFactory {
    
    public WatchService createWatchService() throws IOException {
        // Получаем WatchService для файловой системы по умолчанию
        WatchService watchService = FileSystems.getDefault().newWatchService();
        return watchService;
    }
}

import java.nio.file.*;

public class DirectoryRegistrar {
    
    public void registerDirectory(Path dir, WatchService watchService) throws IOException {
        // Регистрируем директорию на отслеживание создания, удаления и модификации
        WatchKey key = dir.register(watchService,
            StandardWatchEventKinds.ENTRY_CREATE,   // создание файла/директории
            StandardWatchEventKinds.ENTRY_DELETE,   // удаление
            StandardWatchEventKinds.ENTRY_MODIFY    // изменение содержимого или метаданных
        );
        
        // WatchKey — это токен, идентифицирующий зарегистрированную директорию
        // Его можно использовать для отмены регистрации
        System.out.println("Директория зарегистрирована: " + dir);
    }
}

import java.nio.file.*;
import java.util.concurrent.TimeUnit;

public class EventPoller {
    
    // Блокирующее ожидание: поток ждёт, пока не появится событие
    public void blockingWait(WatchService watchService) throws InterruptedException {
        // take() блокирует поток до появления события
        // Прерывается только при InterruptedException или закрытии WatchService
        WatchKey key = watchService.take();
        processKey(key);
    }
    
    // Неблокирующая проверка: возвращает null, если событий нет
    public void nonBlockingPoll(WatchService watchService) {
        WatchKey key = watchService.poll();
        if (key != null) {
            processKey(key);
        } else {
            System.out.println("Нет новых событий");
        }
    }
    
    // Ожидание с таймаутом
    public void timedPoll(WatchService watchService) throws InterruptedException {
        // Ждём 5 секунд, если событий нет — возвращаем null
        WatchKey key = watchService.poll(5, TimeUnit.SECONDS);
        if (key != null) {
            processKey(key);
        }
    }
    
    private void processKey(WatchKey key) {
        for (WatchEvent<?> event : key.pollEvents()) {
            WatchEvent.Kind<?> kind = event.kind();
            Path fileName = (Path) event.context();  // имя файла, вызвавшего событие
            
            System.out.println("Событие: " + kind.name() + " для " + fileName);
        }
        // Сбрасываем ключ, чтобы получать новые события
        boolean valid = key.reset();
        if (!valid) {
            System.out.println("Ключ больше не валиден — директория удалена");
        }
    }
}

WatchEvent<?> event = ...;

// Тип события: ENTRY_CREATE, ENTRY_DELETE, ENTRY_MODIFY
WatchEvent.Kind<?> kind = event.kind();

// Имя файла или директории, вызвавшей событие (относительно зарегистрированной директории)
Path context = (Path) event.context();

// Количество событий данного типа для этого файла (может быть > 1 при coalescing)
int count = event.count();

Path dir = (Path) key.watchable();  // зарегистрированная директория
Path absolute = dir.resolve(context);  // полный путь

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

public class FilesLinesTricky {
    public static void main(String[] args) throws Exception {
        Path file = Paths.get("test.txt");
        Files.write(file, Arrays.asList("A", "B", "C"));

        try (Stream<String> lines = Files.lines(file)) {
            Iterator<String> it = lines.iterator();
            System.out.print(it.next()); 
            System.out.print(it.next()); 

            Files.write(file, Arrays.asList("D", "E"), StandardOpenOption.APPEND);

            while (it.hasNext()) {
                System.out.print(it.next());
            }
        }
    }
}

import java.util.WeakHashMap;
import java.lang.ref.WeakReference;

public class WeakHashMapPitfall {
    
    static class Key { /* ... */ }
    
    static class Value {
        private final Key key; // ссылка на ключ!
        Value(Key key) { this.key = key; }
    }
    
    public static void main(String[] args) {
        //Антипаттерн: значение ссылается на ключ
        WeakHashMap<Key, Value> map = new WeakHashMap<>();
        Key key = new Key();
        map.put(key, new Value(key)); // значение хранит ссылку на ключ
        key = null; // убираем внешнюю ссылку
        System.gc(); // попытка сборки
        // Запись не будет удалена, так как Value держит Key
        System.out.println("Size: " + map.size()); // 1 — утечка!
        
        //Решение: не хранить ссылку на ключ в значении
        static class SafeValue {
            // без ссылки на Key
        }
        WeakHashMap<Key, SafeValue> safeMap = new WeakHashMap<>();
        Key key2 = new Key();
        safeMap.put(key2, new SafeValue());
        key2 = null;
        System.gc();
        // Запись будет удалена
        System.out.println("Safe size: " + safeMap.size()); // 0
        
        // Альтернатива: использовать WeakReference для значения
        WeakHashMap<Key, WeakReference<Value>> refMap = new WeakHashMap<>();
        Key key3 = new Key();
        refMap.put(key3, new WeakReference<>(new Value(key3))); // всё равно Value ссылается на Key
        // это не решает проблему, если Value ссылается на Key
    }
}

public class Task240726 {
    static class Key {
        String id;
        Key(String id) { this.id = id; }
        @Override
        public int hashCode() { return id.hashCode(); }
        @Override
        public boolean equals(Object o) {
            if (this == o) return true;
            if (!(o instanceof Key)) return false;
            Key key = (Key) o;
            return id.equals(key.id);
        }
    }
    static class Value {
        Key ref;
        Value(Key ref) { this.ref = ref; }
    }

    public static void main(String[] args) throws InterruptedException {
        WeakHashMap<Key, Value> map = new WeakHashMap<>();
        Key key1 = new Key("one");
        Key key2 = new Key("two");

        map.put(key1, new Value(key1));
        map.put(key2, new Value(null));

        key1 = null;
        key2 = null;

        System.gc();
        Thread.sleep(1000);

        System.out.println(map.size());
        System.out.println(map.containsKey(new Key("one")));
        System.out.println(map.containsKey(new Key("two")));
    }
}

import java.nio.file.*;
import java.nio.channels.SeekableByteChannel;
import java.nio.ByteBuffer;
import java.io.IOException;
import java.nio.charset.StandardCharsets;

public class ChannelOpener {
    
    public void openForRead(Path file) throws IOException {
        // Открываем только для чтения
        try (SeekableByteChannel channel = Files.newByteChannel(file, StandardOpenOption.READ)) {
            System.out.println("Размер файла: " + channel.size());
            System.out.println("Текущая позиция: " + channel.position());
        }
    }
    
    public void openForWrite(Path file) throws IOException {
        // Открываем для чтения и записи, создаём если нет, обрезаем если есть
        try (SeekableByteChannel channel = Files.newByteChannel(file,
                StandardOpenOption.READ,
                StandardOpenOption.WRITE,
                StandardOpenOption.CREATE,
                StandardOpenOption.TRUNCATE_EXISTING)) {
            
            // Записываем данные
            ByteBuffer buffer = ByteBuffer.wrap("Hello, World".getBytes(StandardCharsets.UTF_8));
            channel.write(buffer);
        }
    }
}

public class RandomAccessExample {
    
    public void readFromPosition(Path file, long position, int length) throws IOException {
        try (SeekableByteChannel channel = Files.newByteChannel(file, StandardOpenOption.READ)) {
            // Устанавливаем позицию
            channel.position(position);
            
            ByteBuffer buffer = ByteBuffer.allocate(length);
            int bytesRead = channel.read(buffer);
            
            buffer.flip();  // переключаем буфер из режима записи в режим чтения
            byte[] data = new byte[bytesRead];
            buffer.get(data);
            
            System.out.println("Прочитано с позиции " + position + ": " + new String(data));
        }
    }
    
    public void writeAtPosition(Path file, long position, String data) throws IOException {
        try (SeekableByteChannel channel = Files.newByteChannel(file,
                StandardOpenOption.READ, StandardOpenOption.WRITE)) {
            
            channel.position(position);
            
            ByteBuffer buffer = ByteBuffer.wrap(data.getBytes(StandardCharsets.UTF_8));
            channel.write(buffer);
            
            // После записи позиция сдвинулась на количество записанных байт
            System.out.println("Новая позиция: " + channel.position());
        }
    }
    
    public void appendToFile(Path file, String data) throws IOException {
        // Способ 1: через APPEND опцию
        try (SeekableByteChannel channel = Files.newByteChannel(file,
                StandardOpenOption.WRITE, StandardOpenOption.APPEND)) {
            ByteBuffer buffer = ByteBuffer.wrap(data.getBytes(StandardCharsets.UTF_8));
            channel.write(buffer);
        }
        
        // Способ 2: через position(size()) — ручное позиционирование в конец
        try (SeekableByteChannel channel = Files.newByteChannel(file,
                StandardOpenOption.READ, StandardOpenOption.WRITE)) {
            channel.position(channel.size());  // переходим в конец
            ByteBuffer buffer = ByteBuffer.wrap(data.getBytes(StandardCharsets.UTF_8));
            channel.write(buffer);
        }
    }
}

// Старый способ (RandomAccessFile)
try (RandomAccessFile raf = new RandomAccessFile("data.bin", "rw")) {
    raf.seek(100);  // позиционирование
    raf.write("data".getBytes());
}

// Новый способ (SeekableByteChannel)
try (SeekableByteChannel channel = Files.newByteChannel(Paths.get("data.bin"),
        StandardOpenOption.READ, StandardOpenOption.WRITE)) {
    channel.position(100);
    channel.write(ByteBuffer.wrap("data".getBytes()));
}

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

public class HardLinkManager {
    
    public void createHardLink(Path existingFile, Path newLink) throws IOException {
        // Проверяем, что исходный файл существует и на той же файловой системе
        if (!Files.isRegularFile(existingFile)) {
            throw new IllegalArgumentException("Исходный файл не существует или не является обычным файлом");
        }
        
        // createLink создаёт жёсткую ссылку
        Files.createLink(newLink, existingFile);
        
        // Проверяем: оба пути указывают на один inode
        Object key1 = Files.readAttributes(existingFile, BasicFileAttributes.class).fileKey();
        Object key2 = Files.readAttributes(newLink, BasicFileAttributes.class).fileKey();
        
        if (key1 != null && key1.equals(key2)) {
            System.out.println("Жёсткая ссылка создана. Оба пути указывают на inode " + key1);
        }
    }
}

public class SymlinkManager {
    
    public void createSymlink(Path link, Path target) throws IOException {
        // Создаём символическую ссылку
        // target может быть абсолютным или относительным
        Files.createSymbolicLink(link, target);
    }
    
    public void createRelativeSymlink(Path linkDir, Path targetFile) throws IOException {
        // Строим относительный путь от linkDir до targetFile
        Path relativeTarget = linkDir.relativize(targetFile);
        Path link = linkDir.resolve("shortcut");
        
        Files.createSymbolicLink(link, relativeTarget);
    }
    
    public void inspectSymlink(Path link) throws IOException {
        if (!Files.isSymbolicLink(link)) {
            System.out.println("Это не символическая ссылка");
            return;
        }
        
        // Читаем целевой путь, хранящийся в ссылке
        Path target = Files.readSymbolicLink(link);
        System.out.println("Ссылка указывает на: " + target);
        
        // Проверяем, существует ли целевой объект
        if (Files.exists(link)) {
            System.out.println("Целевой объект существует");
            
            // Читаем атрибуты целевого объекта (следуем по ссылке)
            BasicFileAttributes attrs = Files.readAttributes(link, BasicFileAttributes.class);
            System.out.println("Тип цели: " + (attrs.isDirectory() ? "директория" : "файл"));
        } else {
            System.out.println("Висячая ссылка — цель не существует");
        }
        
        // Читаем атрибуты самой ссылки (не следуем по ней)
        BasicFileAttributes linkAttrs = Files.readAttributes(
            link, BasicFileAttributes.class, LinkOption.NOFOLLOW_LINKS
        );
        System.out.println("Размер самой ссылки: " + linkAttrs.size() + " байт (длина пути)");
    }
}

public class SafeTreeWalker {
    
    // ОПАСНО: может зациклиться, если есть symlink на предка
    public void dangerousWalk(Path root) throws IOException {
        try (Stream<Path> stream = Files.walk(root, FileVisitOption.FOLLOW_LINKS)) {
            stream.forEach(System.out::println);  // риск бесконечного цикла
        }
    }
    
    // БЕЗОПАСНО: не следуем по символическим ссылкам
    public void safeWalk(Path root) throws IOException {
        try (Stream<Path> stream = Files.walk(root)) {  // без FOLLOW_LINKS
            stream.forEach(System.out::println);
        }
    }
    
    // БЕЗОПАСНО: следуем по ссылкам, но отслеживаем посещённые inode
    public void safeWalkWithCycleDetection(Path root) throws IOException {
        Set<Object> visitedInodes = new HashSet<>();
        
        Files.walkFileTree(root, EnumSet.of(FileVisitOption.FOLLOW_LINKS), Integer.MAX_VALUE,
            new SimpleFileVisitor<Path>() {
                @Override
                public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
                    Object key = attrs.fileKey();
                    if (key != null) {
                        if (visitedInodes.contains(key)) {
                            System.out.println("Обнаружен цикл через ссылку: " + file);
                            return FileVisitResult.SKIP_SIBLINGS;
                        }
                        visitedInodes.add(key);
                    }
                    System.out.println(file);
                    return FileVisitResult.CONTINUE;
                }
            }
        );
    }
}