Espressioni regolari in Java – Esempio di Regex Java

Benvenuti alle espressioni regolari in Java. È anche chiamato Regex in Java. Quando ho iniziato a programmare, le espressioni regolari in java erano un incubo per me. Questo tutorial mira ad aiutarti a padroneggiare le espressioni regolari in Java. Tornerò anche qui per rinfrescare la mia conoscenza delle espressioni regolari in Java.

Espressioni Regolari in Java

L’espressione regolare in Java definisce un modello per una stringa. Le espressioni regolari possono essere utilizzate per cercare, modificare o manipolare il testo. Un’espressione regolare non è specifica del linguaggio, ma differiscono leggermente per ogni linguaggio. Le espressioni regolari in Java sono più simili a Perl. Le classi Regex di Java sono presenti nel pacchetto java.util.regex che contiene tre classi:

1. Pattern: L’oggetto Pattern è la versione compilata dell’espressione regolare. La classe Pattern non ha alcun costruttore pubblico e utilizziamo il suo metodo statico pubblico compile per creare l’oggetto pattern passando l’argomento dell’espressione regolare.
2. Matcher: Matcher è l’oggetto motore di regex di Java che corrisponde al modello di stringa di input con l’oggetto modello creato. La classe Matcher non ha alcun costruttore pubblico e otteniamo un oggetto Matcher usando il metodo matcher dell’oggetto modello, che prende la stringa di input come argomento. Successivamente, utilizziamo il metodo matches che restituisce un risultato booleano in base al fatto che la stringa di input corrisponda o meno al modello regex.
3. PatternSyntaxException: PatternSyntaxException viene lanciata se la sintassi dell’espressione regolare non è corretta.

Diamo un’occhiata a un esempio di programma Java Regex.

package com.journaldev.util;

import java.util.regex.*;

public class PatternExample {

	public static void main(String[] args) {
		Pattern pattern = Pattern.compile(".xx.");
		Matcher matcher = pattern.matcher("MxxY");
		System.out.println("Input String matches regex - "+matcher.matches());
		// cattiva espressione regolare
		pattern = Pattern.compile("*xx*");

	}

}

Quando eseguiamo questo programma di esempio Java regex, otteniamo l’output seguente.

Input String matches regex - true
Exception in thread "main" java.util.regex.PatternSyntaxException: Dangling meta character '*' near index 0
*xx*
^
	at java.util.regex.Pattern.error(Pattern.java:1924)
	at java.util.regex.Pattern.sequence(Pattern.java:2090)
	at java.util.regex.Pattern.expr(Pattern.java:1964)
	at java.util.regex.Pattern.compile(Pattern.java:1665)
	at java.util.regex.Pattern.(Pattern.java:1337)
	at java.util.regex.Pattern.compile(Pattern.java:1022)
	at com.journaldev.util.PatternExample.main(PatternExample.java:13)

Dato che l’espressione regolare di Java ruota attorno alla stringa, la classe String è stata estesa in Java 1.4 per fornire un metodo matches che effettua la corrispondenza del modello regex. Internamente utilizza le classi regex di Java Pattern e Matcher per elaborare i dati, riducendo ovviamente le linee di codice. La classe Pattern contiene anche il metodo matches che prende come argomenti una regex e una stringa di input, restituendo un risultato booleano dopo averle confrontate. Pertanto, il seguente codice funziona correttamente per la corrispondenza di una stringa di input con un’espressione regolare in Java.

String str = "bbb";
System.out.println("Using String matches method: "+str.matches(".bb"));
System.out.println("Using Pattern matches method: "+Pattern.matches(".bb", str));

Quindi, se il tuo requisito è solo verificare se la stringa di input corrisponde al modello, dovresti risparmiare tempo e righe di codice utilizzando il semplice metodo di confronto di stringhe. Dovresti utilizzare le classi Pattern e Matches solo quando è necessario manipolare la stringa di input o è necessario riutilizzare il modello. Nota che il modello definito dalla regex viene applicato alla stringa da sinistra a destra e una volta che un carattere di origine è utilizzato in una corrispondenza, non può essere riutilizzato. Ad esempio, la regex “121” si abbinerà a “31212142121” solo due volte come “_121____121”.

Espressione Regolare in Java – simboli di corrispondenza comuni

Meta-caratteri in Java Regex

Abbiamo alcuni meta-caratteri nella regex di Java, sono come shortcode per modelli di corrispondenza comuni.

Ci sono due modi per utilizzare i meta-caratteri come caratteri ordinari nelle espressioni regolari.

1. Precedere il meta-carattere con una barra rovesciata (\).
2. Mantenere il meta-carattere tra \Q (che inizia la citazione) e \E (che la termina).

Espressioni regolari in Java – Quantificatori

I quantificatori Regex di Java specificano il numero di occorrenze di un carattere da confrontare.

I quantificatori Regex di Java possono essere utilizzati anche con classi di caratteri e gruppi di cattura. Ad esempio, [abc]+ significa – a, b o c – una o più volte. (abc)+ significa il gruppo “abc” una o più volte. Discuteremo ora dei Gruppi di cattura.

Espressioni regolari in Java – Gruppi di cattura

I gruppi di cattura delle espressioni regolari in Java vengono utilizzati per trattare più caratteri come un’unica unità. Puoi creare un gruppo usando (). La porzione di stringa di input che corrisponde al gruppo di cattura viene salvata in memoria e può essere richiamata utilizzando il Riferimento indietro. Puoi utilizzare il metodo matcher.groupCount per scoprire il numero di gruppi di cattura in un modello regex di Java. Ad esempio, ((a)(bc)) contiene 3 gruppi di cattura – ((a)(bc)), (a) e (bc). Puoi utilizzare il Riferimento indietro nell’espressione regolare con una barra rovesciata (\) e quindi il numero del gruppo da richiamare. I gruppi di cattura e i riferimenti indietro possono essere confusionari, quindi cerchiamo di capire questo con un esempio.

System.out.println(Pattern.matches("(\\w\\d)\\1", "a2a2")); //true
System.out.println(Pattern.matches("(\\w\\d)\\1", "a2b2")); //false
System.out.println(Pattern.matches("(AB)(B\\d)\\2\\1", "ABB2B2AB")); //true
System.out.println(Pattern.matches("(AB)(B\\d)\\2\\1", "ABB2B3AB")); //false

Nel primo esempio, durante l’esecuzione il primo gruppo di acquisizione è (\w\d) che si valuta come “a2” quando viene abbinato alla stringa di input “a2a2” e salvato in memoria. Quindi \1 si riferisce a “a2” e quindi restituisce true. Per lo stesso motivo, la seconda affermazione stampa false. Cerca di capire questo scenario per le affermazioni 3 e 4 da solo. 🙂 Ora esamineremo alcuni importanti metodi delle classi Pattern e Matcher.

1. Possiamo creare un oggetto Pattern con dei flag. Ad esempio Pattern.CASE_INSENSITIVE abilita il matching senza distinzione tra maiuscole e minuscole.
2. La classe Pattern fornisce anche il metodo split(String) che è simile al metodo split() della classe String.
3. Il metodo toString() della classe Pattern restituisce la stringa di espressione regolare da cui è stata compilata questa pattern.
4. Le classi Matcher hanno metodi di indice start() e end() che indicano precisamente dove è stata trovata la corrispondenza nella stringa di input.
5. La classe Matcher fornisce anche metodi di manipolazione delle stringhe come replaceAll(String replacement) e replaceFirst(String replacement).

Esaminiamo questi metodi di regex java in un semplice programma di esempio.

package com.journaldev.util;

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexExamples {

	public static void main(String[] args) {
		// utilizzando pattern con flags
		Pattern pattern = Pattern.compile("ab", Pattern.CASE_INSENSITIVE);
		Matcher matcher = pattern.matcher("ABcabdAb");
		// utilizzando i metodi find(), group(), start() e end() di Matcher
		while (matcher.find()) {
			System.out.println("Found the text \"" + matcher.group()
					+ "\" starting at " + matcher.start()
					+ " index and ending at index " + matcher.end());
		}

		// utilizzando il metodo split() di Pattern
		pattern = Pattern.compile("\\W");
		String[] words = pattern.split("one@two#three:four$five");
		for (String s : words) {
			System.out.println("Split using Pattern.split(): " + s);
		}

		// utilizzando i metodi replaceFirst() e replaceAll() di Matcher
		pattern = Pattern.compile("1*2");
		matcher = pattern.matcher("11234512678");
		System.out.println("Using replaceAll: " + matcher.replaceAll("_"));
		System.out.println("Using replaceFirst: " + matcher.replaceFirst("_"));
	}

}

L’output del programma di esempio di regex java sopra è.

Found the text "AB" starting at 0 index and ending at index 2
Found the text "ab" starting at 3 index and ending at index 5
Found the text "Ab" starting at 6 index and ending at index 8
Split using Pattern.split(): one
Split using Pattern.split(): two
Split using Pattern.split(): three
Split using Pattern.split(): four
Split using Pattern.split(): five
Using replaceAll: _345_678
Using replaceFirst: _34512678

Ecco tutto per le espressioni regolari in Java. Le espressioni regolari in Java sembrano difficili all’inizio, ma se ci lavori per un po’ di tempo, è facile impararle e usarle.

Puoi controllare il codice completo e altri esempi di espressioni regolari dal nostro Repository GitHub.