java regex tutorial with regular expression examples
Acest tutorial Java Regex explică ce este o expresie regulată în Java, de ce avem nevoie de ea și cum să o folosim cu ajutorul exemplelor de expresie regulată:
LA expresie uzuala în Java care este abreviat ca „ regex ”Este o expresie care este utilizată pentru a defini un model de căutare pentru șiruri.
Șablonul de căutare poate fi un caracter simplu sau un șir sau poate fi un șir sau o expresie complexă care definește un anumit șablon care trebuie căutat în șir.
Mai mult, modelul poate fi necesar să se potrivească de una sau mai multe ori cu șirul.
=> Vizitați aici pentru a vedea seria de antrenament Java pentru toți.
Ce veți învăța:
Expresie regulată: de ce avem nevoie de ea
O expresie regulată este utilizată în principal pentru a căuta un model într-un șir. De ce căutăm un model într-un șir? S-ar putea să dorim să găsim un anumit model într-un șir și apoi să îl manipulăm sau să-l edităm.
Deci, într-o aplicație pentru computer, este posibil să avem o cerință continuă de a manipula diferite tipare. Prin urmare, avem întotdeauna nevoie de regex pentru a facilita căutarea modelului.
Acum, dat un model de căutat, cum funcționează exact regexul?
Când analizăm și modificăm textul folosind o regex, spunem că „am aplicat regex șirului sau textului”. Ceea ce facem este să aplicăm modelul textului în direcția „de la stânga la dreapta”, iar șirul sursă se potrivește cu modelul.
De exemplu, ia în considerare un șir „ ababababab ”. Să presupunem că este definit un „aba” regex. Deci, acum trebuie să aplicăm această regex șirului. Aplicând regexul de la stânga la dreapta, regexul se va potrivi cu șirul „ aba_aba___ ”, În două locuri.
Astfel, odată ce un caracter sursă este utilizat într-o potrivire, nu îl putem reutiliza. Astfel, după ce a găsit primul meci aba, al treilea personaj „a” nu a fost refolosit.
cele mai bune site-uri pentru a viziona anime
java.util.regex
Limbajul Java nu oferă nicio clasă încorporată pentru regex. Dar putem lucra cu expresii regulate importând „ java.util.regex ' pachet.
Pachetul java.util.regex oferă o interfață și trei clase, după cum se arată mai jos:
Clasa modelului: O clasă de tipare reprezintă regexul compilat. Clasa Pattern nu are niciun constructor public, dar oferă metode static compile () care returnează obiecte Pattern și pot fi utilizate pentru a crea un model.
Clasa meciului: Obiectul clasei Matcher se potrivește cu modelul regex cu șirul. La fel ca clasa Pattern, această clasă nu oferă niciun constructor public. Oferă metoda matcher () care returnează un obiect Matcher.
PatternSyntaxException: Această clasă definește o excepție nebifată. Un obiect de tip PatternSyntaxException returnează o excepție necontrolată care indică o eroare de sintaxă în modelul regex.
Interfață MatchResult: Interfața MatchResult determină rezultatul potrivirii modelului regex.
Exemplu Java Regex
Să implementăm un exemplu simplu de regex în Java. În programul de mai jos avem un șir simplu ca model și apoi îl potrivim cu un șir. Ieșirea imprimă poziția de început și sfârșit în șirul în care este găsit modelul.
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)); } } Ieșire:
Model găsit de la 15 la 19
Regex Matcher în Java
Clasa Matcher implementează interfața MatchResult. Matcher acționează ca un motor regex și este folosit pentru a efectua potrivirea exactă a unei secvențe de caractere.
Mai jos sunt prezentate metodele obișnuite ale clasei Matcher. Are mai multe metode, dar am enumerat doar metodele importante de mai jos.
| Nu face | Metodă | Descriere |
|---|---|---|
| 7 | int start () | Oferă indicele de pornire al subsecvenței potrivite și îl returnează. |
| 1 | meciuri booleene () | Verifică dacă regexul se potrivește cu modelul. |
| Două | Model de model () | Returnează modelul interpretat de potrivitor. |
| 3 | boolean find () | Această metodă găsește următoarea expresie care se potrivește cu modelul. |
| 4 | găsire booleană (int start) | La fel ca find (), dar găsește expresia care trebuie potrivită din poziția de start dată. |
| 5 | Grup de șiruri () | Returnează subsecvența care se potrivește cu modelul. |
| 6 | Grup de șiruri (numele șirului) | Returnează subsecvența de intrare. Aceasta este capturată în operațiunea de potrivire anterioară prin capturarea grupului cu numele specificat. |
| 8 | intenționează() | Returnează poziția finală / indexul subsecvenței potrivite. |
| 9 | int groupCount () | Returnează numărul total de subsecvențe potrivite. |
| 10 | String replaceAll (String replacement) | Înlocuiți toate subsecvențele secvenței de intrare care se potrivesc modelului cu șirul de înlocuire dat. |
| unsprezece | String replaceFirst (String replace) | Înlocuiți prima subsecvență potrivită a secvenței de intrare cu șirul de înlocuire specificat. |
| 12 | String toString () | Returnează reprezentarea în șiruri a potrivitorului curent. |
Exemplu de implementare a expresiei regulate
Să vedem un exemplu de utilizare a unora dintre aceste metode.
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); } } Ieșire:
șir de intrare: vinde scoici de pe malul mării cu scoici
Înlocuiește prima metodă: vinde perle de mare pe malul mării cu scoici
Înlocuiește toate metodele: vinde perle de mare pe malul mării cu perle
etl tester intervievează întrebări și răspunsuri
Regex Pattern Class În Java
Clasa Pattern definește modelul pentru motorul regex care poate fi apoi folosit pentru a se potrivi cu șirul de intrare.
Următorul tabel prezintă metodele furnizate de clasa Pattern care este frecvent utilizată.
| Nu face | Metodă | Descriere |
|---|---|---|
| 7 | String () divizat (intrare CharSequence, limită int) | Șirul de intrare este împărțit în jurul potrivirilor găsite de un model dat. |
| 1 | compilație de model static (regex șir) | Returnează reprezentarea compilată a regexului. |
| Două | compilație de modele statice (regex șir, steaguri int) | Compilează regexul dat utilizând steagurile specificate și returnează modelul. |
| 3 | Meciuri meciuri (introducere CharSequence) | Returnează un potrivitor prin potrivirea secvenței de intrare cu modelul. |
| 4 | potriviri booleene statice (regex șir, intrare CharSequence) | Compilează regexul dat și se potrivește cu modelul cu o intrare dată. |
| 5 | steaguri int () | Returnează steagurile modelului cu care se face potrivirea. |
| 6 | String () split (intrare CharSequence) | Șirul de intrare este împărțit în jurul potrivirilor găsite de un model dat. |
| 8 | Șir de șir () | Returnează modelul de expresie regulată. |
| 9 | Cota statică a șirului (șiruri) | Returnează un șir literal (model) pentru șirul dat. |
| 10 | String toString () | Obțineți reprezentarea în șir a modelului. |
Exemplul de mai jos utilizează unele dintre metodele de mai sus ale clasei 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 Regex String Matches Method Am văzut metoda String.Contains () în tutorialele noastre de șiruri. Această metodă returnează o valoare booleană adevărată sau falsă, în funcție de dacă șirul conține sau nu un caracter specificat.
În mod similar, avem o metodă „matches ()” pentru a verifica dacă șirul se potrivește cu o expresie regulată sau regex. Dacă șirul se potrivește cu regexul specificat, atunci se returnează o valoare adevărată sau se returnează false.
Sintaxa generală a metodei matches ():
public boolean matches (String regex)Dacă regexul specificat nu este valid, atunci „PatternSyntaxException” este aruncat.
Să implementăm un program pentru a demonstra utilizarea metodei matches ().
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')); } } Ieșire:
Șir de intrare: Tutoriale din seria Java
Regex: (. *) Java (. *) Se potrivește cu șirul? Adevărat
Regex: (. *) Seria (. *) Se potrivește cu șirul? Adevărat
Regex: (. *) Seria (. *) Se potrivește cu șirul? fals
Regex: (. *) Tutorialele se potrivesc cu șirul? Adevărat
Folosim o mulțime de caractere speciale și metacaractere cu expresii regulate în Java. De asemenea, folosim multe clase de caractere pentru potrivirea modelelor. În această secțiune, vom furniza tabelele care conțin clase de caractere, caractere Meta și cuantificatoare care pot fi utilizate cu regex.
Clasele de caractere Regex
Nu face Clasa personajului Descriere 7 (a-z && (^ m-p)) Scădere: de la a la z, și nu de la m la p: (a-lq-z) 1 (pqr) p, q sau r Două (^ pqr) Negare: orice alt caracter decât p, q sau r 3 (a-zA-Z) Interval: de la a la z sau de la A la Z, inclusiv 4 (a-d (m-p)) Uniune: de la a până la d, sau de la m la p: (a-dm-p) 5 (a-z && (def)) Intersecție: d, e sau f 6 (a-z && (^ bc)) Scădere: de la a până la z, cu excepția lui b și c: (ad-z)
Cuantificatoare Regex
Cuantificatoarele sunt folosite pentru a specifica de câte ori va apărea caracterul în regex.
Următorul tabel prezintă cuantificatoarele regex comune utilizate în Java.
Nu face Cuantificator Regex Descriere 7 ÎN Orice caracter care nu conține cuvânt, (^ w) 1 X? x apare o dată sau deloc Două x + x apare de una sau de mai multe ori 3 X * x apare de zero sau de mai multe ori 4 x {n} x apare de n ori 5 x {n,} x apare de n sau de mai multe ori 6 X și Z} x apare de cel puțin y ori, dar mai puțin de z ori
Regex Meta Personaje
Metacaracterele din regex funcționează ca coduri de prescurtare. Aceste coduri includ caractere în spațiu alb și non-spațiu alături de alte coduri scurte.
Următorul tabel listează caracterele Meta regex.
Nu face Meta caractere Descriere 1 . Orice personaj (poate sau nu să se potrivească cu terminatorul) Două d Orice cifră, (0-9) 3 D Orice fără cifre, (^ 0-9) 4 s Orice caracter al spațiului alb, ( t n x0B f r) 5 S Orice caracter care nu este spațiu alb, (^ s) 6 în Orice caracter de cuvânt, (a-zA-Z_0-9) 8 b O limită de cuvinte 9 B O limită fără cuvinte
Mai jos este un program Java care folosește caracterele speciale de mai sus din 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?')); } } Ieșire:
Jim (jim): fals
(Pp) eter (Peter): adevărat
. * abc. * (pqabcqp): adevărat
^ (^ d). * (abc123): adevărat
(a-zA-Z) (a-zA-Z) (a-zA-Z) (aQz): adevărat
(a-zA-Z) (a-zA-Z) (a-zA-Z), a10zfalse
D *, abcde: adevărat
^ This $, This is Java: false
^ This $, This: false
^ This $, Is This Java?: False
În programul de mai sus, am furnizat diverse regexe care se potrivesc cu șirul de intrare. Cititorii sunt sfătuiți să citească comentariile din program pentru fiecare regex pentru a înțelege mai bine conceptul.
Regex Logical sau (|) Operator
Putem folosi logic sau (| operator) în regex care ne oferă posibilitatea de a selecta fie un operand al | operator. Putem folosi acest operator într-o regex pentru a da o alegere de caracter sau șir. De exemplu, dacă vrem să potrivim atât cuvintele „test”, cât și „Test”, atunci vom include aceste cuvinte în logică sau operator ca Test | test.
Să vedem următorul exemplu pentru a înțelege acest 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()); } } } Ieșire:
Textul „Test” găsit la 9-13.
Text „test” găsit la 8-12.
În acest program, am furnizat regexul „(Test | test)”. Apoi, mai întâi dăm șirul de intrare ca „Ajutor pentru testarea software-ului” și ne potrivim cu modelul. Vedem că meciul este găsit și poziția este tipărită.
Apoi, oferim șirul de intrare ca „SoftwaretestingHelp”. De data aceasta, de asemenea, meciul este găsit. Acest lucru se datorează faptului că regex a folosit sau operator și, prin urmare, modelul de pe fiecare parte a | operatorul este asortat cu șirul.
Validare e-mail folosind Regex
De asemenea, putem valida ID-ul de e-mail (adresa) cu regex folosind metoda java.util.regex.Pattern.matches (). Se potrivește cu ID-ul de e-mail dat cu regex și returnează true dacă e-mailul este valid.
Următorul program demonstrează validarea e-mailurilor folosind regex.
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)); } } Ieșire:
ID-ul de e-mail este: ssthva@gmail.com
ID de e-mail valid? Adevărat
ID-ul de e-mail este: @ sth @ gmail.com
ID de e-mail valid? fals
După cum putem vedea din rezultatul de mai sus, primul id de e-mail este valid. Al doilea id începe direct cu @ și, prin urmare, regex nu îl validează. Prin urmare, este un id nevalid.
tutorial cu seleniu pentru începători cu exemple
întrebări frecvente
Q # 1) Ce este într-o expresie regulată?
Răspuns: LA Expresie uzuala denumit în mod obișnuit regex este un model sau o secvență de caractere (normale sau speciale sau caractere Meta) care este utilizat pentru a valida un șir de intrare.
Q # 2) Care este semnificația clasei Matcher pentru o expresie regulată în Java?
Răspuns: Clasa matcher (java.util.regex.Matcher) acționează ca un motor regex. Efectuează operațiile de potrivire interpretând modelul.
Q # 3) Care este tiparul în Java?
Răspuns: Pachetul java.util.regex oferă o clasă Pattern care este utilizată pentru a compila un regex într-un pattern care este reprezentarea standard pentru regex. Acest model este apoi utilizat pentru a valida șirurile prin potrivirea acestuia cu modelul.
Q # 4) Ce este B într-o expresie regulată?
Răspuns: B din regex este notat ca b și este un caracter ancor care este folosit pentru a se potrivi cu o poziție numită limită de cuvânt. Începutul liniei este notat cu un cursor (^) iar sfârșitul liniei este notat cu un semn dolar ($).
Q # 5) Este modelul Java sigur pentru fire?
Răspuns: Da. Instanțele din clasa Pattern sunt imuabile și sigure pentru a fi utilizate de mai multe fire simultane. Dar instanțele clasei de potrivire nu sunt sigure.
Concluzie
În acest tutorial, am discutat expresii regulate în Java. Expresia regulată cunoscută și sub numele de „regex” este utilizată pentru a valida șirul de intrare în Java. Java oferă „ java.util.regex ' pachet care oferă clase precum Pattern, Matcher etc., care ajută la definirea și potrivirea modelului cu șirul de intrare.
Am văzut, de asemenea, diverse clase speciale de caractere și metacaractere pe care le putem folosi în regex, care oferă coduri de prescurtare pentru potrivirea modelelor. De asemenea, am explorat validarea e-mailurilor folosind regex.
=> Explorați aici seria de antrenament Java simplă.
Lectură recomandată