Wyrażenia regularne w praktyce

import java.util.ArrayList;
import java.util.Arrays;
import java.util.List;
import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.regex.PatternSyntaxException;

/**
 * Wyrażenia regularne w praktyce: Pattern, Matcher i ich pułapki — skryptyJAVA.pl
 * Zapisz jako: WyrazeniaRegularne.java
 */
public class WyrazeniaRegularne {
    // Pattern jest niezmienny i bezpieczny wątkowo; nowy Matcher tworzymy dla każdego szukania.
    private static final Pattern KOD_POCZTOWY = Pattern.compile("\\b\\d{2}-\\d{3}\\b");
    // Grupa obcy pochłania pełny obsługiwany zapis: +CC i dziewięć cyfr.
    private static final Pattern TELEFON = Pattern.compile(
            "(?<![\\d+])(?:(?<kraj>\\+48)|(?<obcy>\\+\\d{1,3}))?[\\h-]*"
                    + "(?<numer>\\d{3}(?:[\\h-]*\\d{3}){2})(?!\\d)");

    // Atext obejmuje typową niecytowaną część lokalną; domena pozostaje uproszczona do ASCII.
    private static final Pattern EMAIL = Pattern.compile(
            "(?<![\\p{L}\\p{M}\\p{N}!#$%&'*+/=?^_`{|}~.-])"
                    + "(?<lokalny>[\\p{L}\\p{M}\\p{N}!#$%&'*+/=?^_`{|}~.-]+)"
                    + "@(?<domena>[A-Za-z0-9.-]+\\.[A-Za-z]{2,})");

    private static final Pattern SLOWA_ASCII = Pattern.compile("\\w+");
    private static final Pattern SLOWA_PL = Pattern.compile("\\w+", Pattern.UNICODE_CHARACTER_CLASS);

    /** Zwraca wszystkie fragmenty pasujące do wzorca; pusta lista, gdy nic nie pasuje. */
    public static List<String> znajdzWszystkie(Pattern wzorzec, String tekst) {
        Matcher szukacz = wzorzec.matcher(tekst);
        List<String> wyniki = new ArrayList<>();
        while (szukacz.find()) {
            wyniki.add(szukacz.group());
        }
        return wyniki;
    }

    /** Normalizuje polskie telefony; rozpoznaje prefiks zapisany jako +CC przed dziewięcioma cyframi. */
    public static List<String> normalizujTelefony(String tekst) {
        Matcher szukacz = TELEFON.matcher(tekst);
        List<String> wyniki = new ArrayList<>();
        while (szukacz.find()) {
            if (szukacz.group("obcy") != null) { continue; }
            String cyfry = szukacz.group("numer").replaceAll("[\\h-]", "");
            // Grupa opcjonalna, która nie wzięła udziału w dopasowaniu, zwraca null.
            String uwaga = szukacz.group("kraj") == null ? "   (kierunkowy dopisany)" : "";
            wyniki.add("+48 " + cyfry.substring(0, 3) + " " + cyfry.substring(3, 6)
                    + " " + cyfry.substring(6) + uwaga);
        }
        return wyniki;
    }

    /** Maskuje całą lokalną część uproszczonego adresu: żaneta@firma.pl -> ***@firma.pl. */
    public static String anonimizujEmaile(String log) {
        return EMAIL.matcher(log).replaceAll("***@${domena}");
    }

    /** Podmiana dosłowna: quote unieszkodliwia wzorzec, quoteReplacement — tekst zamiennika. */
    public static String podmienDoslownie(String tekst, String szukane, String zamiennik) {
        return Pattern.compile(Pattern.quote(szukane))
                .matcher(tekst)
                .replaceAll(Matcher.quoteReplacement(zamiennik));
    }

    /** Dopasowuje wzorzec do długiego tekstu i opisuje wynik zamiast przerywać program. */
    private static String sprawdzDlugiTekst(Pattern wzorzec, String tekst) {
        long start = System.nanoTime();
        try {
            boolean pasuje = wzorzec.matcher(tekst).matches();
            return "wynik " + pasuje + " po " + (System.nanoTime() - start) / 1_000_000 + " ms";
        } catch (StackOverflowError blad) {
            // Silnik regexów schodzi w rekurencję, więc przepełnienie stosu to Error, nie wyjątek.
            return "StackOverflowError po " + (System.nanoTime() - start) / 1_000_000 + " ms";
        }
    }

    // ── PRZYKŁADY ───────────────────────────────────────────
    public static void main(String[] args) {
        String adres = "Adres: 00-950 Warszawa, magazyn 31-548 Kraków";
        System.out.println("MATCHES vs FIND");
        System.out.println("  matches na całym zdaniu: " + KOD_POCZTOWY.matcher(adres).matches());
        System.out.println("  matches na samym kodzie: " + KOD_POCZTOWY.matcher("00-950").matches());
        System.out.println("  find znalazł:            " + znajdzWszystkie(KOD_POCZTOWY, adres));

        String kontakt = "Kontakt +48 601 202 303, magazyn 512-118-990, faktura 12345678901234";
        System.out.println("GRUPY NAZWANE");
        normalizujTelefony(kontakt).forEach(numer -> System.out.println("  " + numer));
        Pattern naiwny = Pattern.compile("\\d{3}[ -]?\\d{3}[ -]?\\d{3}");
        System.out.println("  wzorzec bez strażników: " + znajdzWszystkie(naiwny, kontakt));

        System.out.println("ANONIMIZACJA W LOGU");
        System.out.println("  " + anonimizujEmaile("14:02 login żaneta.kowalska@firma.com.pl, IP 10.0.0.7"));

        System.out.println("ZNAKI SPECJALNE PO OBU STRONACH");
        String szablon = "Cena: {kwota} za sztukę";
        try {
            System.out.println(szablon.replaceAll("{kwota}", "3,50 zł"));
        } catch (PatternSyntaxException wyjatek) {
            System.out.println("  klamra we wzorcu: " + wyjatek.getClass().getSimpleName());
        }
        try {
            System.out.println(szablon.replaceAll(Pattern.quote("{kwota}"), "3,50 zł ($2 za kg)"));
        } catch (IndexOutOfBoundsException wyjatek) {
            System.out.println("  dolar w zamienniku: " + wyjatek.getMessage());
        }
        System.out.println("  " + podmienDoslownie(szablon, "{kwota}", "3,50 zł ($2 za kg)"));
        String cel = "Kopiuj do {cel}", sciezka = "C:\\dane\\raport";
        System.out.println("  backslash wprost:   " + cel.replaceAll(Pattern.quote("{cel}"), sciezka));
        System.out.println("  po quoteReplacement: " + podmienDoslownie(cel, "{cel}", sciezka));

        System.out.println("POLSKIE LITERY W \\w");
        System.out.println("  \\w+ bez flagi: " + znajdzWszystkie(SLOWA_ASCII, "Zażółć gęślą jaźń"));
        System.out.println("  \\w+ z flagą:   " + znajdzWszystkie(SLOWA_PL, "Zażółć gęślą jaźń"));
        Pattern bezUnicodeCase = Pattern.compile("łódź", Pattern.CASE_INSENSITIVE);
        Pattern zUnicodeCase = Pattern.compile("łódź", Pattern.CASE_INSENSITIVE | Pattern.UNICODE_CASE);
        System.out.println("  ŁÓDŹ bez UNICODE_CASE: " + bezUnicodeCase.matcher("ŁÓDŹ").matches());
        System.out.println("  ŁÓDŹ z UNICODE_CASE:   " + zUnicodeCase.matcher("ŁÓDŹ").matches());

        System.out.println("SPLIT I PUSTE POLA");
        System.out.println("  domyślnie: " + Arrays.toString("Anna;Jan;;Ewa;;".split(";")));
        System.out.println("  limit -1:  " + Arrays.toString("Anna;Jan;;Ewa;;".split(";", -1)));

        System.out.println("DŁUGI TEKST I REKURENCJA");
        String duzy = "ala ma kota ".repeat(4000);
        Pattern zGrupa = Pattern.compile("(\\s*\\w+)*\\s*");
        System.out.println("  (\\s*\\w+)*\\s* -> " + sprawdzDlugiTekst(zGrupa, duzy));
        System.out.println("  [\\w\\s]+      -> " + sprawdzDlugiTekst(Pattern.compile("[\\w\\s]+"), duzy));
    }
}