0Pricing
Java Academy · Lekcja

Wyszukiwanie i dopasowywanie

matches, find, lookingAt

Wyszukiwanie i dopasowywanie to bezpłatna lekcja Java Academy na CoddyKit. To lekcja 2 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.

Trzy sposoby stosowania wzorca

Obiekt Matcher udostępnia trzy podstawowe testy:

  • matches() wymaga dopasowania do całego wejścia.
  • lookingAt() wymaga dopasowania na początku.
  • find() wyszukuje dopasowanie w dowolnym miejscu.
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("42");
        System.out.println(m.matches());
    }
}

matches: całe wejście

matches zwraca true tylko wtedy, gdy cały napis jest zgodny ze wzorcem, tak jak gdyby był zakotwiczony na obu końcach.

import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("\\d+");
        System.out.println(p.matcher("123").matches());
        System.out.println(p.matcher("123abc").matches());
    }
}

lookingAt: dopasowanie na początku

lookingAt kończy się powodzeniem, jeśli wejście zaczyna się od dopasowania, nawet jeśli pozostała część nie pasuje.

import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("\\d+");
        System.out.println(p.matcher("123abc").lookingAt());
        System.out.println(p.matcher("abc123").lookingAt());
    }
}

find: dopasowanie w dowolnym miejscu

find przeszukuje tekst w kierunku końca, szukając następnego dopasowania. Zwraca true, jeśli od bieżącej pozycji wzwyż istnieje takie dopasowanie.

import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("\\d+");
        System.out.println(p.matcher("abc123def").find());
    }
}

Iterowanie po wszystkich dopasowaniach za pomocą find

Wywoływanie find w pętli pozwala przejść przez każde dopasowanie 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("a1bb22ccc333");
        while (m.find()) {
            System.out.println(m.group());
        }
    }
}

Pozycje dopasowania: start i end

Po pomyślnym dopasowaniu metody start() i end() zwracają zakres indeksów, a group() zwraca dopasowany tekst.

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.group() + " at [" + m.start() + "," + m.end() + ")");
        }
    }
}

Kotwice z find

Kotwice ^ i $ pozwalają metodzie find działać jak sprawdzenie początku lub końca. W tym przypadku ^\d+ dopasowuje cyfry wyłącznie na samym początku.

import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("^\\d+");
        System.out.println(p.matcher("123abc").find());
        System.out.println(p.matcher("abc123").find());
    }
}

Resetowanie obiektu Matcher

reset() przewija obiekt Matcher na początek, dzięki czemu można ponownie przeszukać te same dane wejściowe.

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

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("a").matcher("aaa");
        int first = 0;
        while (m.find()) first++;
        m.reset();
        int second = 0;
        while (m.find()) second++;
        System.out.println(first + " " + second);
    }
}

Ponowne użycie obiektu Matcher dla nowych danych wejściowych

reset(newInput) pozwala użyć tego samego obiektu Matcher z innym napisem, unikając tworzenia nowego obiektu.

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("abc");
        m.reset("xyz789");
        System.out.println(m.find());
        System.out.println(m.group());
    }
}

Podsumowanie matches i find

Wyboru należy dokonać zgodnie z zamiarem: proszę używać matches do sprawdzania całej wartości (na przykład całego identyfikatora), a find do wyodrębniania lub lokalizowania fragmentów w większym tekście.

import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        Pattern id = Pattern.compile("[A-Z]{2}\\d{4}");
        System.out.println(id.matcher("AB1234").matches());
        System.out.println(id.matcher("id=AB1234;").find());
    }
}

Zliczanie dopasowań

Typowym zadaniem jest zliczanie wystąpień. Proszę wywoływać find w pętli i zwiększać licznik.

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

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("o").matcher("foo boo zoo");
        int count = 0;
        while (m.find()) count++;
        System.out.println(count);
    }
}

Szybkie sprawdzenie

Która metoda wymaga dopasowania całego napisu wejściowego do wzorca?

Podsumowanie

Zlokalizowano dopasowania:

  • matches sprawdza całe wejście, lookingAt sprawdza początek, a find wyszukuje w dowolnym miejscu.
  • Proszę użyć find w pętli, aby przejść przez wszystkie dopasowania, i odczytywać wartości za pomocą group, start oraz end.
  • reset przewija obiekt Matcher na początek, a reset(input) pozwala użyć go ponownie z nowym tekstem.

Często zadawane pytania

Czy lekcja „Wyszukiwanie i dopasowywanie” jest bezpłatna?

Tak — pełny tekst „Wyszukiwanie i dopasowywanie” 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 „Wyszukiwanie i dopasowywanie”?

matches, find, lookingAt Ć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 2 z 4.

Ile czasu zajmuje lekcja „Wyszukiwanie i dopasowywanie”?

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