Quali sono le espressioni regolari in Java?
In Java , Regex o Regular Expression è un'interfaccia del programma applicativo che aiuta a definire un modello per cercare, manipolare e modificare le stringhe. Le espressioni regolari Java sono ampiamente utilizzate nella convalida di password ed e-mail. Queste espressioni sono fornite dal pacchetto java.util.regex e sono composte da 1 interfaccia e 3 classi.
Le tre classi sono:
- Pattern: aiuta a definire i pattern.
- Matcher: usando i pattern, aiuta a eseguire le operazioni di match.
- PatternSyntaxException: aiuta a indicare un errore di sintassi.
Java Regex ha un'interfaccia nota come MatchResultInterface che aiuta a determinare il risultato dell'operazione di corrispondenza dell'espressione regolare.
Sintassi delle espressioni regolari in Java
Ora vediamo come scrivere un'espressione regolare in Java con l'aiuto di un programma.
Codice:
//Java program to demonstrate regular expressions
import java.util.regex.*;
public class RegExamples (
public static void main(String args())(
String A = " Happiness is " + " within yourself";
String B = ".*within.*";
// checks whether the string A contains the word 'within' and stores the result in matchcheck
boolean matchcheck = Pattern.matches(B, A);
//prints the result
System.out.println("Is there any string 'within' in the text ? \n " + matchcheck);
) )
Produzione:
Metodi comunemente usati nelle espressioni regolari
Esistono 3 metodi comunemente usati nelle espressioni regolari. Loro sono,
1. Metodi di indice
I metodi di indice offrono valori di indice che aiutano a mostrare con precisione dove è stata trovata la corrispondenza nella stringa fornita come input.
| Metodo | Descrizione |
| inizio() | Viene restituito l'indice iniziale della partita precedente. |
| start (gruppo int) | Data la precedente sottosezione del gruppo, la sequenza viene acquisita e restituita. |
| fine() | Viene restituito l'offset dopo la corrispondenza dell'ultimo carattere. |
| Fine (gruppo int) | Data la precedente operazione di corrispondenza del gruppo, la sottosequenza viene catturata e sfalsata dopo la corrispondenza dell'ultimo carattere restituito. |
2. Metodi di studio
I metodi di studio controllano la stringa fornita come input e viene restituito un valore booleano che indica se il modello è stato trovato o meno.
| Metodo | Descrizione |
| lookingat () | Abbina la sequenza indicata come input rispetto al modello dall'inizio della regione. |
| trova() | Trova la successiva sottosequenza della sequenza fornita come input rispetto al modello dall'inizio della regione. |
| find (int start) | Reimposta il matcher e quindi trova la successiva sottosequenza della sequenza fornita come input rispetto al modello dall'indice specificato. |
| partite () | Abbina il contenuto allo schema. |
3. Metodi di sostituzione
Metodi utilizzati per sostituire il testo in una stringa.
| Metodo | Descrizione |
| appendReplacement (StringBuffer s, Sostituzione stringa) | Verrà implementata una fase di aggiunta e sostituzione non terminale. |
| appendTail (StringBuffer) | Verrà implementata un'appendice terminale e una fase di sostituzione. |
| replaceAll (sostituzione stringa) | Sostituisci tutta la sottosequenza della sequenza indicata come input che corrisponde allo schema con una stringa di sostituzione. |
| quoteReplacement (String s) | Verrà restituita una stringa di sostituzione letterale per la stringa menzionata. |
| replaceFirst (sostituzione stringa) | Sostituisci la prima sottosequenza della sequenza indicata come input che corrisponde al modello con una stringa di sostituzione. |
Come definire un'espressione regolare in Java?
Esistono diversi modi in cui è possibile definire un'espressione regolare. Loro sono:
1. Letterali
Supponiamo che una stringa "hai" debba essere cercata in un testo "hai". Può essere fatto usando la sintassi.
Pattern.matches("hai", "hai")
2. Classi di caratteri
Corrisponde a ogni singolo carattere nel testo fornito come input a più caratteri consentiti nella classe di caratteri. Di seguito sono riportati i vari costrutti di classe.
| Classe di caratteri | Spiegazione |
| (PQR) | Corrisponde al testo se contiene p, qor che dovrebbe essere solo una volta. |
| (PQR) | indica la negazione e per questo motivo, qui, vengono presi i caratteri singoli tranne p, q o r. |
| (A-zA-Z) | sono considerati dalla a alla z e dalla A alla Z. |
| (Annuncio (ps)) | da a a o da p a s. |
| (A-dm-p) | Unione di entrambe le gamme. |
| (Az && (PQR)) | dalla a alla z e (p, q o r). |
| (Az && (PQ)) | dalla a alla z e anche, p, q non sono considerati. |
| (Ad-z) | Esegue la sottrazione. |
| (Az && (mp)) | dalla a alla z e non dalla m alla p. |
3. Metacaratteri
I metacaratteri si comportano come codici brevi nell'espressione regolare. Di seguito sono riportati alcuni dei metacaratteri comunemente utilizzati.
| Espressione regolare | Spiegazione |
| \ d | Qualsiasi cifra da 0 a 9. Può anche essere scritta come (0-9). |
| \ D | Qualsiasi cifra non compresa tra 0 e 9. Può anche essere scritta come (0-9). |
| \S | Carattere spazi bianchi o (\ t \ n \ x0B \ f \ r). |
| \S | Carattere non bianco o (\ s). |
| \ w | Carattere di parola o (a-zA-Z_0-9). |
| \ W | Carattere non verbale o (\ w). |
| \ b | Confine di parole. |
| \ B | Confine non di parole. |
4. Quantificatori
I quantificatori menzionano il conteggio delle occorrenze di ciascun personaggio da abbinare alla stringa.
| Espressione regolare | Spiegazione |
| un? | Si verifica una volta o per niente. |
| UN* | A si verifica 0 o più volte. |
| A + | A si verifica 1 o più volte. |
| Un) | A si verifica esattamente n volte. |
| Un, ) | A si verifica n o più di quello. |
| A (n, m) | A si verifica almeno n volte ma non dovrebbe essere più di m volte. |
Come creare espressioni regolari in Java?
Vediamo ora un programma Java con le espressioni regolari sopra menzionate.
Codice:
//Java program to demonstrate regular expressions
import java.util.regex.*;
public class RegExamples (
public static void main(String args())(
String str="hai";
// Returns true if string 1 matches string 2
System.out.println("Returns true if 'hai' matches 'Hai' :"+
Pattern.matches(str, "Hai")); //False
//Returns true if Hai or hai matches parameter 2
System.out.println("Returns true if 'Hai' or 'hai' matches 'Hai' : "+
Pattern.matches("(Hh)ai", "Hai")); //True
// Returns true if the string matches exactly "ann" or "Ann" or "jak" or "Jak"
System.out.println("Returns true if the string matches exactly 'ann' or 'Ann' or 'jak' or 'Jak' with 'Ann' : "+
Pattern.matches("(aA)nn|(jJ)ak", "Ann"));//True
//returns true if the string contains "with" at any place in the string
System.out.println("returns true if the string contains 'with' in the string 'within' : " +
Pattern.matches(".*with.*", "within"));//True
// returns true if the '9448anna' does not have number in the beginning
System.out.println( "returns true if the '9448anna' does not have number in the beginning : "+
Pattern.matches("^(^\\d).*", "9448anna")); //False
System.out.println("returns true if the '9448anna' does not have number in the beginning : " +
Pattern.matches("^(^\\d).*", "anna9448")); //True
)
)
Produzione:
Conclusione
Le espressioni regolari Java sono ampiamente utilizzate per applicazioni in tempo reale come la verifica di password ed e-mail. Queste espressioni sono API che definiscono modelli e offrono ricerca, modifica e molte altre operazioni nella stringa.
Articoli consigliati
Questa è una guida alle espressioni regolari in Java. Qui discutiamo come creare, come definire e metodi comunemente usati di espressioni regolari in Java. Puoi anche consultare i seguenti articoli per saperne di più -
- I 3 migliori compilatori di Java
- Espressioni regolari in JavaScript - Proprietà e metodi
- Sviluppo di app Java
- Metodi di matrice in Java con esempi
- Funzioni Regex in Python (esempio)