In Java, le espressioni regolari o Regex (in breve) in Java sono un'API per definire modelli di stringhe che possono essere utilizzate per cercare, manipolare e modificare una stringa in Java. La convalida della posta elettronica e le password sono alcune aree di stringhe in cui Regex è ampiamente utilizzato per definire i vincoli. Le espressioni regolari in Java sono fornite sotto java.util.regex pacchetto. Questo consiste in 3 classi e 1 interfaccia . IL java.util.regex Il pacchetto è costituito principalmente dalle seguenti tre classi, come illustrato di seguito in formato tabellare:
Classi e interfacce Regex
Regex in Java fornisce 3 classi e 1 interfaccia che sono le seguenti:
- Classe modello
- Classe Corrispondente
- Classe PatternSyntaxException
- Interfaccia risultato partita
Una maggiore comprensione può essere interpretata dall'immagine fornita di seguito come segue:
fare e il ciclo while in Java
| Si No. | Classe/Interfaccia | Descrizione |
|---|---|---|
| 1. | Classe modello | Utilizzato per definire i modelli |
| 2. | Classe Corrispondente | Utilizzato per eseguire operazioni di corrispondenza sul testo utilizzando modelli |
| 3. | Classe PatternSyntaxException | Utilizzato per indicare un errore di sintassi in un modello di espressione regolare |
| 4. | Interfaccia risultato partita | Utilizzato per rappresentare il risultato di un'operazione di corrispondenza |
Classe modello
Questa classe è una raccolta di espressioni regolari che possono essere utilizzate per definire vari tipi di modelli, senza fornire costruttori pubblici. Questo può essere creato invocando il metodo compile() che accetta un'espressione regolare come primo argomento, restituendo così un modello dopo l'esecuzione.
| Si No. | Metodo | Descrizione |
|---|---|---|
| 1. | compilare (stringa regex) | Viene utilizzato per compilare l'espressione regolare data in un modello. |
| 2. | compile(String regex, int flag) | Viene utilizzato per compilare l'espressione regolare data in uno schema con i flag specificati. |
| 3. | bandiere() | Viene utilizzato per restituire i flag di corrispondenza di questo modello. |
| 4. | matcher (input CharSequence) | Viene utilizzato per creare un matcher che abbinerà l'input fornito a questo modello. |
| 5. | corrispondenze (stringa regex, input CharSequence) | Viene utilizzato per compilare l'espressione regolare data e tenta di confrontare l'input fornito con essa. |
| 6. | modello() | Viene utilizzato per restituire l'espressione regolare da cui è stato compilato questo modello. |
| 7. | citazione(Stringa s) | Viene utilizzato per restituire un modello letterale String per la String specificata. |
| 8. | diviso (input sequenza di caratteri) | Viene utilizzato per dividere la sequenza di input data attorno alle corrispondenze di questo modello. |
| 9. | split (input CharSequence, limite int) | Viene utilizzato per dividere la sequenza di input data attorno alle corrispondenze di questo modello. Il parametro limite controlla il numero di volte in cui viene applicato il modello. |
| 10. | accordare() | Viene utilizzato per restituire la rappresentazione di stringa di questo modello. |
Esempio: Classe del modello
Giava
// Java Program Demonstrating Working of matches() Method> // Pattern class> // Importing Pattern class from java.util.regex package> import> java.util.regex.Pattern;> // Main class> class> GFG {> >// Main driver method> >public> static> void> main(String args[])> >{> >// Following line prints 'true' because the whole> >// text 'geeksforgeeks' matches pattern> >// 'geeksforge*ks'> >System.out.println(Pattern.matches(> >'geeksforge*ks'>,>'geeksforgeeks'>));> >// Following line prints 'false' because the whole> >// text 'geeksfor' doesn't match pattern 'g*geeks*'> >System.out.println(> >Pattern.matches(>'g*geeks*'>,>'geeksfor'>));> >}> }> |
>
>Produzione
true false>
Classe di abbinamento
Questo oggetto viene utilizzato per eseguire operazioni di corrispondenza per una stringa di input in Java, interpretando così i modelli spiegati in precedenza. Anche questo non definisce costruttori pubblici. Questo può essere implementato invocando matcher() su qualsiasi oggetto pattern.
| Si No. | Metodo | Descrizione |
|---|---|---|
| 1. | Trovare() | Viene utilizzato principalmente per cercare più occorrenze delle espressioni regolari nel testo. |
| 2. | trova(int inizio) | Viene utilizzato per cercare le occorrenze delle espressioni regolari nel testo a partire dall'indice fornito. |
| 3. | inizio() | Viene utilizzato per ottenere l'indice iniziale di una corrispondenza trovata utilizzando il metodo find(). |
| 4. | FINE() | Viene utilizzato per ottenere l'indice finale di una corrispondenza trovata utilizzando il metodo find(). Restituisce l'indice del carattere successivo all'ultimo carattere corrispondente. |
| 5. | conteggiogruppo() | Viene utilizzato per trovare il numero totale della sottosequenza corrispondente. |
| 6. | gruppo() | Viene utilizzato per trovare la sottosequenza corrispondente. |
| 7. | corrispondenze() | Viene utilizzato per verificare se l'espressione regolare corrisponde al modello. |
Nota: T Pattern.matches() controlla se l'intero testo corrisponde o meno a un modello. Altri metodi (illustrati di seguito) vengono utilizzati principalmente per trovare più occorrenze di pattern nel testo.
Analizziamo alcuni programmi di esempio come abbiamo fatto per la classe Pattern. Qui discuteremo alcuni programmi Java che dimostrano il funzionamento di compile(), find(), start(), end() e split() per ottenere una migliore comprensione della classe Matcher.
Esempio 1: Ricerca di modelli
Giava
// Java program to demonstrate working of> // String matching in Java> // Importing Matcher and Pattern class> import> java.util.regex.Matcher;> import> java.util.regex.Pattern;> // Main class> class> GFG {> >// Main driver method> >public> static> void> main(String args[])> >{> >// Create a pattern to be searched> >// Custom pattern> >Pattern pattern = Pattern.compile(>'geeks'>);> >// Search above pattern in 'techcodeview.com> | Descrizione |
|---|---|
| [xyz] | x,y o z |
| [^xyz] | Qualsiasi carattere diverso da x,y o z |
| [a-zA-Z] | caratteri dall'intervallo dalla a alla z o dalla A alla Z. |
| [a-f[m-t]] | Unione di a con f e m con t. |
| [a-z && p-y] | Tutta la gamma di elementi che si intersecano tra due gamme |
| [a-z && [^bc]] | Unione da a a z con eccetto b e c |
| [a-z && [^m-p]] | Unione da a a z con eccetto l'intervallo da m a p |
Di seguito è riportata l'implementazione dell'argomento precedente:
Giava
// Java Program to check on Regex> import> java.io.*;> import> java.util.regex.*;> // Driver class> class> GFG {> >// Main function> >public> static> void> main(String[] args)> >{> >// Checks if the string matches with the regex> >// Should be single character a to z> >System.out.println(Pattern.matches(>'[a-z]'>,>'g'>));> >// Check if the element is range a to z or A to Z> >System.out.println(> >Pattern.matches(>'[a-zA-Z]'>,>'Gfg'>));> >}> }> |
>
>Produzione
true false>
Metacaratteri regex
| Regex | Descrizione |
|---|---|
| X? | X appare una volta oppure no |
| X+ | X appare una o più volte |
| X* | X appare zero o meno una volta |
| X{n} | X appare n volte |
| X{n,} utilizzo di Internet | X appare n volte o più di n |
| X{n,m} | X appare maggiore che uguale a n volte e minore di m volte. |
Di seguito è riportata l'implementazione dei metacaratteri Regex:
Giava
// Java Program to check on regex> import> java.io.*;> import> java.util.regex.*;> // Driver class> class> GFG {> >// Main function> >public> static> void> main(String[] args)> >{> >// Checking all the strings using regex> >System.out.println(Pattern.matches(>'[b-z]?'>,>'a'>));> >// Check if all the elements are in range a to z> >// or A to Z> >System.out.println(> >Pattern.matches(>'[a-zA-Z]+'>,>'GfgTestCase'>));> >// Check if elements is not in range a to z> >System.out.println(Pattern.matches(>'[^a-z]?'>,>'g'>));> >// Check if all the elements are either g,e,k or s> >System.out.println(> >Pattern.matches(>'[geks]*'>,>'geeksgeeks'>));> >}> }> |
>
>Produzione
false true false true>
Esempio di ricerca regex Java
| Regex | Descrizione |
|---|---|
| . | Qualsiasi personaggio |
| D | Qualsiasi cifra, [0-9] |
| D rhel contro centos | Qualsiasi non cifra, [^0-9] |
| S | Carattere di spazio bianco, [ x0Bf ] |
| S | Carattere diverso dallo spazio, [^s] |
| In | Carattere della parola, [a-zA-Z_0-9] |
| IN | Carattere non verbale, [^w] |
| B | Confine di parola |
| B | Confine non di parola |
Di seguito è riportata l'implementazione di Java Regex Finder:
Giava
// Java Program to implement regex> import> java.io.*;> import> java.util.regex.*;> // Driver Class> class> GFG {> >// Main Function> >public> static> void> main(String[] args)> >{> >// Check if all elements are numbers> >System.out.println(Pattern.matches(>'d+'>,>'1234'>));> >// Check if all elements are non-numbers> >System.out.println(Pattern.matches(>'D+'>,>'1234'>));> >// Check if all the elements are non-numbers> >System.out.println(Pattern.matches(>'D+'>,>'Gfg'>));> >// Check if all the elements are non-spaces> >System.out.println(Pattern.matches(>'S+'>,>'gfg'>));> >}> }> |
>
>Produzione
true false true true>
Conclusione
Infine, discutiamo alcune delle osservazioni importanti recuperate dall'articolo di cui sopra
- Creiamo un oggetto pattern chiamando Pattern.compile(), non esiste un costruttore. compile() è un metodo statico nella classe Pattern.
- Come sopra, creiamo un oggetto Matcher utilizzando matcher() sugli oggetti della classe Pattern.
- Pattern.matches() è anche un metodo statico utilizzato per verificare se un determinato testo nel suo insieme corrisponde o meno al pattern.
- find() viene utilizzato per trovare più occorrenze di pattern nel testo.
- Possiamo dividere un testo in base a un modello delimitatore utilizzando il metodo split()
Domande frequenti su Java Regex
Q1. Cosa sono le espressioni regolari in Java?
Anni:
Le espressioni regolari in Java vengono utilizzate per modelli di stringa che possono essere utilizzati per cercare, manipolare e modificare una stringa in Java.
Q2. Qual è un semplice esempio di espressione regolare in Java?
Anni:
Di seguito è riportato un semplice esempio di espressione regolare in Java:
Giava
// Java Program to check on Regex>import>java.io.*;>import>java.util.regex.*;>// Driver class>class>GFG {>>// Main function>>public>static>void>main(String[] args)>>{>>// Checks if the string matches with the regex>>// Should be single character a to z>>System.out.println(Pattern.matches(>'[a-z]'>,>'g'>));>>// Check if all the elements are non-numbers>>System.out.println(Pattern.matches(>'D+'>,>'Gfg'>));>>// Check if all the elements are non-spaces>>System.out.println(Pattern.matches(>'S+'>,>'gfg'>));>>}>}>>Java ciao mondo>Produzionetrue true true>