Listowanie i przeszukiwanie katalogów przez walkFileTree

import java.io.BufferedReader;
import java.io.IOException;
import java.io.InputStreamReader;
import java.io.UncheckedIOException;
import java.nio.charset.StandardCharsets;
import java.nio.file.FileVisitResult;
import java.nio.file.Files;
import java.nio.file.LinkOption;
import java.nio.file.Path;
import java.nio.file.SimpleFileVisitor;
import java.nio.file.attribute.BasicFileAttributes;
import java.util.ArrayList;
import java.util.Comparator;
import java.util.List;
import java.util.Locale;
import java.util.Objects;
import java.util.Set;
import java.util.stream.Stream;

/**
 * Listowanie i przeszukiwanie katalogów przez walkFileTree — skryptyJAVA.pl
 * Zapisz jako: PrzeszukiwanieKatalogow.java
 */
public class PrzeszukiwanieKatalogow {

    /** Znajduje zwykłe pliki o rozszerzeniu, schodząc najwyżej na podaną głębokość. */
    public static List<Path> znajdzPoRozszerzeniu(Path katalog, String rozszerzenie,
                                                  int maksymalnaGlebokosc) throws IOException {
        if (maksymalnaGlebokosc < 0) {
            throw new IllegalArgumentException("Głębokość nie może być ujemna.");
        }
        String koncowka = normalizujRozszerzenie(rozszerzenie);
        List<Path> wyniki = new ArrayList<>();
        Files.walkFileTree(katalog, Set.of(), maksymalnaGlebokosc, new SimpleFileVisitor<>() {
            @Override
            public FileVisitResult preVisitDirectory(Path dir, BasicFileAttributes attrs) {
                if (!dir.equals(katalog) && (attrs.isSymbolicLink() || attrs.isOther())) {
                    return FileVisitResult.SKIP_SUBTREE;
                }
                return FileVisitResult.CONTINUE;
            }

            @Override
            public FileVisitResult visitFile(Path plik, BasicFileAttributes attrs) {
                if (attrs.isRegularFile() && maRozszerzenie(plik, koncowka)) {
                    wyniki.add(plik);
                }
                return FileVisitResult.CONTINUE;
            }
        });
        wyniki.sort(Comparator.comparing(plik -> katalog.relativize(plik).toString(),
                String.CASE_INSENSITIVE_ORDER));
        return List.copyOf(wyniki);
    }

    /** Przed kropką musi coś stać: plik nazwany ".txt" jest ukryty, a nie typu txt. */
    private static boolean maRozszerzenie(Path plik, String koncowka) {
        String nazwa = plik.getFileName().toString().toLowerCase(Locale.ROOT);
        return nazwa.length() > koncowka.length() && nazwa.endsWith(koncowka);
    }

    /** Wyszukuje fragment bez rozróżniania wielkości liter w plikach danego typu. */
    public static List<Path> znajdzWTresci(Path katalog, String rozszerzenie,
                                           String fragment) throws IOException {
        String szukany = Objects.requireNonNull(fragment, "fragment").toLowerCase(Locale.ROOT);
        List<Path> wyniki = new ArrayList<>();
        for (Path plik : znajdzPoRozszerzeniu(katalog, rozszerzenie, Integer.MAX_VALUE)) {
            if (plikZawiera(plik, szukany)) {
                wyniki.add(plik);
            }
        }
        return List.copyOf(wyniki);
    }

    /** Czyta plik linia po linii; strumień nie pozostaje otwarty po powrocie z metody. */
    private static boolean plikZawiera(Path plik, String szukany) throws IOException {
        try (BufferedReader czytnik = new BufferedReader(new InputStreamReader(
                     Files.newInputStream(plik, LinkOption.NOFOLLOW_LINKS),
                     StandardCharsets.UTF_8));
             Stream<String> linie = czytnik.lines()) {
            try {
                return linie.anyMatch(linia -> linia.toLowerCase(Locale.ROOT).contains(szukany));
            } catch (UncheckedIOException wyjatek) {
                throw wyjatek.getCause();
            }
        }
    }

    private static String normalizujRozszerzenie(String rozszerzenie) {
        String wynik = Objects.requireNonNull(rozszerzenie, "rozszerzenie")
                .strip().toLowerCase(Locale.ROOT);
        if (wynik.isEmpty() || wynik.equals(".")) {
            throw new IllegalArgumentException("Podaj rozszerzenie, na przykład txt.");
        }
        return wynik.startsWith(".") ? wynik : "." + wynik;
    }

    /** Usuwa drzewo od najgłębszych elementów; używane tylko do sprzątania demonstracji. */
    private static void usunDrzewo(Path katalog) throws IOException {
        if (!Files.exists(katalog)) {
            return;
        }
        List<Path> odKonca;
        try (Stream<Path> sciezki = Files.walk(katalog)) {
            try {
                odKonca = sciezki.sorted(Comparator.reverseOrder()).toList();
            } catch (UncheckedIOException wyjatek) {
                throw wyjatek.getCause();
            }
        }
        for (Path sciezka : odKonca) {
            Files.deleteIfExists(sciezka);
        }
    }

    // ── PRZYKŁADY ───────────────────────────────────────────
    public static void main(String[] args) throws IOException {
        Path demo = Files.createTempDirectory("files-walk-demo-");
        try {
            Path dokumenty = Files.createDirectories(demo.resolve("dokumenty"));
            Path archiwum = Files.createDirectories(dokumenty.resolve("archiwum"));
            Path kod = Files.createDirectories(demo.resolve("kod"));
            Files.writeString(demo.resolve("README.TXT"), "Projekt w języku Java\n",
                    StandardCharsets.UTF_8);
            Files.writeString(dokumenty.resolve("raport.txt"), "Raport kwartalny\nBez błędów\n",
                    StandardCharsets.UTF_8);
            Files.writeString(archiwum.resolve("stary.txt"), "Archiwalny projekt Java\n",
                    StandardCharsets.UTF_8);
            Files.writeString(kod.resolve("Main.java"), "public class Main {}\n",
                    StandardCharsets.UTF_8);

            System.out.println("Katalog demonstracyjny: " + demo);
            System.out.println("\nPliki TXT do głębokości 2:");
            for (Path plik : znajdzPoRozszerzeniu(demo, "txt", 2)) {
                System.out.printf("  %-25s %4d B%n", demo.relativize(plik), Files.size(plik));
            }

            System.out.println("\nPliki TXT zawierające słowo Java:");
            for (Path plik : znajdzWTresci(demo, ".txt", "java")) {
                System.out.println("  " + demo.relativize(plik));
            }
        } finally {
            usunDrzewo(demo);
            System.out.println("\nUsunięto katalog demonstracyjny.");
        }
    }
}