java regex tutorial with regular expression examples
Ten samouczek dotyczący języka Java Regex wyjaśnia, czym jest wyrażenie regularne w Javie, dlaczego go potrzebujemy i jak go używać, korzystając z przykładów wyrażeń regularnych:
DO Wyrażenie regularne w Javie to jest w skrócie „ wyrażenie regularne ”Jest wyrażeniem używanym do definiowania wzorca wyszukiwania dla ciągów.
Wzorzec wyszukiwania może być prostym znakiem lub podciągiem lub może to być złożony ciąg lub wyrażenie, które definiuje określony wzorzec do przeszukania w ciągu.
Ponadto wzorzec może wymagać dopasowania jednego lub więcej razy do ciągu.
=> Odwiedź tutaj, aby zobaczyć serię szkoleń Java dla wszystkich.
Czego się nauczysz:
Wyrażenie regularne: dlaczego go potrzebujemy
Wyrażenie regularne jest używane głównie do wyszukiwania wzorca w ciągu. Dlaczego szukamy wzorca w ciągu? Możemy chcieć znaleźć określony wzorzec w ciągu, a następnie manipulować nim lub edytować.
Tak więc w aplikacji komputerowej możemy mieć ciągły wymóg manipulowania różnymi wzorami. Dlatego zawsze wymagamy wyrażenia regularnego, aby ułatwić wyszukiwanie wzorca.
Teraz mając wzorzec do wyszukania, jak dokładnie działa wyrażenie regularne?
Kiedy analizujemy i zmieniamy tekst za pomocą wyrażenia regularnego, mówimy, że „zastosowaliśmy wyrażenie regularne do ciągu lub tekstu”. To, co robimy, to nakładanie wzorca na tekst w kierunku „od lewej do prawej”, a ciąg źródłowy jest dopasowywany do wzorca.
Na przykład, rozważ ciąg „ ababababab ”. Załóżmy, że zdefiniowano wyrażenie regularne „aba”. Więc teraz musimy zastosować to wyrażenie regularne do łańcucha. Stosując wyrażenie regularne od lewej do prawej, wyrażenie regularne będzie pasowało do ciągu „ aba_aba___ ”, W dwóch miejscach.
Dlatego po użyciu znaku źródłowego w dopasowaniu nie możemy go ponownie użyć. Zatem po znalezieniu pierwszego dopasowania aba trzeci znak „a” nie został ponownie użyty.
najlepsze oprogramowanie do kopiowania DVD dla komputerów Mac
java.util.regex
Język Java nie udostępnia żadnej wbudowanej klasy dla wyrażenia regularnego. Ale możemy pracować z wyrażeniami regularnymi, importując „ java.util.regex ”Pakiet.
Pakiet java.util.regex udostępnia jeden interfejs i trzy klasy, jak pokazano poniżej:
Klasa wzoru: Klasa wzorca reprezentuje skompilowane wyrażenie regularne. Klasa Pattern nie ma żadnych publicznych konstruktorów, ale udostępnia statyczne metody compile (), które zwracają obiekty Pattern i mogą służyć do tworzenia wzorca.
Klasa dopasowująca: Obiekt klasy Matcher dopasowuje wzorzec regex do łańcucha. Podobnie jak klasa Pattern, ta klasa również nie udostępnia żadnych publicznych konstruktorów. Udostępnia metodę matcher (), która zwraca obiekt Matcher.
PatternSyntaxException: Ta klasa definiuje niesprawdzony wyjątek. Obiekt typu PatternSyntaxException zwraca niesprawdzony wyjątek wskazujący na błąd składni we wzorcu wyrażenia regularnego.
Interfejs MatchResult: Interfejs MatchResult określa wynik dopasowania wzorca wyrażenia regularnego.
Przykład Java Regex
Zaimplementujmy prosty przykład wyrażenia regularnego w Javie. W poniższym programie jako wzorzec mamy prosty ciąg, a następnie dopasowujemy go do łańcucha. Dane wyjściowe wypisują pozycję początkową i końcową w ciągu, w którym znaleziono wzorzec.
import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main { public static void main(String args()) { //define a pattern to be searched Pattern pattern = Pattern.compile('Help.'); // Search above pattern in 'softwareTestingHelp.com' Matcher m = pattern.matcher('softwareTestingHelp.com'); // print the start and end position of the pattern found while (m.find()) System.out.println('Pattern found from position ' + m.start() + ' to ' + (m.end()-1)); } } Wynik:
Wzór znaleziony od 15 do 19
Regex Matcher w Javie
Klasa matcher implementuje interfejs MatchResult. Matcher działa jak silnik wyrażeń regularnych i służy do dokładnego dopasowania sekwencji znaków.
Poniżej podano typowe metody klasy Matcher. Ma więcej metod, ale poniżej wymieniliśmy tylko ważne metody.
| Nie rób | metoda | Opis |
|---|---|---|
| 7 | int start () | Podaje początkowy indeks dopasowanego podciągu i zwraca go. |
| 1 | dopasowania logiczne () | Sprawdza, czy wyrażenie regularne pasuje do wzorca. |
| dwa | Wzór wzoru () | Zwraca wzorzec, który interpretuje dopasowujący. |
| 3 | boolean find () | Ta metoda znajduje następne wyrażenie, które ma zostać dopasowane do wzorca. |
| 4 | boolean find (int start) | To samo co find (), ale znajduje wyrażenie do dopasowania z podanej pozycji początkowej. |
| 5 | Grupa ciągów () | Zwraca podciąg pasujący do wzorca. |
| 6 | Grupa ciągów (nazwa ciągu) | Zwraca podciąg wejściowy. Jest to przechwytywane we wcześniejszej operacji dopasowania, przechwytując grupę o określonej nazwie. |
| 8 | int end () | Zwraca pozycję końcową / indeks dopasowanego podciągu. |
| 9 | int groupCount () | Zwraca całkowitą liczbę dopasowanych podciągów. |
| 10 | String replaceAll (zamiana ciągu) | Zastąp wszystkie podsekwencje sekwencji wejściowej, które pasują do wzorca, podanym ciągiem zastępującym. |
| jedenaście | String replaceFirst (wymiana ciągu) | Zastąp pierwszy pasujący podciąg sekwencji wejściowej określonym ciągiem zastępczym. |
| 12 | Ciąg toString () | Zwraca ciąg znaków reprezentujący bieżący element dopasowujący. |
Przykład implementacji wyrażenia regularnego
Zobaczmy przykład użycia niektórych z tych metod.
import java.util.regex.Matcher; import java.util.regex.Pattern; public class MatcherDemo { public static void main(String() args) { String inputString = 'She sells sea shells on the sea shore with shells'; //obtain a Pattern object Pattern pattern = Pattern.compile('shells'); // obtain a matcher object System.out.println('input string: ' + inputString); Matcher matcher = pattern.matcher(inputString); inputString = matcher.replaceFirst('pearls'); System.out.println('
replaceFirst method:' + inputString); //use replaceAll method to replace all occurrences of pattern inputString = matcher.replaceAll('pearls'); System.out.println('
replaceAll method:' + inputString); } } Wynik:
ciąg wejściowy: sprzedaje muszle na brzegu morza wraz z muszlami
replacePierwsza metoda: sprzedaje perły morskie na brzegu morza wraz z muszlami
replaceAll metoda: sprzedaje perły morskie na brzegu morza razem z perłami
Regex Pattern Class w Javie
Klasa Pattern definiuje wzorzec dla silnika wyrażeń regularnych, którego można następnie użyć w celu dopasowania do ciągu wejściowego.
W poniższej tabeli przedstawiono metody udostępniane przez często używaną klasę Pattern.
| Nie rób | metoda | Opis |
|---|---|---|
| 7 | String () split (wejście CharSequence, limit int) | Ciąg wejściowy jest dzielony na dopasowania znalezione przez podany wzorzec. |
| 1 | statyczna kompilacja wzorca (wyrażenie regularne String) | Zwraca skompilowaną reprezentację wyrażenia regularnego. |
| dwa | statyczna kompilacja wzorca (ciąg wyrażeń regularnych, flagi int) | Kompiluje podane wyrażenie regularne przy użyciu określonych flag i zwraca wzorzec. |
| 3 | Dopasowuje dopasowania (dane wejściowe CharSequence) | Zwraca dopasowanie, dopasowując sekwencję wejściową do wzorca. |
| 4 | statyczne dopasowania boolowskie (ciąg regex, wejście CharSequence) | Kompiluje podane wyrażenie regularne i dopasowuje wzorzec do podanego wejścia. |
| 5 | flagi int () | Zwraca flagi wzorca, z którym odbywa się dopasowywanie. |
| 6 | String () split (dane wejściowe CharSequence) | Ciąg wejściowy jest dzielony na dopasowania znalezione przez podany wzorzec. |
| 8 | Wzór ciągu () | Zwraca wzorzec wyrażenia regularnego. |
| 9 | statyczny cytat typu String (ciąg znaków) | Zwraca literał String (wzorzec) dla podanego ciągu znaków. |
| 10 | Ciąg toString () | Uzyskaj ciąg reprezentujący wzorzec. |
Poniższy przykład wykorzystuje niektóre z powyższych metod klasy Pattern.
import java.util.regex.*; public class Main { public static void main(String() args) { // define a REGEX String String REGEX = 'Test'; // string to be searched for given pattern String actualString = 'Welcome to SoftwareTestingHelp portal'; // generate a pattern for given regex using compile method Pattern pattern = Pattern.compile(REGEX); // set limit to 2 int limit = 2; // use split method to split the string String() array = pattern.split(actualString, limit); // print the generated array for (int i = 0; i Metoda dopasowań ciągów Regex Metodę String.Contains () widzieliśmy w naszych samouczkach dotyczących ciągów znaków. Ta metoda zwraca wartość logiczną prawda lub fałsz w zależności od tego, czy ciąg zawiera określony znak, czy nie.
Podobnie, mamy metodę „match ()”, która sprawdza, czy ciąg pasuje do wyrażenia regularnego lub regex. Jeśli ciąg pasuje do określonego wyrażenia regularnego, zwracana jest wartość true lub w przeciwnym razie zwracana jest wartość false.
Ogólna składnia metody match ():
bezpieczne narzędzie do czyszczenia rejestru dla systemu Windows 7
public boolean matches (String regex)Jeśli określone wyrażenie regularne jest nieprawidłowe, zostanie zgłoszony wyjątek „PatternSyntaxException”.
Zaimplementujmy program, który zademonstruje użycie metody match ().
public class MatchesExample{ public static void main(String args()){ String str = new String('Java Series Tutorials'); System.out.println('Input String: ' + str); //use matches () method to check if particular regex matches to the given input System.out.print('Regex: (.*)Java(.*) matches string? ' ); System.out.println(str.matches('(.*)Java(.*)')); System.out.print('Regex: (.*)Series(.*) matches string? ' ); System.out.println(str.matches('(.*)Series(.*)')); System.out.print('Regex: (.*)Series(.*) matches string? ' ); System.out.println(str.matches('(.*)String(.*)')); System.out.print('Regex: (.*)Tutorials matches string? ' ); System.out.println(str.matches('(.*)Tutorials')); } } Wynik:
Ciąg wejściowy: samouczki z serii Java
Wyrażenie regularne: (. *) Java (. *) Pasuje do ciągu? prawdziwe
Wyrażenie regularne: (. *) Seria (. *) Pasuje do ciągu? prawdziwe
Wyrażenie regularne: (. *) Seria (. *) Pasuje do ciągu? fałszywy
Wyrażenie regularne: (. *) Poradniki pasują do ciągu? prawdziwe
Używamy wielu znaków specjalnych i metaznaków w wyrażeniach regularnych w Javie. Używamy również wielu klas znaków do dopasowywania wzorców. W tej sekcji udostępnimy tabele zawierające klasy znaków, znaki Meta i kwantyfikatory, których można używać z wyrażeniem regularnym.
Klasy znaków Regex
Nie rób Klasa postaci Opis 7 (a-z && (^ m-p)) Odejmowanie: od a do z, a nie od m do p: (a-lq-z) 1 (pqr) p, q lub r dwa (^ pqr) Negacja: dowolny znak inny niż p, q lub r 3 (a-zA-Z) Zakres: od a do z lub od A do Z włącznie 4 (a-d (m-p)) Suma: od a do d lub m do p: (a-dm-p) 5 (a – z && (def)) Przecięcie: d, e lub f 6 (a – z && (^ bc)) Odejmowanie: od a do z, z wyjątkiem b i c: (ad-z)
Kwantyfikatory wyrażeń regularnych
Kwantyfikatory służą do określenia, ile razy znak wystąpi w wyrażeniu regularnym.
W poniższej tabeli przedstawiono typowe kwantyfikatory wyrażeń regularnych używane w języku Java.
Nie rób Kwantyfikator wyrażeń regularnych Opis 7 W Dowolny znak niebędący słowem, (^ w) 1 x? x pojawia się raz lub wcale dwa x + x pojawia się raz lub więcej razy 3 x * x występuje zero lub więcej razy 4 x {n} x występuje n razy 5 x {n,} x występuje n lub więcej razy 6 X i Z} x występuje co najmniej y razy, ale mniej niż z razy
Regex Meta Characters
Metaznaki w wyrażeniu regularnym działają jako kody skrócone. Kody te obejmują białe i niebiałe znaki, a także inne skróty.
W poniższej tabeli wymieniono znaki meta wyrażenia regularnego.
Nie rób Znaki meta Opis 1 . Dowolny znak (może pasować do terminatora lub nie) dwa
e Dowolne cyfry, (0–9) 3 RE Dowolna niecyfrowa, (^ 0-9) 4 s Dowolny biały znak, ( t n x0B f r) 5 S Dowolny znak niebędący białymi znakami, (^ s) 6 w Dowolny znak słowa, (a-zA-Z_0-9) 8 b Granica słów 9 B Granica bez słów
Poniżej podano program Java, który używa powyższych znaków specjalnych w Regex.
import java.util.regex.*; public class RegexExample{ public static void main(String args()){ // returns true if string exactly matches 'Jim' System.out.print('Jim (jim):' + Pattern.matches('Jim', 'jim')); // Returns true if the input string is Peter or peter System.out.println('
(Pp)eter(Peter) :' + Pattern.matches('(Pp)eter', 'Peter')); //true if string = abc System.out.println('
.*abc.*(pqabcqp) :' + Pattern.matches('.*abc.*', 'pqabcqp')); // true if string doesn't start with a digit System.out.println('
^(^\d).*(abc123):' + Pattern.matches('^(^\d).*', 'abc123')); // returns true if the string contains exact three letters System.out.println('
(a-zA-Z)(a-zA-Z)(a-zA-Z) (aQz):' + Pattern.matches('(a-zA-Z)(a-zA-Z)(a-zA-Z)', 'aQz')); System.out.println('
(a-zA-Z)(a-zA-Z)(a-zA-Z), a10z' + Pattern.matches('(a-zA-Z)(a-zA-Z)(a-zA-Z), a10z', 'a10z')); //input string length = 4 // true if the string contains 0 or more non-digits System.out.println('
\D*, abcde:' + Pattern.matches('\D*', 'abcde')); //True // true of line contains only word this ^-start of the line, $ - end of the line System.out.println('
^This$, This is Java:' + Pattern.matches('^This$', 'This is Java')); System.out.println('
^This$, This:' + Pattern.matches('^This$, This', 'This')); System.out.println('
^This$, Is This Java?:' + Pattern.matches('^This$, Is This Java?', 'Is This Java?')); } } Wynik:
Jim (jim): fałsz
(Pp) eter (Peter): prawda
. * abc. * (pqabcqp): prawda
^ (^ d). * (abc123): prawda
(a-zA-Z) (a-zA-Z) (a-zA-Z) (aQz): prawda
(a-zA-Z) (a-zA-Z) (a-zA-Z), a10zfalse
D *, abcde: prawda
^ To $, to jest Java: false
^ To $, to: fałsz
^ This $, Is This Java?: False
W powyższym programie udostępniliśmy różne wyrażenia regularne, które są dopasowywane do ciągu wejściowego. Czytelnikom zaleca się przeczytanie komentarzy w programie dla każdego wyrażenia regularnego, aby lepiej zrozumieć koncepcję.
Operator logiczny Regex lub (|)
Możemy użyć operatora logicznego lub (|) w wyrażeniu regularnym, który daje nam możliwość wyboru dowolnego operandu | operator. Możemy użyć tego operatora w wyrażeniu regularnym, aby dać wybór znaku lub ciągu. Na przykład, jeśli chcemy dopasować oba słowa, „test” i „Test”, umieścimy te słowa w logice lub operatorze jako Test | test.
Zobaczmy następujący przykład, aby zrozumieć ten operator.
import java.util.regex.Matcher; import java.util.regex.Pattern; public class RegexOR { public static void main(String() args) { // Regex string to search for patterns Test or test String regex = '(Test|test)'; // Compiles the pattern and obtains the matcher object from input string. Pattern pattern = Pattern.compile(regex); String input = 'Software Testing Help'; Matcher matcher = pattern.matcher(input); // print every match while (matcher.find()) { System.out.format('Text '%s' found at %d to %d.%n', matcher.group(), matcher.start(), matcher.end()); } //define another input string and obtain the matcher object input = 'SoftwaretestingHelp'; matcher = pattern.matcher(input); // Print every match while (matcher.find()) { System.out.format('Text '%s' found at %d to %d.%n', matcher.group(), matcher.start(), matcher.end()); } } } Wynik:
Tekst „Test” znajduje się od 9 do 13.
Tekst „test” znaleziony w przedziale od 8 do 12.
W tym programie udostępniliśmy wyrażenie regularne „(Test | test)”. Następnie najpierw podajemy ciąg wejściowy jako „Pomoc w testowaniu oprogramowania” i dopasowujemy wzorzec. Widzimy, że znaleziono dopasowanie i pozycja jest drukowana.
Następnie podajemy ciąg wejściowy jako „Pomoc testowa oprogramowania”. Tym razem znaleziono również dopasowanie. Dzieje się tak, ponieważ w wyrażeniu regularnym użyto operatora or i stąd wzorzec po obu stronach | operator jest dopasowany do łańcucha.
Walidacja adresu e-mail przy użyciu Regex
Możemy również zweryfikować identyfikator (adres) e-mail za pomocą wyrażenia regularnego przy użyciu metody java.util.regex.Pattern.matches (). Dopasowuje podany identyfikator e-mail do wyrażenia regularnego i zwraca wartość true, jeśli adres e-mail jest prawidłowy.
Poniższy program demonstruje walidację wiadomości e-mail przy użyciu wyrażenia regularnego.
public class EmailDemo { static boolean isValidemail(String email) { String regex = '^(\w-_\.+)*(\w-_\.)\@((\w)+\.)+(\w)+(\w)$'; //regex to validate email. return email.matches(regex); //match email id with regex and return the value } public static void main(String() args) { String email = 'ssthva@gmail.com'; System.out.println('The Email ID is: ' + email); System.out.println('Email ID valid? ' + isValidemail(email)); email = '@sth@gmail.com'; System.out.println('The Email ID is: ' + email); System.out.println('Email ID valid? ' + isValidemail(email)); } } Wynik:
Identyfikator e-mail to: ssthva@gmail.com
Adres e-mail jest ważny? prawdziwe
Identyfikator e-mail to: @ sth @ gmail.com
Adres e-mail jest ważny? fałszywy
Jak widać z powyższego wyniku, pierwszy identyfikator e-mail jest prawidłowy. Drugi identyfikator zaczyna się bezpośrednio od @, a zatem regex go nie sprawdza. Dlatego jest to nieprawidłowy identyfikator.
wiosenne pytania do wywiadu mvc i odpowiedzi dla doświadczonych
Często Zadawane Pytania
P 1) Co znajduje się w wyrażeniu regularnym?
Odpowiedź: DO Wyrażenie regularne potocznie nazywane regex to wzorzec lub sekwencja znaków (normalnych, specjalnych lub meta), która jest używana do walidacji ciągu wejściowego.
P # 2) Jakie znaczenie ma klasa Matcher dla wyrażeń regularnych w Javie?
Odpowiedź: Klasa dopasowująca (java.util.regex.Matcher) działa jako silnik wyrażeń regularnych. Wykonuje operacje dopasowywania poprzez interpretację wzorca.
Pytanie 3) Jaki jest wzorzec w Javie?
Odpowiedź: Pakiet java.util.regex udostępnia klasę Pattern, która jest używana do kompilowania wyrażenia regularnego do wzorca, który jest standardową reprezentacją wyrażenia regularnego. Ten wzorzec jest następnie używany do sprawdzania poprawności ciągów przez dopasowanie go do wzorca.
P # 4) Co to jest B w wyrażeniu regularnym?
Odpowiedź: B w wyrażeniu regularnym jest oznaczane jako b i jest znakiem kotwicy używanym do dopasowania pozycji zwanej granicą słowa. Początek wiersza jest oznaczony daszkiem (^), a koniec wiersza jest oznaczony znakiem dolara ($).
Pytanie 5) Czy wzorzec Java jest bezpieczna dla wątków?
Odpowiedź: Tak. Wystąpienia klasy Pattern są niezmienne i bezpieczne do użycia przez wiele współbieżnych wątków. Jednak instancje klas dopasowujących nie są bezpieczne dla wątków.
Wniosek
W tym samouczku omówiliśmy wyrażenia regularne w Javie. Wyrażenie regularne, znane również jako „regex”, służy do sprawdzania poprawności ciągu wejściowego w języku Java. Java zapewnia „ java.util.regex ” pakiet, który zapewnia klasy takie jak Pattern, Matcher itp., które pomagają zdefiniować i dopasować wzorzec do ciągu wejściowego.
Widzieliśmy również różne specjalne klasy znaków i metaznaki, których możemy użyć w wyrażeniu regularnym, które dają skrócone kody do dopasowywania wzorców. Zbadaliśmy również weryfikację wiadomości e-mail za pomocą wyrażenia regularnego.
=> Zapoznaj się z serią prostych szkoleń dotyczących języka Java.
rekomendowane lektury