IL Java Regex o l'espressione regolare è un'API per definire un modello per la ricerca o la manipolazione delle stringhe .
È ampiamente utilizzato per definire il vincolo su stringhe come password e convalida e-mail. Dopo aver appreso il tutorial sulle regex Java, sarai in grado di testare le tue espressioni regolari con lo strumento Java Regex Tester.
L'API Java Regex fornisce 1 interfaccia e 3 classi in java.util.regex pacchetto.
pacchetto java.util.regex
Le classi Matcher e Pattern forniscono la funzionalità dell'espressione regolare Java. Il pacchetto java.util.regex fornisce le seguenti classi e interfacce per le espressioni regolari.
- Interfaccia MatchResult
- Classe di abbinamento
- Classe del modello
- Classe PatternSyntaxException
Classe di abbinamento
Implementa il Risultato della partita interfaccia. È un motore regex che viene utilizzato per eseguire operazioni di corrispondenza su una sequenza di caratteri.
| NO. | Metodo | Descrizione |
|---|---|---|
| 1 | corrispondenze booleane() | verifica se l'espressione regolare corrisponde al modello. |
| 2 | ricerca booleana() | trova l'espressione successiva che corrisponde al modello. |
| 3 | ricerca booleana(int inizio) | trova l'espressione successiva che corrisponde al modello dal numero iniziale specificato. |
| 4 | Gruppo di stringhe() | restituisce la sottosequenza corrispondente. |
| 5 | int inizio() | restituisce l'indice iniziale della sottosequenza corrispondente. |
| 6 | avere intenzione() | restituisce l'indice finale della sottosequenza corrispondente. |
| 7 | int groupCount() | restituisce il numero totale della sottosequenza corrispondente. |
Classe del modello
È il versione compilata di un'espressione regolare . Viene utilizzato per definire un modello per il motore regex.
| NO. | Metodo | Descrizione |
|---|---|---|
| 1 | Compilazione modello statico (stringa regex) | compila la regex specificata e restituisce l'istanza del Pattern. |
| 2 | Matcher matcher (input CharSequence) | crea un matcher che abbina l'input fornito al modello. |
| 3 | corrispondenze booleane statiche (string regex, input CharSequence) | Funziona come la combinazione dei metodi di compilazione e di corrispondenza. Compila l'espressione regolare e abbina l'input fornito al modello. |
| 4 | String[] split (input CharSequence) | divide la stringa di input specificata attorno alle corrispondenze del modello specificato. |
| 5 | Schema di corde() | restituisce il modello regex. |
Esempio di espressioni regolari Java
Esistono tre modi per scrivere l'esempio regex in Java.
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); }} Provalo adesso Produzione
true true true
Espressione regolare . Esempio
IL . (punto) rappresenta un singolo carattere.
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) }} Provalo adesso Classi di caratteri Regex
| NO. | Classe di caratteri | Descrizione |
|---|---|---|
| 1 | [abc] | a, b o c (classe semplice) |
| 2 | [^abc] | Qualsiasi carattere tranne a, b o c (negazione) |
| 3 | [a-zA-Z] | da a a z o da A a Z, inclusi (intervallo) |
| 4 | [a-d[m-p]] | da a a d, o da m a p: [a-dm-p] (unione) |
| 5 | [a-z&&[def]] | d, e o f (intersezione) |
| 6 | [a-z&&[^bc]] | da a a z, eccetto b e c: [ad-z] (sottrazione) |
| 7 | [a-z&&[^m-p]] | da a a z e non da m a p: [a-lq-z](sottrazione) |
Esempio di classi di caratteri per espressioni regolari
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) }} Provalo adesso Quantificatori regex
I quantificatori specificano il numero di occorrenze di un carattere.
| Regex | Descrizione |
|---|---|
| X? | X si verifica una volta o non si verifica affatto |
| X+ | X ricorre una o più volte |
| X* | X ricorre zero o più volte |
| X{n} | X ricorre solo n volte |
| X{n,} | X ricorre n o più volte |
| X{y,z} | X ricorre almeno y volte ma meno di z volte |
Esempio di classi di caratteri e quantificatori di espressioni regolari
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) }} Provalo adesso Metacaratteri regex
I metacaratteri delle espressioni regolari funzionano come shortcode.
| Regex | Descrizione |
|---|---|
| . | Qualsiasi carattere (può corrispondere o meno al terminatore) |
| D | Qualsiasi cifra, tranne [0-9] |
| D | Qualsiasi non-cifra, abbreviazione di [^0-9] |
| S | Qualsiasi carattere di spazio bianco, abbreviazione di [ x0Bf ] |
| S | Qualsiasi carattere diverso dagli spazi, abbreviazione di [^s] |
| In | Qualsiasi carattere di parola, abbreviazione di [a-zA-Z_0-9] |
| IN | Qualsiasi carattere non verbale, abbreviazione di [^w] |
| B | Un confine di parole |
| B | Un confine non verbale |
Esempio di metacaratteri di espressioni regolari
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) }} Provalo adesso Domanda sulle espressioni regolari 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) }} Provalo adesso
Domanda 2 sulle espressioni regolari
/*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) }} Provalo adesso Esempio di ricerca regex Java
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.'); } } } } Produzione:
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