Utilizzo delle espressioni regolari in Java per la sostituzione di stringhe

Come tutti i linguaggi di programmazione, anche in Java a manipolazione delle stringhe è un'attività che richiede spesso la gestione di pattern specifici: le espressioni regolari. Le regex consentono di identificare e manipolare pattern specifici all'interno di una stringa, offrendo un elevato livello di precisione e controllo.

In questo articolo, esploreremo in dettaglio come utilizzare le espressioni regolari in Java per individuare e sostituire stringhe, fornendo una guida pratica e completa per sfruttare al meglio questa potente funzionalità.

Che cos'è un'espressione regolare e come funziona in Java

Un'espressione regolare è una sequenza di caratteri che definisce un pattern di ricerca. In Java, le espressioni regolari sono implementate attraverso la classe Pattern, che offre un metodo potente per la manipolazione delle stringhe. Per comprendere appieno il loro funzionamento, spiegheremo i concetti fondamentali delle espressioni regolari e come vengono utilizzate nel contesto di Java.

Esempio di creazione di un pattern regex in Java

La creazione di un pattern regex è un passaggio cruciale per utilizzare le espressioni regolari in Java. Di seguito è riportato un esempio di codice che mostra come creare un pattern regex per individuare sequenze di numeri:

import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        // Creazione di un pattern regex per individuare sequenze di numeri
        String regex = "\\d+";

        // Creazione dell'oggetto Pattern
        Pattern pattern = Pattern.compile(regex);

        // Esempio di utilizzo del pattern regex per individuare corrispondenze
        String text = "Questa stringa contiene 123 numeri. Ma li contiene anche qui, 12, vero?";
        java.util.regex.Matcher matcher = pattern.matcher(text);

        // Stampa di tutte le corrispondenze trovate
        while (matcher.find()) {
            System.out.println("Corrispondenza trovata: " + matcher.group());
        }
    }
}

Il codice inizia con l'importazione della classe Pattern dal pacchetto java.util.regex. Questa classe fornisce funzionalità per lavorare con espressioni regolari in Java.

Successivamente, viene dichiarata una stringa chiamata regex, che rappresenta l'espressione regolare che vogliamo utilizzare per trovare le sequenze di numeri all'interno di una stringa. Nell'esempio, la regex \\d+ corrisponde a una o più cifre numeriche.

Dopo aver definito l'espressione regolare, creiamo un oggetto Pattern utilizzando il metodo statico compile() della classe Pattern. Passiamo la stringa regex come argomento per creare il pattern desiderato.

Una volta creato l'oggetto Pattern, possiamo utilizzarlo per cercare corrispondenze nella nostra stringa di testo. Per fare ciò, creiamo un oggetto Matcher chiamato matcher chiamando il metodo matcher() sull'oggetto Pattern appena creato e passando la stringa di testo su cui vogliamo eseguire la ricerca.

Successivamente, entriamo in un ciclo while che continua fino a quando troviamo ulteriori corrispondenze all'interno della stringa. Chiamiamo il metodo find() sull'oggetto Matcher per cercare la prossima corrispondenza. Se viene trovata una corrispondenza, entriamo nel blocco del ciclo e stampiamo la corrispondenza trovata utilizzando il metodo group() dell'oggetto Matcher.

Facciamo un ulteriore esempio, di seguito è riportato un codice che mostra come utilizzare le espressioni regolari in Java per individuare un indirizzo email:

import java.util.regex.Pattern;

public class RegexExample {
    public static void main(String[] args) {
        // Creazione di un pattern regex per individuare indirizzi email
        String regex = "\\b[A-Za-z0-9._%+-]+@[A-Za-z0-9.-]+\\.[A-Za-z]{2,}\\b";
        
        // Creazione dell'oggetto Pattern
        Pattern pattern = Pattern.compile(regex);
        
        // Esempio di utilizzo del pattern regex per individuare corrispondenze
        String text = "Questo è un esempio di testo con un indirizzo email: test@example.com";
        java.util.regex.Matcher matcher = pattern.matcher(text);
        
        // Stampa della corrispondenza trovata
        if (matcher.find()) {
            System.out.println("Indirizzo email trovato: " + matcher.group());
        }
    }
}

Sostituzione di stringhe corrispondenti utilizzando le espressioni regolari

Oltre all'individuazione dei pattern, le espressioni regolari sono fondamentali per sostituire le stringhe corrispondenti con nuovi valori. Di seguito fornirò un esempio pratico, dove lo scenario è il seguente:

Il backoffice in Laravel genera i percorsi delle immagini nel db con il suo percorso tipico. Abbiamo quindi un Rest Server in Spring Boot che deve modificare questi percorsi per il frontend in Next.js. Quindi andiamo a sostituire i percorsi assoluti con un nuovo percorso relativo.

import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        // Creazione di un pattern regex per individuare indirizzi email
        String regex = "src=\"(.*?)\"";

        // Creazione dell'oggetto Pattern
        Pattern pattern = Pattern.compile(regex);

        // Esempio di utilizzo del pattern regex per individuare corrispondenze
        String text = "<div>\n" +
                "  <img src=\"http://www.host.loc/storage/imgs/img_1.jpg\">\n" +
                "  <p>Testo di esempio</p>\n" +
                "  <img src=\"http://www.host.loc/storage/imgs/img_2.jpg\">\n" +
                "</div>";

        java.util.regex.Matcher matcher = pattern.matcher(text);

        // Ciclo delle corrispondenze trovate
        while (matcher.find()) {
            String path = matcher.group(1);
            if(path.startsWith("http")) {
                int startIndex = path.indexOf("storage");
                String result = path.substring(startIndex);
                // Sostituzione delle occorrenze
                result = result.replace("storage", "/public");
                text = text.replace(matcher.group(1), result);
            }
        }
        System.out.println(text);
    }
}

Iniziamo creando un oggetto Pattern utilizzando il metodo compile() della classe Pattern. Il pattern regex utilizzato è src="(.*?)", che corrisponde alla sequenza di caratteri "src=", seguita da qualsiasi carattere non avido tra virgolette.

Successivamente, definiamo una stringa chiamata text che rappresenta il testo HTML in cui cercheremo i tag img e i relativi attributi src. Nel nostro esempio, il testo HTML è racchiuso tra i tag <div> e </div> e contiene due tag img con gli attributi src.

Creiamo quindi un oggetto Matcher utilizzando il metodo matcher() della classe Pattern, passando come argomento la stringa text. L'oggetto Matcher ci permetterà di individuare le corrispondenze nel testo HTML.

Avviamo un ciclo utilizzando il metodo find() del Matcher per cercare tutte le corrispondenze nel testo HTML. Ogni volta che viene trovata una corrispondenza, eseguiamo il blocco di codice all'interno del ciclo.

All'interno del blocco di codice, estraiamo il percorso corrispondente all'attributo src utilizzando il metodo group() del Matcher, con parametro 1. Questo metodo restituisce la parte corrispondente catturata all'interno delle parentesi tonde nella regex (in sostanza l'uri delle immagini).

Infine, possiamo eseguire la sostituzione del percorso trovato utilizzando il metodo replace() della classe String. Ad esempio, possiamo sostituire la parola "storage" con "/public" nel percorso estratto. Possiamo quindi aggiornare la stringa text con la sostituzione utilizzando il metodo replace().

Conclusioni

Le espressioni regolari in Java sono uno strumento potente per la manipolazione avanzata delle stringhe. Sono in grado di individuare pattern specifici e sostituire stringhe in modo preciso e controllato. In questo articolo, abbiamo esplorato il concetto di espressioni regolari, la creazione di pattern regex, l'individuazione di pattern specifici e la sostituzione delle stringhe corrispondenti.

Con una comprensione solida di queste funzionalità, sarai in grado di utilizzare le espressioni regolari per affrontare sfide complesse nella manipolazione delle stringhe in Java.