public class ThreadStopExample {
    
    //Антипаттерн: Thread.stop()
    public static void badStop() throws InterruptedException {
        Thread t = new Thread(() -> {
            while (true) {
                System.out.println("Работаю...");
                // Если здесь stop() будет вызван, данные могут быть повреждены
            }
        });
        t.start();
        Thread.sleep(100);
        t.stop(); // Опасно! Освобождает мониторы, оставляя объекты в мусорном состоянии
    }
    
    //Правильно: кооперативное завершение через прерывание
    public static void goodInterrupt() throws InterruptedException {
        Thread t = new Thread(() -> {
            while (!Thread.currentThread().isInterrupted()) {
                System.out.println("Безопасная работа...");
                try {
                    Thread.sleep(500);
                } catch (InterruptedException e) {
                    // Восстанавливаем статус прерывания и выходим
                    Thread.currentThread().interrupt();
                    break;
                }
            }
            System.out.println("Поток корректно завершён");
        });
        t.start();
        Thread.sleep(2000);
        t.interrupt(); // Сигнал остановки
        t.join();
    }
    
    // Альтернатива: volatile флаг
    private volatile boolean running = true;
    
    public void safeWithFlag() throws InterruptedException {
        Thread t = new Thread(() -> {
            while (running) {
                System.out.println("Работа с флагом...");
                try {
                    Thread.sleep(300);
                } catch (InterruptedException e) {
                    // При прерывании тоже можем выйти
                    Thread.currentThread().interrupt();
                    break;
                }
            }
        });
        t.start();
        Thread.sleep(1000);
        running = false; // Сигнал остановки
        t.interrupt();   // Дополнительно для прерывания блокировок
        t.join();
    }
    
    public static void main(String[] args) throws InterruptedException {
        // badStop(); // Не запускайте!
        goodInterrupt();
    }
}

public class ThreadStopTricky {
    private static int value = 0;

    public static void main(String[] args) throws Exception {
        Thread t = new Thread(() -> {
            synchronized (ThreadStopTricky.class) {
                value = 1;
                try { Thread.sleep(1000); } catch (InterruptedException e) {}
                value = 2;
            }
        });
        t.start();
        Thread.sleep(50);
        t.stop();
        synchronized (ThreadStopTricky.class) {
            System.out.println(value);
        }
    }
}

public class DirectoryLister {
    
    public void listDirectory(Path dir) throws IOException {
        // Stream<Path> — ленивый поток, записи читаются по требованию
        try (Stream<Path> stream = Files.list(dir)) {
            stream.forEach(path -> {
                String type = Files.isDirectory(path) ? "[DIR]" : "[FILE]";
                System.out.println(type + " " + path.getFileName());
            });
        }
    }
}

public class TxtFileFinder {
    
    public void findTxtFiles(Path dir) throws IOException {
        try (Stream<Path> stream = Files.list(dir)) {
            stream.filter(Files::isRegularFile)           // только файлы, не директории
                  .filter(this::hasTxtExtension)           // фильтр по расширению
                  .forEach(this::printFileInfo);
        }
    }
    
    private boolean hasTxtExtension(Path path) {
        String fileName = path.getFileName().toString();
        // endsWith чувствителен к регистру — на case-sensitive ФС это корректно
        return fileName.endsWith(".txt");
    }
    
    private void printFileInfo(Path path) {
        try {
            long size = Files.size(path);
            FileTime modified = Files.getLastModifiedTime(path);
            System.out.printf("%s (%d bytes, modified: %s)%n",
                path.getFileName(), size, modified);
        } catch (IOException e) {
            System.err.println("Ошибка чтения атрибутов: " + path.getFileName());
        }
    }
    
    // Альтернатива: чтение атрибутов за один вызов для каждого файла
    public void findTxtFilesOptimized(Path dir) throws IOException {
        try (Stream<Path> stream = Files.list(dir)) {
            stream.filter(Files::isRegularFile)
                  .filter(p -> p.toString().endsWith(".txt"))
                  .map(p -> {
                      try {
                          BasicFileAttributes attrs = Files.readAttributes(
                              p, BasicFileAttributes.class
                          );
                          return new FileInfo(p.getFileName(), attrs.size(), 
                                            attrs.lastModifiedTime());
                      } catch (IOException e) {
                          return null;
                      }
                  })
                  .filter(Objects::nonNull)
                  .forEach(System.out::println);
        }
    }
    
    private record FileInfo(Path name, long size, FileTime modified) {}
}

функция list(Path dir) -> Stream<Path>:
    открыть файловый дескриптор директории dir (системный вызов opendir)
    создать DirectoryStream для чтения записей
    создать Stream, который при запросе следующего элемента:
        вызывает DirectoryStream.readNextEntry()
        если запись есть — возвращает Path(entry_name)
        если записей больше нет — закрывает дескриптор и завершает поток
    зарегистрировать onClose для Stream, который закрывает дескриптор
    вернуть Stream

public void walkDirectory(Path root) throws IOException {
    try (Stream<Path> stream = Files.walk(root)) {
        stream.forEach(path -> {
            int depth = root.relativize(path).getNameCount();
            String indent = "  ".repeat(depth);
            System.out.println(indent + path.getFileName());
        });
    }
}

public void walkWithDepthLimit(Path root) throws IOException {
    // Обходим только 2 уровня вглубь
    try (Stream<Path> stream = Files.walk(root, 2)) {
        stream.filter(Files::isRegularFile)
              .forEach(p -> System.out.println(p.toAbsolutePath()));
    }
}

public class SafeWalker {
    
    // Безопасный обход: символические ссылки обрабатываются как файлы, не следуем по ним
    public void walkNoFollowLinks(Path root) throws IOException {
        // По умолчанию walk НЕ следует по ссылкам — это поведение по умолчанию
        // Но явно можно указать:
        try (Stream<Path> stream = Files.walk(root)) {
            stream.forEach(path -> {
                if (Files.isSymbolicLink(path)) {
                    System.out.println("[LINK] " + path.getFileName());
                }
            });
        }
    }
    
    // Обход с явным следованием по ссылкам (осторожно!)
    public void walkFollowingLinks(Path root) throws IOException {
        try (Stream<Path> stream = Files.walk(root, FileVisitOption.FOLLOW_LINKS)) {
            stream.forEach(System.out::println);
        }
    }
}

функция walk(Path start, int maxDepth) -> Stream<Path>:
    создать очередь (Deque) для обхода в ширину/глубину
    поместить start в очередь с глубиной 0
    создать Stream, который при запросе элемента:
        извлекает следующий путь из очереди
        возвращает его как элемент Stream
        если это директория И глубина < maxDepth:
            открыть DirectoryStream для этой директории
            для каждой записи:
                поместить entry в очередь с глубиной + 1
    зарегистрировать onClose для закрытия всех открытых DirectoryStream
    вернуть Stream

// ОПАСНО: материализует все пути в память
Files.walk(root).sorted().forEach(...);  // OOM при миллионе файлов

// Безопасно: обход без сортировки
Files.walk(root).forEach(...);  // ленивый, память ограничена буфером

import java.nio.file.*;
import java.nio.file.attribute.BasicFileAttributes;
import java.io.IOException;
import java.util.concurrent.atomic.AtomicLong;

public class ControlledTreeWalker implements FileVisitor<Path> {
    
    private final AtomicLong totalSize = new AtomicLong(0);
    private final long maxSizeToProcess;  // прервать после достижения лимита
    private volatile boolean cancelled = false;
    
    public ControlledTreeWalker(long maxSize) {
        this.maxSizeToProcess = maxSize;
    }
    
    @Override
    public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) {
        if (cancelled) {
            return FileVisitResult.TERMINATE;  // прервать обход
        }
        // Пропускаем скрытые директории
        try {
            if (Files.isHidden(dir)) {
                return FileVisitResult.SKIP_SUBTREE;  // не заходить внутрь
            }
        } catch (IOException e) {
            // Продолжаем, если не удалось проверить
        }
        return FileVisitResult.CONTINUE;
    }
    
    @Override
    public FileVisitResult visitFile(Path file, BasicFileAttributes attrs) {
        if (cancelled) {
            return FileVisitResult.TERMINATE;
        }
        if (attrs.isRegularFile()) {
            totalSize.addAndGet(attrs.size());
            if (totalSize.get() >= maxSizeToProcess) {
                cancelled = true;
                return FileVisitResult.TERMINATE;
            }
        }
        return FileVisitResult.CONTINUE;
    }
    
    @Override
    public FileVisitResult visitFileFailed(Path file, IOException exc) {
        // Логируем ошибку, но продолжаем обход
        System.err.println("Ошибка доступа к файлу: " + file + " — " + exc.getMessage());
        return FileVisitResult.CONTINUE;
    }
    
    @Override
    public FileVisitResult postVisitDirectory(Path dir, IOException exc) {
        if (exc != null) {
            System.err.println("Ошибка обхода директории: " + dir + " — " + exc.getMessage());
        }
        return FileVisitResult.CONTINUE;
    }
    
    public long getTotalSize() {
        return totalSize.get();
    }
    
    public static long calculateSizeWithLimit(Path root, long limit) throws IOException {
        ControlledTreeWalker walker = new ControlledTreeWalker(limit);
        Files.walkFileTree(root, walker);
        return walker.getTotalSize();
    }
}

// Оптимизация: используем 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);  // полный путь