The Wyrażenie regularne Java lub Wyrażenie regularne to interfejs API do zdefiniuj wzorzec wyszukiwania lub manipulowania ciągami znaków .
Jest szeroko stosowany do definiowania ograniczeń dotyczących ciągów znaków, takich jak sprawdzanie poprawności hasła i adresu e-mail. Po zapoznaniu się z samouczkiem dotyczącym wyrażeń regularnych w języku Java będziesz mógł testować wyrażenia regularne za pomocą narzędzia Java Regex Tester Tool.
Java Regex API zapewnia 1 interfejs i 3 klasy java.util.regex pakiet.
pakiet java.util.regex
Klasy Matcher i Pattern udostępniają funkcję wyrażeń regularnych Java. Pakiet java.util.regex udostępnia następujące klasy i interfejsy dla wyrażeń regularnych.
- Interfejs MatchResult
- Klasa Matchera
- Klasa wzorcowa
- Klasa PatternSyntaxException
Klasa Matchera
Implementuje Wynik meczu interfejs. To jest silnik regex który służy do wykonywania operacji dopasowania na sekwencji znaków.
| NIE. | metoda | Opis |
|---|---|---|
| 1 | dopasowania logiczne() | sprawdź, czy wyrażenie regularne pasuje do wzorca. |
| 2 | znalezienie wartości logicznej() | znajduje następne wyrażenie pasujące do wzorca. |
| 3 | znalezienie wartości logicznej (int start) | znajduje następne wyrażenie pasujące do wzorca z podanego numeru początkowego. |
| 4 | grupa ciągów() | zwraca dopasowany podciąg. |
| 5 | int początek() | zwraca indeks początkowy dopasowanego podciągu. |
| 6 | zamierzać() | zwraca indeks końcowy dopasowanego podciągu. |
| 7 | int grupaCount() | zwraca całkowitą liczbę dopasowanego podciągu. |
Klasa wzorcowa
To jest skompilowana wersja wyrażenia regularnego . Służy do definiowania wzorca dla silnika regex.
| NIE. | metoda | Opis |
|---|---|---|
| 1 | Kompilacja wzorca statycznego (wyrażenie regularne) | kompiluje podane wyrażenie regularne i zwraca instancję wzorca. |
| 2 | Dopasowujący element dopasowujący (wejście CharSequence) | tworzy element dopasowujący, który dopasowuje dane wejściowe do wzorca. |
| 3 | statyczne dopasowania logiczne (wyrażenie regularne, wejście CharSequence) | Działa jako kombinacja metod kompilacji i dopasowywania. Kompiluje wyrażenie regularne i dopasowuje podane dane wejściowe do wzorca. |
| 4 | Rozdzielenie ciągu [] (wejście CharSequence) | dzieli dany ciąg wejściowy wokół dopasowań danego wzorca. |
| 5 | Wzór ciągu() | zwraca wzór wyrażenia regularnego. |
Przykład wyrażeń regularnych Java
Istnieją trzy sposoby napisania przykładowego wyrażenia regularnego w Javie.
import java.util.regex.*; public class RegexExample1{ public static void main(String args[]){ //1st way Pattern p = Pattern.compile('.s');//. represents single character Matcher m = p.matcher('as'); boolean b = m.matches(); //2nd way boolean b2=Pattern.compile('.s').matcher('as').matches(); //3rd way boolean b3 = Pattern.matches('.s', 'as'); System.out.println(b+' '+b2+' '+b3); }} Przetestuj teraz Wyjście
true true true
Wyrażenie regularne . Przykład
. (kropka) oznacza pojedynczy znak.
import java.util.regex.*; class RegexExample2{ public static void main(String args[]){ System.out.println(Pattern.matches('.s', 'as'));//true (2nd char is s) System.out.println(Pattern.matches('.s', 'mk'));//false (2nd char is not s) System.out.println(Pattern.matches('.s', 'mst'));//false (has more than 2 char) System.out.println(Pattern.matches('.s', 'amms'));//false (has more than 2 char) System.out.println(Pattern.matches('..s', 'mas'));//true (3rd char is s) }} Przetestuj teraz Klasy znaków Regex
| NIE. | Klasa postaci | Opis |
|---|---|---|
| 1 | [ABC] | a, b lub c (prosta klasa) |
| 2 | [^abc] | Dowolny znak z wyjątkiem a, b lub c (negacja) |
| 3 | [a-zA-Z] | od a do z lub od A do Z włącznie (zakres) |
| 4 | [a-d[m-p]] | a do d lub m do p: [a-dm-p] (unia) |
| 5 | [a-z&&[def]] | d, e lub f (przecięcie) |
| 6 | [a-z&&[^bc]] | od a do z, z wyjątkiem b i c: [ad-z] (odejmowanie) |
| 7 | [a-z&&[^m-p]] | a do z, a nie m do p: [a-lq-z] (odejmowanie) |
Wyrażenie regularne Klasy znaków Przykład
import java.util.regex.*; class RegexExample3{ public static void main(String args[]){ System.out.println(Pattern.matches('[amn]', 'abcd'));//false (not a or m or n) System.out.println(Pattern.matches('[amn]', 'a'));//true (among a or m or n) System.out.println(Pattern.matches('[amn]', 'ammmna'));//false (m and a comes more than once) }} Przetestuj teraz Kwantyfikatory wyrażeń regularnych
Kwantyfikatory określają liczbę wystąpień znaku.
| Wyrażenie regularne | Opis |
|---|---|
| X? | X występuje raz lub wcale |
| X+ | X występuje raz lub więcej razy |
| X* | X występuje zero lub więcej razy |
| X{n} | X występuje tylko n razy |
| X{n,} | X występuje n lub więcej razy |
| X{y,z} | X występuje co najmniej y razy, ale rzadziej niż z razy |
Klasy znaków wyrażeń regularnych i przykład kwantyfikatorów
import java.util.regex.*; class RegexExample4{ public static void main(String args[]){ System.out.println('? quantifier ....'); System.out.println(Pattern.matches('[amn]?', 'a'));//true (a or m or n comes one time) System.out.println(Pattern.matches('[amn]?', 'aaa'));//false (a comes more than one time) System.out.println(Pattern.matches('[amn]?', 'aammmnn'));//false (a m and n comes more than one time) System.out.println(Pattern.matches('[amn]?', 'aazzta'));//false (a comes more than one time) System.out.println(Pattern.matches('[amn]?', 'am'));//false (a or m or n must come one time) System.out.println('+ quantifier ....'); System.out.println(Pattern.matches('[amn]+', 'a'));//true (a or m or n once or more times) System.out.println(Pattern.matches('[amn]+', 'aaa'));//true (a comes more than one time) System.out.println(Pattern.matches('[amn]+', 'aammmnn'));//true (a or m or n comes more than once) System.out.println(Pattern.matches('[amn]+', 'aazzta'));//false (z and t are not matching pattern) System.out.println('* quantifier ....'); System.out.println(Pattern.matches('[amn]*', 'ammmna'));//true (a or m or n may come zero or more times) }} Przetestuj teraz Metaznaki wyrażeń regularnych
Metaznaki wyrażeń regularnych działają jak krótkie kody.
| Wyrażenie regularne | Opis |
|---|---|
| . | Dowolny znak (może pasować do terminatora lub nie) |
| D | Dowolne cyfry, z wyjątkiem [0-9] |
| D | Dowolna liczba niecyfrowa, skrót od [^0-9] |
| S | Dowolny biały znak, skrót od [ x0Bf ] |
| S | Dowolny znak inny niż spacja, skrót od [^s] |
| w | Dowolny znak słowa, skrót od [a-zA-Z_0-9] |
| W | Dowolny znak inny niż słowo, skrót od [^w] |
| B | Granica słowa |
| B | Granica niesłowa |
Przykład metaznaków wyrażeń regularnych
import java.util.regex.*; class RegexExample5{ public static void main(String args[]){ System.out.println('metacharacters d....');\d means digit System.out.println(Pattern.matches('\d', 'abc'));//false (non-digit) System.out.println(Pattern.matches('\d', '1'));//true (digit and comes once) System.out.println(Pattern.matches('\d', '4443'));//false (digit but comes more than once) System.out.println(Pattern.matches('\d', '323abc'));//false (digit and char) System.out.println('metacharacters D....');\D means non-digit System.out.println(Pattern.matches('\D', 'abc'));//false (non-digit but comes more than once) System.out.println(Pattern.matches('\D', '1'));//false (digit) System.out.println(Pattern.matches('\D', '4443'));//false (digit) System.out.println(Pattern.matches('\D', '323abc'));//false (digit and char) System.out.println(Pattern.matches('\D', 'm'));//true (non-digit and comes once) System.out.println('metacharacters D with quantifier....'); System.out.println(Pattern.matches('\D*', 'mak'));//true (non-digit and may come 0 or more times) }} Przetestuj teraz Wyrażenie regularne Pytanie 1
/*Create a regular expression that accepts alphanumeric characters only. Its length must be six characters long only.*/ import java.util.regex.*; class RegexExample6{ public static void main(String args[]){ System.out.println(Pattern.matches('[a-zA-Z0-9]{6}', 'arun32'));//true System.out.println(Pattern.matches('[a-zA-Z0-9]{6}', 'kkvarun32'));//false (more than 6 char) System.out.println(Pattern.matches('[a-zA-Z0-9]{6}', 'JA2Uk2'));//true System.out.println(Pattern.matches('[a-zA-Z0-9]{6}', 'arun$2'));//false ($ is not matched) }} Przetestuj teraz
Wyrażenie regularne Pytanie 2
/*Create a regular expression that accepts 10 digit numeric characters starting with 7, 8 or 9 only.*/ import java.util.regex.*; class RegexExample7{ public static void main(String args[]){ System.out.println('by character classes and quantifiers ...'); System.out.println(Pattern.matches('[789]{1}[0-9]{9}', '9953038949'));//true System.out.println(Pattern.matches('[789][0-9]{9}', '9953038949'));//true System.out.println(Pattern.matches('[789][0-9]{9}', '99530389490'));//false (11 characters) System.out.println(Pattern.matches('[789][0-9]{9}', '6953038949'));//false (starts from 6) System.out.println(Pattern.matches('[789][0-9]{9}', '8853038949'));//true System.out.println('by metacharacters ...'); System.out.println(Pattern.matches('[789]{1}\d{9}', '8853038949'));//true System.out.println(Pattern.matches('[789]{1}\d{9}', '3853038949'));//false (starts from 3) }} Przetestuj teraz Przykład wyszukiwarki wyrażeń regularnych w Javie
import java.util.regex.Pattern; import java.util.Scanner; import java.util.regex.Matcher; public class RegexExample8{ public static void main(String[] args){ Scanner sc=new Scanner(System.in); while (true) { System.out.println('Enter regex pattern:'); Pattern pattern = Pattern.compile(sc.nextLine()); System.out.println('Enter text:'); Matcher matcher = pattern.matcher(sc.nextLine()); boolean found = false; while (matcher.find()) { System.out.println('I found the text '+matcher.group()+' starting at index '+ matcher.start()+' and ending at index '+matcher.end()); found = true; } if(!found){ System.out.println('No match found.'); } } } } Wyjście:
Enter regex pattern: java Enter text: this is java, do you know java I found the text java starting at index 8 and ending at index 12 I found the text java starting at index 26 and ending at index 30