// Оптимизация: используем walkFileTree вместо Stream для минимизации объектов
public long fastSizeCalculation(Path root) throws IOException {
    long[] total = new long[1];  // массив примитивов — нет boxing, нет объектов
    
    Files.walkFileTree(root, new SimpleFileVisitor<Path>() {
        @Override
        public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
            total[0] += attrs.size();  // прямой доступ к примитиву
            return FileVisitResult.CONTINUE;
        }
    });
    
    return total[0];
}

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

public class Task210726 {
    public static void main(String[] args) throws IOException {
        Path dir = Paths.get("test");
        Files.createDirectory(dir);
        Files.createFile(dir.resolve("a.txt"));
        Files.createFile(dir.resolve("b.txt"));

        Stream<Path> stream = Files.list(dir);
        System.out.print(stream.count() + " ");
        System.out.print(stream.count());
    }
}

import java.nio.charset.StandardCharsets;
import java.io.UnsupportedEncodingException;

public class StringGetBytes {
    
    public static void main(String[] args) throws UnsupportedEncodingException {
        String text = "Привет, мир!";
        
        //Антипаттерн: платформенно-зависимая кодировка
        byte[] badBytes = text.getBytes();
        System.out.println("Длина (default): " + badBytes.length);
        // На Windows (CP1251) результат может быть другим, чем на Linux (UTF-8)
        
        //Решение: явная кодировка UTF-8
        byte[] goodBytes = text.getBytes(StandardCharsets.UTF_8);
        System.out.println("Длина (UTF-8): " + goodBytes.length);
        
        // Также при обратном преобразовании
        String restored = new String(goodBytes, StandardCharsets.UTF_8);
        System.out.println("Восстановлено: " + restored);
        
        // Для старых версий Java (до 7) используйте строковое имя
        // byte[] bytes = text.getBytes("UTF-8");
        // Но StandardCharsets предпочтительнее (типобезопасно)
        
        // Демонстрация различий: символы вне ASCII кодируются по-разному
        String euro = "€"; // Символ евро
        byte[] utf8 = euro.getBytes(StandardCharsets.UTF_8);    // 3 байта (E2 82 AC)
        byte[] win1251 = euro.getBytes("Windows-1251");         // 1 байт (80) или не поддерживается
        System.out.println("UTF-8 length: " + utf8.length);
        System.out.println("Windows-1251 length: " + win1251.length);
    }
}

public class Task220726 {
    public static void main(String[] args) {
        String s = "é";
        System.out.println(s.getBytes().length);
    }
}

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