java regex tutorial with regular expression examples
Aquest tutorial de Java Regex explica què és una expressió regular a Java, per què la necessitem i com utilitzar-la amb l'ajuda d'exemples d'expressió regular:
A Expressió normal a Java que s’abreuja com “ regex ”És una expressió que s’utilitza per definir un patró de cerca de cadenes.
El patró de cerca pot ser un caràcter simple o una subcadena o pot ser una cadena o una expressió complexa que defineixi un patró concret que cal cercar a la cadena.
A més, el patró pot haver de coincidir una o més vegades amb la cadena.
=> Visiteu aquí per veure la sèrie de formació de Java per a tothom
Què aprendreu:
- Expressió regular: per què ho necessitem?
- Validació del correu electrònic mitjançant Regex
- Conclusió
Expressió regular: per què ho necessitem?
Una expressió regular s'utilitza principalment per buscar un patró en una cadena. Per què cerquem un patró en una cadena? És possible que vulguem trobar un patró concret en una cadena i després manipular-lo o editar-lo.
Per tant, en una aplicació informàtica, podem tenir un requisit continu de manipular diversos patrons. Per tant, sempre necessitem l’expressió regular per facilitar la cerca del patró.
Ara, donat un patró per cercar, com funciona exactament la regla regular?
Quan analitzem i alterem el text mitjançant una expressió regular, diem que 'hem aplicat una expressió regular a la cadena o al text'. El que fem és aplicar el patró al text en una direcció d’esquerra a dreta i la cadena d’origen es fa coincidir amb el patró.
Per exemple, considera una cadena ' ababababab ”. Suposem que es defineix una regla regular 'aba'. Per tant, ara hem d'aplicar aquesta expressió regular a la cadena. Aplicant la regla regular d’esquerra a dreta, la regla coincidirà amb la cadena “ aba_aba___ ”, A dos llocs.
Així, un cop s’utilitza un caràcter font en una coincidència, no el podem tornar a utilitzar. Així, després de trobar el primer partit aba, el tercer personatge 'a' no es va tornar a utilitzar.
configuració eclipsi per a c ++
java.util.regex
El llenguatge Java no proporciona cap classe integrada per a l'expressió regular. Però podem treballar amb expressions regulars important el fitxer ' java.util.regex ”Paquet.
El paquet java.util.regex proporciona una interfície i tres classes com es mostra a continuació:
Classe de patrons: Una classe de patró representa la regla regular compilada. La classe Pattern no té cap constructor públic, però proporciona mètodes static compile () que retornen objectes Pattern i es poden utilitzar per crear un pattern.
Classe de Matcher: L'objecte de la classe Matcher fa coincidir el patró d'expressió regular amb la cadena. Igual que la classe Pattern, aquesta classe tampoc proporciona cap constructor públic. Proporciona el mètode matcher () que retorna un objecte Matcher.
PatternSyntaxException: Aquesta classe defineix una excepció sense marcar. Un objecte de tipus PatternSyntaxException retorna una excepció no marcada que indica un error de sintaxi en el patró de regla.
Interfície MatchResult: La interfície MatchResult determina el resultat de la concordança del patró regex.
Exemple de Java Regex
Implantem un exemple senzill de regex a Java. Al programa següent tenim una cadena simple com a patró i després la relacionem amb una cadena. La sortida imprimeix la posició inicial i final a la cadena on es troba el patró.
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)); } } Sortida:
Patró trobat del 15 al 19
Regex Matcher a Java
La classe Matcher implementa la interfície MatchResult. Matcher actua com a motor de regex i s’utilitza per realitzar la coincidència exacta d’una seqüència de caràcters.
A continuació es detallen els mètodes habituals de la classe Matcher. Té més mètodes, però a continuació només enumerem els mètodes importants.
| no | Mètode | Descripció |
|---|---|---|
| 7 | int start () | Ofereix l'índex inicial de la subseqüència coincident i el retorna. |
| 1 | coincidències booleanes () | Comprova si la regla regular coincideix amb el patró. |
| 2 | Patró de patró () | Retorna el patró que interpreta el coincident. |
| 3 | find booleà () | Aquest mètode troba la següent expressió que ha de coincidir amb el patró. |
| 4 | trobada booleana (int start) | Igual que find (), però troba l'expressió que ha de coincidir des de la posició d'inici donada. |
| 5 | Grup de cadenes () | Retorna la subseqüència que coincideix amb el patró. |
| 6 | Grup de cadenes (nom de la cadena) | Retorna la subseqüència d'entrada. Això es captura en l'operació de coincidència anterior capturant el grup amb el nom especificat. |
| 8 | int end () | Retorna la posició final / índex de la subseqüència coincident. |
| 9 | int groupCount () | Retorna el nombre total de subseqüències coincidents. |
| 10 | String replaceAll (reemplaçament de cadena) | Substituïu totes les subseqüències de la seqüència d'entrada que coincideixin amb el patró per una cadena de substitució donada. |
| 11 | String replaceFirst (reemplaçament de cadena) | Substituïu la primera subseqüència coincident de la seqüència d'entrada per la cadena de substitució especificada. |
| 12 | String toString () | Retorna la representació de cadena del coincident actual. |
Exemple d'implementació d'expressions regulars
Vegem un exemple de l’ús d’alguns d’aquests mètodes.
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); } } Sortida:
cadena d’entrada: ven petxines marines a la vora del mar amb petxines
replacePrimer mètode: ven perles marines a la vora del mar amb petxines
substituirTots els mètodes: ven perles marines a la vora del mar amb perles
Classe de patrons Regex a Java
La classe Patró defineix el patró per al motor de regla regular que després es pot utilitzar per coincidir amb la cadena d'entrada.
La taula següent mostra els mètodes proporcionats per la classe Pattern que s'utilitza habitualment.
| no | Mètode | Descripció |
|---|---|---|
| 7 | Cadena () dividida (entrada CharSequence, límit int) | La cadena d'entrada es divideix al voltant de les coincidències trobades per un patró determinat. |
| 1 | compilació de patrons estàtics (regex de cadena) | Retorna la representació compilada de la regla regular. |
| 2 | recopilació de patrons estàtics (regex de cadena, senyaladors int) | Compila l'expressió regular utilitzant els patrons especificats i retorna. |
| 3 | Coincidències coincidents (entrada CharSequence) | Retorna un aparellador fent coincidir la seqüència d'entrada amb el patró. |
| 4 | coincidències booleanes estàtiques (cadena regex, entrada CharSequence) | Compila la regla regular donada i fa coincidir el patró amb una entrada determinada. |
| 5 | int flags () | Retorna els indicadors del patró amb el qual es fa la coincidència. |
| 6 | Cadena () dividida (entrada CharSequence) | La cadena d'entrada es divideix al voltant de les coincidències trobades per un patró determinat. |
| 8 | Patró de cadena () | Retorna el patró d'expressió regular. |
| 9 | Cita de cadena estàtica (cadena) | Retorna una cadena literal (patró) per a la cadena donada. |
| 10 | String toString () | Obteniu la representació de cadenes del patró. |
L'exemple següent utilitza alguns dels mètodes anteriors de la classe 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 coincideix amb el mètode Hem vist el mètode String.Contains () als nostres tutorials de cadenes. Aquest mètode retorna un valor booleà cert o fals segons si la cadena conté o no un caràcter especificat.
De la mateixa manera, tenim un mètode 'matches ()' per comprovar si la cadena coincideix amb una expressió regular o una expressió regular. Si la cadena coincideix amb l'expressió regular, es retorna un valor vertader o bé es torna fals.
La sintaxi general del mètode matches ():
public boolean matches (String regex)Si l'expressió regular no és vàlida, es llança 'PatternSyntaxException'.
Implementem un programa per demostrar l’ús del mètode 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')); } } Sortida:
Cadena d'entrada: Tutorials de la sèrie Java
Regex: (. *) Java (. *) Coincideix amb la cadena? cert
Regex: (. *) Sèrie (. *) Coincideix amb la cadena? cert
Regex: (. *) Sèrie (. *) Coincideix amb la cadena? fals
Regex: (. *) Els tutorials coincideixen amb la cadena? cert
Utilitzem molts caràcters especials i metacaràcters amb expressions regulars a Java. També fem servir moltes classes de caràcters per a la concordança de patrons. En aquesta secció, proporcionarem les taules que contenen classes de caràcters, caràcters Meta i quantificadors que es poden utilitzar amb l’expressió regular.
Classes de caràcters Regex
no Classe de personatges Descripció 7 (a-z && (^ m-p)) Resta: de a a z, i no de m a p: (a-lq-z) 1 (pqr) p, q o r 2 (^ pqr) Negació: qualsevol caràcter que no sigui p, q o r 3 (a-zA-Z) Rang: de la a la z o de la A a la Z, incloses 4 (a-d (m-p)) Unió: de a a d, o de m a p: (a-dm-p) 5 (a-z && (def)) Intersecció: d, e o f 6 (a-z && (^ bc)) Resta: de la a a la z, excepte b i c: (ad-z)
Quantificadors de Regex
Els quantificadors s’utilitzen per especificar el nombre de vegades que apareixerà el caràcter a l’expressió regular.
A la taula següent es mostren els quantificadors de regex comuns utilitzats a Java.
no Quantificador de Regex Descripció 7 IN Qualsevol caràcter que no sigui de paraula, (^ w) 1 x? x apareix una vegada o no apareix del tot 2 x + x apareix una o més vegades 3 x * x es produeix zero o més vegades 4 x {n} x es produeix n vegades 5 x {n,} x es produeix n o més vegades 6 x {i, z} x es produeix com a mínim y vegades però menys de z vegades
Caràcters Meta Regex
Els caràcters metacaracterístics de la regex funcionen com a codis abreujats. Aquests codis inclouen caràcters en blanc i no blanc juntament amb altres codis curts.
A la taula següent es mostren els caràcters Meta de l’expressió regular.
char array a int c ++
no Meta Caràcters Descripció 1 . Qualsevol personatge (pot coincidir o no amb el terminador) 2 d Qualsevol dígit, (0-9) 3 D Qualsevol que no sigui de dígits, (^ 0-9) 4 s Qualsevol caràcter d'espai en blanc, ( t n x0B f r) 5 S Qualsevol caràcter que no sigui en blanc, (^ s) 6 in Qualsevol caràcter de paraula, (a-zA-Z_0-9) 8 b Un límit de paraules 9 B Un límit sense paraules
A continuació es mostra un programa Java que utilitza els caràcters especials anteriors al 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?')); } } Sortida:
Jim (jim): fals
(Pp) eter (Peter): cert
. * abc. * (pqabcqp): cert
^ (^ d). * (abc123): cert
(a-zA-Z) (a-zA-Z) (a-zA-Z) (aQz): cert
(a-zA-Z) (a-zA-Z) (a-zA-Z), a10zfalse
D *, abcde: true
^ This $, This is Java: false
^ This $, This: false
^ This $, Is This Java?: False
Al programa anterior, hem proporcionat diversos regexs que coincideixen amb la cadena d'entrada. Es recomana als lectors que llegeixin els comentaris del programa per a cada expressió regular per entendre millor el concepte.
Regex Logical o (|) Operador
Podem utilitzar el lògic o (| operador) a l’expressió regular que ens dóna l’opció de seleccionar qualsevol operant de | operador. Podem utilitzar aquest operador en una expressió regular per donar una elecció de caràcter o cadena. Per exemple, si volem coincidir amb les paraules 'prova' i 'prova', inclourem aquestes paraules en lògic o operador com a prova | prova.
Vegem l'exemple següent per entendre aquest operador.
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()); } } } Sortida:
El text 'Prova' es troba a les 9 a les 13 hores.
Text de prova que es troba a les 8 a les 12 hores.
En aquest programa, hem proporcionat l'expressió regular ('Test | test)'. A continuació, primer donem la cadena d'entrada com a 'Ajuda de proves de programari' i coincidim amb el patró. Veiem que la coincidència es troba i que s’imprimeix la posició.
A continuació, donem la cadena d'entrada com a 'SoftwaretestingHelp'. Aquesta vegada també es troba el partit. Això es deu al fet que la regió regular ha utilitzat o operat i, per tant, el patró a banda i banda de | l’operador es fa coincidir amb la cadena.
Validació del correu electrònic mitjançant Regex
També podem validar l’identificador de correu electrònic (adreça) amb l’expressió regular mitjançant el mètode java.util.regex.Pattern.matches (). Coincideix amb l'identificador de correu electrònic indicat amb l'expressió regular i torna cert si el correu electrònic és vàlid.
El programa següent demostra la validació del correu electrònic mitjançant l’expressió regular.
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)); } } Sortida:
L’identificador de correu electrònic és: ssthva@gmail.com
Identificador de correu electrònic vàlid? cert
L'identificador de correu electrònic és: @ sth @ gmail.com
Identificador de correu electrònic vàlid? fals
Com podem veure a la sortida anterior, el primer identificador de correu electrònic és vàlid. El segon identificador comença directament amb @ i, per tant, regex no el valida. Per tant, és un identificador no vàlid.
preguntes i respostes d’entrevistes a bases de dades per a persones experimentades
Preguntes freqüents
P # 1) Què hi ha en una expressió regular?
Resposta: A Expressió normal comunament anomenat regex és un patró o una seqüència de caràcters (caràcters normals o especials o Meta) que s’utilitza per validar una cadena d’entrada.
Q # 2) Quina és la importància de la classe Matcher per a una expressió regular a Java?
Resposta: La classe matcher (java.util.regex.Matcher) actua com un motor de regulació regular. Realitza les operacions de coincidència interpretant el Patró.
P # 3) Quin és el patró a Java?
Resposta: El paquet java.util.regex proporciona una classe Pattern que s'utilitza per compilar una regla regular en un patró que és la representació estàndard per a l'expressió regular. A continuació, aquest patró s’utilitza per validar les cadenes fent-lo coincidir amb el patró.
Q # 4) Què és B en una expressió regular?
Resposta: La B de l’expressió regular s’anota com b i és un caràcter d’ancoratge que s’utilitza per fer coincidir una posició anomenada límit de paraules. L’inici de la línia es denota amb un cursor (^) i el final de la línia es denota amb un signe de dòlar ($).
Q # 5) El patró és Java apte per a fils?
Resposta: Sí. Les instàncies de la classe Pattern són immutables i segures per ser utilitzades per diversos fils simultanis. Però les instàncies de la classe de coincidència no són segures per a fils.
Conclusió
En aquest tutorial, hem parlat d'expressions regulars a Java. L’expressió regular que també es coneix com a ‘regex’ s’utilitza per validar la cadena d’entrada a Java. Java proporciona el ‘ java.util.regex ' paquet que proporciona classes com Pattern, Matcher, etc. que ajuden a definir i fer coincidir el pattern amb la cadena d'entrada.
També hem vist diverses classes de caràcters especials i metacaracters que podem utilitzar a l’expressió regular que donen codis abreujats per a la concordança de patrons. També vam explorar la validació del correu electrònic mitjançant l’expressió regular.
=> Exploreu aquí la sèrie d'entrenament de Java simple.
Lectura recomanada