0Pricing
Java Academy · Lekcja

Wyrażenia regularne z Pattern i Matcher

Waliduj adresy e-mail, wyodrębniaj podłańcuchy i zastępuj wzorce za pomocą wyrażeń regularnych Javy.

Wyrażenia regularne z Pattern i Matcher to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 4 z 4. Możesz przeczytać całą lekcję poniżej za darmo — a potem ćwiczyć ją interaktywnie w przeglądarce z wbudowanym edytorem kodu i tutorem AI dostępnym 24/7. To część ścieżki edukacyjnej Java Academy, a Twój postęp synchronizuje się między webem a aplikacją CoddyKit. Kurs Java Academy zawiera 4 lekcji w sumie.

Wyrażenia regularne z Pattern i Matcher

Pakiet Javy java.util.regex udostępnia klasy Pattern i Matcher do zaawansowanego wyszukiwania, sprawdzania poprawności, wyodrębniania i zastępowania tekstu.

Dlaczego wyrażenia regularne

Wyrażenia regularne (regex) to wzorce służące do dopasowywania tekstu. W Javie używa się ich do sprawdzania poprawności adresów e-mail i numerów telefonów, wyodrębniania danych z logów oraz analizowania tekstu o ustrukturyzowanej formie.

import java.util.regex.*;

// Is this a valid email?
String email = "alice@example.com";
boolean valid = email.matches("[a-zA-Z0-9._%+\\-]+@[a-zA-Z0-9.\\-]+\\.[a-zA-Z]{2,}");
System.out.println(valid); // true

// Extract version numbers from a string
String log = "App v1.2.3 deployed; api v2.0.0 started";
Pattern p = Pattern.compile("v(\\d+\\.\\d+\\.\\d+)");
Matcher m = p.matcher(log);
while (m.find()) System.out.println(m.group(1));
// 1.2.3 
// 2.0.0

Podstawy składni regex

Najważniejsze metaznaki regex:

  • . — dowolny znak
  • \d — cyfra; \w — znak słowa; \s — biały znak
  • * — 0 lub więcej; + — 1 lub więcej; ? — 0 lub 1
  • {n,m} — od n do m razy
  • ^/$ — początek/koniec wiersza
  • [abc] — klasa znaków
// In Java strings, backslash must be doubled: \d = "\\d"
Pattern digit   = Pattern.compile("\\d+");      // one or more digits
Pattern word    = Pattern.compile("\\w{3,20}");  // 3-20 word chars
Pattern space   = Pattern.compile("\\s+");       // whitespace
Pattern phone   = Pattern.compile("\\d{3}-\\d{3}-\\d{4}"); // 555-867-5309

System.out.println(digit.matcher("42").matches());       // true
System.out.println(phone.matcher("555-867-5309").matches()); // true

Pattern.compile i Matcher

Należy skompilować wzorzec raz i ponownie używać obiektu Matcher dla wielu danych wejściowych — jest to wydajniejsze niż używanie String.matches() przy wielokrotnym sprawdzaniu poprawności.

import java.util.regex.*;

Pattern emailPattern = Pattern.compile(
    "^[a-zA-Z0-9._%+\\-]+@[a-zA-Z0-9.\\-]+\\.[a-zA-Z]{2,6}$"
);

String[] emails = {"alice@example.com", "bad@", "test.user@co.uk", "no-at-sign"};
for (String e : emails) {
    Matcher m = emailPattern.matcher(e);
    System.out.println(e + " -> " + (m.matches() ? "valid" : "invalid"));
}

find() a matches()

matches() sprawdza cały łańcuch znaków. find() wyszukuje następne wystąpienie w łańcuchu. Do wyszukiwania należy używać find, a do pełnego sprawdzania poprawności — matches.

import java.util.regex.*;

Pattern price = Pattern.compile("\\d+\\.\\d{2}");

String invoice = "Total: 129.99, Tax: 10.40, Shipping: 5.00";
Matcher m = invoice.matcher(invoice);

// find() locates all matches
while (m.find()) {
    System.out.println("Found: " + m.group() + " at " + m.start());
}
// Found: 129.99 at 7
// Found: 10.40 at 20
// Found: 5.00 at 34

Grupy przechwytujące

Nawiasy tworzą grupy przechwytujące. Za pomocą group(n) można wyodrębniać dopasowane podłańcuchy.

import java.util.regex.*;

Pattern date = Pattern.compile("(\\d{4})-(\\d{2})-(\\d{2})");
Matcher m = date.matcher("Deployed on 2024-06-15 and 2024-07-01");

while (m.find()) {
    String year  = m.group(1);
    String month = m.group(2);
    String day   = m.group(3);
    System.out.println(year + "/" + month + "/" + day);
}
// 2024/06/15
// 2024/07/01

Grupy nazwane

Grupy nazwane (?<name>...) sprawiają, że grupy przechwytujące są czytelniejsze i można uzyskiwać do nich dostęp po nazwie.

import java.util.regex.*;

Pattern log = Pattern.compile(
    "(?<timestamp>\\d{4}-\\d{2}-\\d{2}) (?<level>[A-Z]+) (?<message>.+)"
);

String line = "2024-06-15 ERROR Database connection failed";
Matcher m = log.matcher(line);

if (m.matches()) {
    System.out.println("Time: "    + m.group("timestamp"));
    System.out.println("Level: "   + m.group("level"));
    System.out.println("Message: " + m.group("message"));
}
// Time: 2024-06-15
// Level: ERROR
// Message: Database connection failed

replaceAll i replaceFirst

Zastępowanie na podstawie wzorca: wszystkich wystąpień albo tylko pierwszego.

import java.util.regex.*;

String text = "Call us at 123-456-7890 or 098-765-4321";

// Mask phone numbers for privacy logs
String masked = text.replaceAll("\\d{3}-\\d{3}-\\d{4}", "XXX-XXX-XXXX");
System.out.println(masked);
// Call us at XXX-XXX-XXXX or XXX-XXX-XXXX

// Replace multiple whitespace with single space
String cleaned = "too   many   spaces".replaceAll("\\s+", " ");
System.out.println(cleaned); // too many spaces

split() z wyrażeniami regularnymi

String.split() przyjmuje wyrażenie regularne. Należy używać go do dzielenia tekstu według wielu separatorów lub złożonych separatorów.

// Split on comma with optional spaces
String csv = "Alice, Bob,  Charlie,Diana";
String[] names = csv.split("\\s*,\\s*");
for (String name : names) System.out.println("'" + name + "'");
// 'Alice' 'Bob' 'Charlie' 'Diana'

// Split on any whitespace
String words = "one  two\tthree  four";
String[] parts = words.split("\\s+");
System.out.println(parts.length); // 4

// Limit splits
String line = "key=value=extra";
String[] kv = line.split("=", 2); // [key, value=extra]

Flagi Pattern

Flagi modyfikują działanie regex: CASE_INSENSITIVE, MULTILINE, DOTALL.

import java.util.regex.*;

// Case-insensitive match
Pattern p = Pattern.compile("hello", Pattern.CASE_INSENSITIVE);
System.out.println(p.matcher("HELLO World").find()); // true

// MULTILINE: ^ and $ match line boundaries
Pattern multi = Pattern.compile("^ERROR", Pattern.MULTILINE);
String logs = "INFO start\nERROR crash\nINFO end";
Matcher m = multi.matcher(logs);
int count = 0;
while (m.find()) count++;
System.out.println("ERROR lines: " + count); // 1

Praktyczny przykład: analizator logów

Analizowanie wierszy logów dostępu w stylu Apache za pomocą nazwanych grup.

import java.util.regex.*;

Pattern accessLog = Pattern.compile(
    "(?<ip>[\\d.]+) - - \\[(?<time>[^\\]]+)\\] " +
    "\"(?<method>[A-Z]+) (?<path>[^ ]+)[^\"]*\" " +
    "(?<status>\\d{3}) (?<bytes>\\d+)"
);

String line = "192.168.1.1 - - [27/May/2024:10:30:00 +0000] \"GET /api/products HTTP/1.1\" 200 1024";
Matcher m = accessLog.matcher(line);
if (m.matches()) {
    System.out.println("IP: "     + m.group("ip"));
    System.out.println("Method: " + m.group("method"));
    System.out.println("Status: " + m.group("status"));
}

Szybkie sprawdzenie

Jaka jest różnica między matches() a find() w Matcher?

Podsumowanie: wyrażenia regularne z Pattern i Matcher

Najważniejsze informacje:

  • Pattern.compile() kompiluje regex, a Matcher sprawdza go względem łańcuchów znaków
  • matches() sprawdza cały łańcuch znaków, a find() wyszukuje wystąpienia
  • Grupy przechwytujące () wyodrębniają podłańcuchy; dostęp do nich uzyskuje się za pomocą group(n) lub group("name")
  • Grupy nazwane (?<name>...) zwiększają czytelność wzorców
  • replaceAll() i split() przyjmują wzorce regex, umożliwiając elastyczne przetwarzanie tekstu
  • Flagi Pattern.CASE_INSENSITIVE, MULTILINE i DOTALL służą do modyfikowania działania dopasowywania

Często zadawane pytania

Czy lekcja „Wyrażenia regularne z Pattern i Matcher” jest bezpłatna?

Tak — pełny tekst „Wyrażenia regularne z Pattern i Matcher” jest dostępny za darmo tutaj w sieci. Aby ćwiczyć ją interaktywnie (wbudowany edytor kodu i tutor AI dostępny 24/7) i odblokować resztę kursu Java Academy, przejdź na CoddyKit PRO. Kurs Java Academy zawiera 4 lekcji w sumie.

Co nauczysz się w „Wyrażenia regularne z Pattern i Matcher”?

Waliduj adresy e-mail, wyodrębniaj podłańcuchy i zastępuj wzorce za pomocą wyrażeń regularnych Javy. Ćwiczysz Java Academy z praktycznym kodem, który uruchamiasz bezpośrednio w przeglądarce, a tutor AI dostępny 24/7 odpowiada na Twoje pytania podczas pracy nad lekcją.

Czy potrzebuję doświadczenia, aby zacząć Java Academy?

Nie wymagamy żadnego doświadczenia. Java Academy w CoddyKit jest strukturyzowany dla początkujących i zaawansowanych użytkowników, więc możesz zacząć tutaj lub od początku i uczyć się w swoim tempie. To lekcja 4 z 4.

Ile czasu zajmuje lekcja „Wyrażenia regularne z Pattern i Matcher”?

Większość lekcji CoddyKit trwa około 5–10 minut. Każda lekcja to mały, interaktywny krok, dzięki czemu robisz systematyczne postępy i zawsze wracasz dokładnie do tego samego miejsca — na webie i w aplikacji.

Czy mogę pisać i uruchamiać kod w tej lekcji Java Academy?

Tak. Każda lekcja Java Academy zawiera wbudowany edytor kodu, więc piszesz i uruchamiasz prawdziwy kod bezpośrednio w przeglądarce i od razu otrzymujesz sprzężenie zwrotne od AI — bez konfiguracji na komputerze.

Wszystkie lekcje w tym kursie

  1. Niezmienność String i pula stringów
  2. StringBuilder do wydajnego łączenia
  3. Bloki tekstowe i String.format
  4. Wyrażenia regularne z Pattern i Matcher
← Powrót do Java Academy