0Pricing
Java Academy · Lekcja

Grupy przechwytujące

Wyodrębnianie dopasowanych podciągów

Grupy przechwytujące to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 3 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.

Czym są grupy przechwytujące

Nawiasy ( ) w regexie tworzą grupy przechwytujące. Po dopasowaniu można osobno wyodrębnić tekst każdej grupy, co doskonale sprawdza się podczas analizowania danych o strukturze.

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("(\\d+)-(\\d+)").matcher("42-99");
        if (m.find()) {
            System.out.println(m.group(1));
            System.out.println(m.group(2));
        }
    }
}

Grupa 0 to całe dopasowanie

group(0) (lub group()) zwraca cały dopasowany tekst. Numerowane grupy zaczynają się od 1.

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("(\\d+)px").matcher("width: 24px");
        if (m.find()) {
            System.out.println(m.group(0));
            System.out.println(m.group(1));
        }
    }
}

Zliczanie grup

groupCount() zwraca liczbę grup przechwytujących we wzorcu (bez uwzględniania grupy 0).

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("(\\d{4})-(\\d{2})-(\\d{2})").matcher("2026-05-30");
        if (m.find()) System.out.println(m.groupCount());
    }
}

Analizowanie daty

Grupy przechwytujące ułatwiają podzielenie sformatowanej wartości na części.

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("(\\d{4})-(\\d{2})-(\\d{2})").matcher("2026-05-30");
        if (m.matches()) {
            System.out.println("year=" + m.group(1));
            System.out.println("month=" + m.group(2));
            System.out.println("day=" + m.group(3));
        }
    }
}

Grupy nazwane

Grupę można nazwać za pomocą (?<name>...) i pobierać ją po nazwie. Dzięki temu wzorce są znacznie czytelniejsze.

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class Main {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("(?<user>\\w+)@(?<host>\\w+\\.\\w+)");
        Matcher m = p.matcher("alice@example.com");
        if (m.find()) {
            System.out.println(m.group("user"));
            System.out.println(m.group("host"));
        }
    }
}

Granice grup

start(n) i end(n) zwracają zakres indeksów określonej grupy w danych wejściowych.

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("(\\d+)").matcher("abc123");
        if (m.find()) {
            System.out.println(m.start(1) + " to " + m.end(1));
        }
    }
}

Grupy nieprzechwytujące

Proszę użyć (?:...), aby grupować elementy na potrzeby alternatywy lub kwantyfikatorów, bez tworzenia przechwytywania numerowanego. Dzięki temu numery grup zachowują znaczenie.

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("(?:Mr|Ms)\\.? (\\w+)").matcher("Ms. Smith");
        if (m.find()) System.out.println(m.group(1));
    }
}

Grupy opcjonalne mogą mieć wartość null

Jeśli grupa jest opcjonalna i nie uczestniczyła w dopasowaniu, group(n) zwraca null. Należy zawsze obsłużyć ten przypadek.

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("(\\d+)(px)?").matcher("50");
        if (m.matches()) {
            System.out.println(m.group(1));
            System.out.println(m.group(2));
        }
    }
}

Iterowanie po dopasowaniach z grupami

Połączenie metody find używanej w pętli z wyodrębnianiem grup pozwala pobierać uporządkowane tokeny z większego tekstu.

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("(\\w+)=(\\d+)").matcher("a=1 b=2 c=3");
        while (m.find()) {
            System.out.println(m.group(1) + " -> " + m.group(2));
        }
    }
}

Odwołania wsteczne we wzorcu

W regexie \1 dopasowuje ten sam tekst, który przechwyciła wcześniejsza grupa. Pozwala to wykrywać powtórzenia, na przykład powtórzone słowo.

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("(\\w+) \\1").matcher("the the cat");
        System.out.println(m.find());
        System.out.println(m.group(1));
    }
}

Przechwytywanie do rekordów

Przejrzysty schemat wygląda następująco: dopasować tekst, wyodrębnić grupy i zbudować mały obiekt. W tym przypadku używamy rekordu.

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class Main {
    record Point(int x, int y) {}

    public static void main(String[] args) {
        Matcher m = Pattern.compile("\\((\\d+),(\\d+)\\)").matcher("(3,7)");
        if (m.matches()) {
            Point p = new Point(Integer.parseInt(m.group(1)), Integer.parseInt(m.group(2)));
            System.out.println(p);
        }
    }
}

Szybkie sprawdzenie

Co zwraca group(0) po pomyślnym dopasowaniu?

Podsumowanie

Wyodrębniono dopasowane podnapisy:

  • Nawiasy tworzą grupy numerowane; group(0) oznacza całe dopasowanie, a grupy od 1 wzwyż są przechwytywane.
  • (?<name>...) tworzy grupy nazwane, odczytywane za pomocą group("name").
  • (?:...) grupuje elementy bez przechwytywania.
  • Grupy opcjonalne mogą mieć wartość null; \1 odwołuje się wstecz do wcześniejszej grupy.

Często zadawane pytania

Czy lekcja „Grupy przechwytujące” jest bezpłatna?

Tak — pełny tekst „Grupy przechwytujące” 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 „Grupy przechwytujące”?

Wyodrębnianie dopasowanych podciągów Ć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 3 z 4.

Ile czasu zajmuje lekcja „Grupy przechwytujące”?

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. Kompilowanie wzorców
  2. Wyszukiwanie i dopasowywanie
  3. Grupy przechwytujące
  4. Zastępowanie za pomocą wyrażeń regularnych
← Powrót do Java Academy