java regex tutorial with regular expression examples
Questo tutorial Java Regex spiega cos'è un'espressione regolare in Java, perché ne abbiamo bisogno e come usarla con l'aiuto di esempi di espressioni regolari:
PER espressione regolare in Java che è abbreviato come ' regex 'È un'espressione utilizzata per definire un modello di ricerca per le stringhe.
Il modello di ricerca può essere un semplice carattere o una sottostringa oppure può essere una stringa o un'espressione complessa che definisce un particolare modello da cercare nella stringa.
Inoltre, il modello potrebbe dover corrispondere una o più volte alla stringa.
=> Visita qui per vedere la serie di formazione Java per tutti.
Cosa imparerai:
Espressione regolare: perché ne abbiamo bisogno
Un'espressione regolare viene utilizzata principalmente per cercare un modello in una stringa. Perché cerchiamo uno schema in una stringa? Potremmo voler trovare un particolare pattern in una stringa e poi manipolarlo o modificarlo.
Quindi, in un'applicazione per computer, potremmo avere la necessità continua di manipolare vari modelli. Quindi, abbiamo sempre bisogno di regex per facilitare la ricerca del pattern.
Ora dato uno schema da cercare, come funziona esattamente la regex?
Quando analizziamo e alteriamo il testo utilizzando una regex, diciamo che 'abbiamo applicato regex alla stringa o al testo'. Quello che facciamo è applicare il pattern al testo in una direzione 'da sinistra a destra' e la stringa di origine viene abbinata al pattern.
Per esempio, considera una stringa ' ababababab '. Supponiamo che sia definita un'espressione regolare 'aba'. Quindi ora dobbiamo applicare questa regex alla stringa. Applicando la regex da sinistra a destra, la regex corrisponderà alla stringa ' aba_aba___ ', In due punti.
Pertanto, una volta che un carattere di origine viene utilizzato in una corrispondenza, non possiamo riutilizzarlo. Pertanto, dopo aver trovato la prima corrispondenza aba, il terzo carattere 'a' non è stato riutilizzato.
esempio di test case per applicazioni web
java.util.regex
Il linguaggio Java non fornisce alcuna classe incorporata per regex. Ma possiamo lavorare con le espressioni regolari importando il ' java.util.regex 'Pacchetto.
Il pacchetto java.util.regex fornisce un'interfaccia e tre classi come mostrato di seguito:
Classe modello: Una classe pattern rappresenta la regex compilata. La classe Pattern non ha alcun costruttore pubblico ma fornisce metodi statici compile () che restituiscono oggetti Pattern e possono essere usati per creare un pattern.
Classe Matcher: L'oggetto della classe Matcher abbina il pattern regex alla stringa. Come la classe Pattern, anche questa classe non fornisce alcun costruttore pubblico. Fornisce il metodo matcher () che restituisce un oggetto Matcher.
PatternSyntaxException: Questa classe definisce un'eccezione non controllata. Un oggetto di tipo PatternSyntaxException restituisce un'eccezione non controllata che indica un errore di sintassi nel pattern regex.
Interfaccia MatchResult: L'interfaccia MatchResult determina il risultato della corrispondenza del pattern regex.
Esempio Java Regex
Implementiamo un semplice esempio di regex in Java. Nel programma seguente abbiamo una semplice stringa come modello e poi la abbiniamo a una stringa. L'output stampa la posizione iniziale e finale nella stringa in cui si trova il modello.
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)); } } Produzione:
Modello trovato da 15 a 19
Corrispondenza delle espressioni regolari in Java
La classe matcher implementa l'interfaccia MatchResult. Matcher funge da motore di regex e viene utilizzato per eseguire la corrispondenza esatta di una sequenza di caratteri.
come confrontare due file in unix
Di seguito sono riportati i metodi comuni della classe Matcher. Ha più metodi, ma di seguito abbiamo elencato solo i metodi importanti.
| Non | Metodo | Descrizione |
|---|---|---|
| 7 | int start () | Fornisce l'indice iniziale della sottosequenza corrispondente e lo restituisce. |
| 1 | corrispondenze booleane () | Controlla se la regex corrisponde al pattern. |
| Due | Pattern pattern () | Restituisce il modello interpretato dal matcher. |
| 3 | booleano find () | Questo metodo trova la successiva espressione da abbinare al modello. |
| 4 | boolean find (int start) | Uguale a find () ma trova l'espressione a cui corrispondere dalla posizione iniziale data. |
| 5 | Gruppo di stringhe () | Restituisce la sottosequenza corrispondente al modello. |
| 6 | Gruppo di stringhe (nome della stringa) | Restituisce la sottosequenza di input. Questo viene acquisito nell'operazione di corrispondenza precedente acquisendo il gruppo con il nome specificato. |
| 8 | avere intenzione() | Restituisce la posizione finale / indice della sottosequenza corrispondente. |
| 9 | int groupCount () | Restituisce il numero totale di sottosequenze corrispondenti. |
| 10 | String replaceAll (Sostituzione stringa) | Sostituisci tutte le sottosequenze della sequenza di input che corrispondono al modello con una stringa di sostituzione data. |
| undici | String replaceFirst (Sostituzione stringa) | Sostituire la prima sottosequenza corrispondente della sequenza di input con la stringa di sostituzione specificata. |
| 12 | String toString () | Restituisce la rappresentazione in formato stringa del matcher corrente. |
Esempio di implementazione di espressioni regolari
Vediamo un esempio dell'utilizzo di alcuni di questi metodi.
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); } } Produzione:
stringa di input: Vende conchiglie in riva al mare con conchiglie
sostituire Primo metodo: vende perle di mare in riva al mare con conchiglie
sostituireTutto metodo: Vende perle di mare in riva al mare con perle
Classe di pattern Regex in Java
La classe Pattern definisce il pattern per il motore regex che può quindi essere utilizzato per corrispondere alla stringa di input.
La tabella seguente mostra i metodi forniti dalla classe Pattern comunemente utilizzata.
| Non | Metodo | Descrizione |
|---|---|---|
| 7 | String () split (CharSequence input, int limit) | La stringa di input viene suddivisa attorno alle corrispondenze trovate da un determinato modello. |
| 1 | Compilazione di pattern statici (stringa regex) | Restituisce la rappresentazione compilata della regex. |
| Due | compilazione di modelli statici (regex stringa, flag int) | Compila data regex utilizzando flag specificati e restituisce il modello. |
| 3 | Corrisponde alle corrispondenze (input CharSequence) | Restituisce un matcher facendo corrispondere la sequenza di input con il modello. |
| 4 | corrispondenze booleane statiche (String regex, CharSequence input) | Compila la regex data e confronta il pattern con un dato input. |
| 5 | int flags () | Restituisce i flag del modello con cui viene eseguita la corrispondenza. |
| 6 | String () split (CharSequence input) | La stringa di input viene suddivisa attorno alle corrispondenze trovate da un determinato modello. |
| 8 | Schema corde () | Restituisce il modello di espressione regolare. |
| 9 | static String quote (String s) | Restituisce una stringa letterale (modello) per la stringa data. |
| 10 | String toString () | Ottieni la rappresentazione di stringa del modello. |
L'esempio seguente utilizza alcuni dei metodi precedenti della 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 Metodo Regex String Matches
Abbiamo visto il metodo String.Contains () nei nostri tutorial sulle stringhe. Questo metodo restituisce un valore booleano vero o falso a seconda che la stringa contenga o meno un carattere specificato.
Allo stesso modo, abbiamo un metodo 'corrisponde ()' per verificare se la stringa corrisponde a un'espressione regolare o regex. Se la stringa corrisponde all'espressione regolare specificata, viene restituito un valore true oppure viene restituito false.
La sintassi generale del metodo match ():
public boolean matches (String regex)Se la regex specificata non è valida, viene generata 'PatternSyntaxException'.
Implementiamo un programma per dimostrare l'uso del metodo 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')); } } Produzione:
Stringa di input: tutorial della serie Java
Regex: (. *) Java (. *) Corrisponde alla stringa? vero
Regex: (. *) Serie (. *) Corrisponde alla stringa? vero
Regex: (. *) Serie (. *) Corrisponde alla stringa? falso
Regex: (. *) I tutorial corrispondono alla stringa? vero
Usiamo molti caratteri speciali e metacaratteri con espressioni regolari in Java. Usiamo anche molte classi di caratteri per la corrispondenza dei modelli. In questa sezione, forniremo le tabelle contenenti classi di caratteri, caratteri Meta e quantificatori che possono essere utilizzati con regex.
Classi di caratteri Regex
Non Classe di carattere Descrizione 7 (a-z && (^ m-p)) Sottrazione: dalla a alla z e non dalla m alla p: (a-lq-z) 1 (pqr) p, q o r Due (^ pqr) Negazione: qualsiasi carattere diverso da p, q o r 3 (a-zA-Z) Intervallo: dalla a alla z o dalla A alla Z, inclusi 4 (a-d (m-p)) Unione: da a a d oppure da m a p: (a-dm-p) 5 (a-z && (def)) Intersezione: d, e o f 6 (a-z && (^ bc)) Sottrazione: dalla a alla z, eccetto be c: (ad-z)
Quantificatori Regex
I quantificatori vengono utilizzati per specificare il numero di volte in cui il carattere ricorre nella regex.
La tabella seguente mostra i quantificatori regex comuni utilizzati in Java.
Non Quantificatore Regex Descrizione 7 NEL Qualsiasi carattere non alfanumerico, (^ w) 1 X? x appare una volta o non compare affatto Due x + x appare una o più volte 3 X * x si verifica zero o più volte 4 x {n} x si verifica n volte 5 x {n,} x si verifica n o più volte 6 X e Z} x si verifica almeno y volte ma meno di z volte
Meta caratteri Regex
I metacaratteri nell'espressione regolare funzionano come codici abbreviati. Questi codici includono spazi vuoti e caratteri non vuoti insieme ad altri codici brevi.
La tabella seguente elenca i caratteri Meta regex.
Non Meta caratteri Descrizione 1 . Qualsiasi carattere (può o non può corrispondere al terminatore) Due d Qualsiasi cifra, (0-9) 3 D Qualsiasi non cifra, (^ 0-9) 4 S Qualsiasi carattere di spazio bianco, ( t n x0B f r) 5 S Qualsiasi carattere diverso da spazi, (^ s) 6
el Qualsiasi carattere della parola, (a-zA-Z_0-9) 8 b Un confine di parola 9 B Un confine non di parole
Di seguito è riportato un programma Java che utilizza i caratteri speciali di cui sopra nel 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?')); } } Produzione:
Jim (jim): falso
(Pp) eter (Peter): vero
. * abc. * (pqabcqp): vero
^ (^ d). * (abc123): vero
(a-zA-Z) (a-zA-Z) (a-zA-Z) (aQz): vero
(a-zA-Z) (a-zA-Z) (a-zA-Z), a10zfalse
D *, abcde: true
^ Questo $, questo è Java: falso
^ Questo $, Questo: falso
^ Questo $, è questo Java?: Falso
Nel programma precedente, abbiamo fornito varie espressioni regolari che vengono abbinate alla stringa di input. Si consiglia ai lettori di leggere i commenti nel programma per ogni regex per comprendere meglio il concetto.
Operatore logico o (|) Regex
Possiamo usare l'operatore logico o (|) nella regex che ci dà la scelta di selezionare uno degli operandi di | operatore. Possiamo usare questo operatore in una regex per dare una scelta di carattere o stringa. Per esempio, se vogliamo abbinare entrambe le parole, 'test' e 'Test', includeremo queste parole nella logica o nell'operatore come Test | test.
Vediamo il seguente esempio per comprendere questo operatore.
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()); } } } Produzione:
Testo 'Test' trovato da 9 a 13.
Testo 'test' trovato da 8 a 12.
In questo programma, abbiamo fornito la regex '(Test | test)'. Quindi prima diamo la stringa di input come 'Guida al test del software' e abbiniamo il modello. Vediamo che la corrispondenza viene trovata e la posizione viene stampata.
Successivamente, diamo la stringa di input come 'SoftwaretestingHelp'. Questa volta si trova anche la corrispondenza. Questo perché la regex ha usato l'operatore or e quindi il pattern su entrambi i lati di | l'operatore è abbinato alla stringa.
Convalida e-mail utilizzando Regex
Possiamo anche convalidare l'ID e-mail (indirizzo) con regex utilizzando il metodo java.util.regex.Pattern.matches (). Corrisponde all'ID email fornito con la regex e restituisce true se l'email è valida.
Il seguente programma dimostra la convalida della posta elettronica utilizzando 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)); } } Produzione:
L'ID e-mail è: ssthva@gmail.com
ID email valido? vero
L'ID e-mail è: @ sth @ gmail.com
ID email valido? falso
Come possiamo vedere dall'output sopra, il primo ID e-mail è valido. Il secondo id inizia direttamente con @ e quindi regex non lo convalida. Quindi è un ID non valido.
java coding intervista domande e risposte
Domande frequenti
D # 1) Cosa c'è in un'espressione regolare?
Risposta: PER Espressione regolare comunemente chiamato regex è un pattern o una sequenza di caratteri (normali o speciali o caratteri Meta) che viene utilizzato per convalidare una stringa di input.
D # 2) Qual è il significato della classe Matcher per un'espressione regolare in Java?
Risposta: La classe matcher (java.util.regex.Matcher) funge da motore regex. Esegue le operazioni di abbinamento interpretando il Pattern.
D # 3) Qual è il pattern in Java?
Risposta: Il pacchetto java.util.regex fornisce una classe Pattern che viene utilizzata per compilare una regex in un pattern che è la rappresentazione standard per regex. Questo modello viene quindi utilizzato per convalidare le stringhe abbinandolo al modello.
Q # 4) Cos'è B in un'espressione regolare?
Risposta: La B nell'espressione regolare è indicata come b ed è un carattere di ancoraggio utilizzato per trovare una posizione chiamata confine di parola. L'inizio della riga è indicato con un accento circonflesso (^) e la fine della riga è indicata con un segno di dollaro ($).
D # 5) Il pattern è Java thread-safe?
Risposta: Sì. Le istanze della classe Pattern sono immutabili e sicure per l'uso da più thread simultanei. Ma le istanze della classe matcher non sono thread-safe.
Conclusione
In questo tutorial, abbiamo discusso delle espressioni regolari in Java. L'espressione regolare, nota anche come 'regex', viene utilizzata per convalidare la stringa di input in Java. Java fornisce il ' java.util.regex ' pacchetto che fornisce classi come Pattern, Matcher, ecc. che aiutano a definire e abbinare il modello con la stringa di input.
Abbiamo anche visto varie classi di caratteri speciali e metacaratteri che possiamo usare nella regex che forniscono codici abbreviati per il pattern matching. Abbiamo anche esplorato la convalida della posta elettronica utilizzando regex.
=> Esplora la serie di formazione Java semplice qui.
Lettura consigliata