0Pricing
Java Academy · Lezione

Espressioni regolari con Pattern e Matcher

Convalidi indirizzi email, estragga sottostringhe e sostituisca pattern utilizzando le regex di Java.

Espressioni regolari con Pattern e Matcher è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 4 di 4. Puoi leggere la lezione completa qui gratuitamente — poi esercitati direttamente nel browser con un editor di codice integrato e un tutor IA disponibile 24/7. Fa parte del percorso di apprendimento Java Academy, e i tuoi progressi si sincronizzano tra il web e l'app CoddyKit. Il corso Java Academy include 4 lezioni in totale.

Espressioni regolari con Pattern e Matcher

Il package java.util.regex di Java fornisce Pattern e Matcher per eseguire ricerche avanzate nel testo, validazione, estrazione e sostituzione.

Perché usare le espressioni regolari

Le espressioni regolari (regex) sono pattern per trovare corrispondenze nel testo. In Java vengono usate per validare indirizzi email e numeri di telefono, estrarre dati dai log e analizzare testo strutturato.

import java.util.regex.*;

// Is this a valid email?
String email = "alice@example.com";
boolean valid = email.matches("[a-zA-Z0-9._%+\\-]+@[a-zA-Z0-9.\\-]+\\.[a-zA-Z]{2,}");
System.out.println(valid); // true

// Extract version numbers from a string
String log = "App v1.2.3 deployed; api v2.0.0 started";
Pattern p = Pattern.compile("v(\\d+\\.\\d+\\.\\d+)");
Matcher m = p.matcher(log);
while (m.find()) System.out.println(m.group(1));
// 1.2.3 
// 2.0.0

Basi della sintassi regex

Metacaratteri regex principali:

  • . — qualsiasi carattere
  • \d — cifra; \w — carattere di una parola; \s — spazio bianco
  • * — 0 o più; + — 1 o più; ? — 0 o 1
  • {n,m} — da n a m volte
  • ^/$ — inizio/fine della riga
  • [abc] — classe di caratteri
// In Java strings, backslash must be doubled: \d = "\\d"
Pattern digit   = Pattern.compile("\\d+");      // one or more digits
Pattern word    = Pattern.compile("\\w{3,20}");  // 3-20 word chars
Pattern space   = Pattern.compile("\\s+");       // whitespace
Pattern phone   = Pattern.compile("\\d{3}-\\d{3}-\\d{4}"); // 555-867-5309

System.out.println(digit.matcher("42").matches());       // true
System.out.println(phone.matcher("555-867-5309").matches()); // true

Pattern.compile e Matcher

Compili un pattern una sola volta e riutilizzi Matcher per più input: è più efficiente che usare String.matches() per validazioni ripetute.

import java.util.regex.*;

Pattern emailPattern = Pattern.compile(
    "^[a-zA-Z0-9._%+\\-]+@[a-zA-Z0-9.\\-]+\\.[a-zA-Z]{2,6}$"
);

String[] emails = {"alice@example.com", "bad@", "test.user@co.uk", "no-at-sign"};
for (String e : emails) {
    Matcher m = emailPattern.matcher(e);
    System.out.println(e + " -> " + (m.matches() ? "valid" : "invalid"));
}

find() rispetto a matches()

matches() verifica l'intera stringa. find() trova la corrispondenza successiva all'interno della stringa. Utilizzi find per la ricerca e matches per la validazione completa.

import java.util.regex.*;

Pattern price = Pattern.compile("\\d+\\.\\d{2}");

String invoice = "Total: 129.99, Tax: 10.40, Shipping: 5.00";
Matcher m = invoice.matcher(invoice);

// find() locates all matches
while (m.find()) {
    System.out.println("Found: " + m.group() + " at " + m.start());
}
// Found: 129.99 at 7
// Found: 10.40 at 20
// Found: 5.00 at 34

Gruppi di cattura

Le parentesi creano gruppi di cattura. Utilizzi group(n) per estrarre le sottostringhe corrispondenti.

import java.util.regex.*;

Pattern date = Pattern.compile("(\\d{4})-(\\d{2})-(\\d{2})");
Matcher m = date.matcher("Deployed on 2024-06-15 and 2024-07-01");

while (m.find()) {
    String year  = m.group(1);
    String month = m.group(2);
    String day   = m.group(3);
    System.out.println(year + "/" + month + "/" + day);
}
// 2024/06/15
// 2024/07/01

Gruppi denominati

I gruppi denominati (?<name>...) rendono i gruppi di cattura più leggibili e accessibili tramite il nome.

import java.util.regex.*;

Pattern log = Pattern.compile(
    "(?<timestamp>\\d{4}-\\d{2}-\\d{2}) (?<level>[A-Z]+) (?<message>.+)"
);

String line = "2024-06-15 ERROR Database connection failed";
Matcher m = log.matcher(line);

if (m.matches()) {
    System.out.println("Time: "    + m.group("timestamp"));
    System.out.println("Level: "   + m.group("level"));
    System.out.println("Message: " + m.group("message"));
}
// Time: 2024-06-15
// Level: ERROR
// Message: Database connection failed

replaceAll e replaceFirst

Sostituzione basata su pattern: sostituire tutte le occorrenze oppure solo la prima.

import java.util.regex.*;

String text = "Call us at 123-456-7890 or 098-765-4321";

// Mask phone numbers for privacy logs
String masked = text.replaceAll("\\d{3}-\\d{3}-\\d{4}", "XXX-XXX-XXXX");
System.out.println(masked);
// Call us at XXX-XXX-XXXX or XXX-XXX-XXXX

// Replace multiple whitespace with single space
String cleaned = "too   many   spaces".replaceAll("\\s+", " ");
System.out.println(cleaned); // too many spaces

split() con le regex

String.split() accetta una regex. Utilizzatelo per dividere il testo usando più delimitatori o separatori complessi.

// Split on comma with optional spaces
String csv = "Alice, Bob,  Charlie,Diana";
String[] names = csv.split("\\s*,\\s*");
for (String name : names) System.out.println("'" + name + "'");
// 'Alice' 'Bob' 'Charlie' 'Diana'

// Split on any whitespace
String words = "one  two\tthree  four";
String[] parts = words.split("\\s+");
System.out.println(parts.length); // 4

// Limit splits
String line = "key=value=extra";
String[] kv = line.split("=", 2); // [key, value=extra]

Flag di Pattern

I flag modificano il comportamento delle regex: CASE_INSENSITIVE, MULTILINE, DOTALL.

import java.util.regex.*;

// Case-insensitive match
Pattern p = Pattern.compile("hello", Pattern.CASE_INSENSITIVE);
System.out.println(p.matcher("HELLO World").find()); // true

// MULTILINE: ^ and $ match line boundaries
Pattern multi = Pattern.compile("^ERROR", Pattern.MULTILINE);
String logs = "INFO start\nERROR crash\nINFO end";
Matcher m = multi.matcher(logs);
int count = 0;
while (m.find()) count++;
System.out.println("ERROR lines: " + count); // 1

Pratica: parser di log

Analizzare righe di log di accesso in stile Apache con gruppi denominati.

import java.util.regex.*;

Pattern accessLog = Pattern.compile(
    "(?<ip>[\\d.]+) - - \\[(?<time>[^\\]]+)\\] " +
    "\"(?<method>[A-Z]+) (?<path>[^ ]+)[^\"]*\" " +
    "(?<status>\\d{3}) (?<bytes>\\d+)"
);

String line = "192.168.1.1 - - [27/May/2024:10:30:00 +0000] \"GET /api/products HTTP/1.1\" 200 1024";
Matcher m = accessLog.matcher(line);
if (m.matches()) {
    System.out.println("IP: "     + m.group("ip"));
    System.out.println("Method: " + m.group("method"));
    System.out.println("Status: " + m.group("status"));
}

Verifica rapida

Qual è la differenza tra matches() e find() in Matcher?

Riepilogo: espressioni regolari con Pattern e Matcher

Punti chiave:

  • Pattern.compile() compila una regex; Matcher la verifica rispetto alle stringhe
  • matches() valida l'intera stringa; find() cerca le occorrenze
  • I gruppi di cattura () estraggono sottostringhe; vi si accede con group(n) o group("name")
  • I gruppi denominati (?...) rendono i pattern più leggibili
  • replaceAll() e split() accettano pattern regex per una manipolazione flessibile del testo
  • Utilizzi i flag Pattern.CASE_INSENSITIVE, MULTILINE e DOTALL per modificare il comportamento della ricerca

Domande Frequenti

La lezione «Espressioni regolari con Pattern e Matcher» è gratuita?

Sì — il testo completo di «Espressioni regolari con Pattern e Matcher» è gratuito qui sul web. Per esercitarvi in modo interattivo (un editor di codice integrato e un tutor IA 24/7) e sbloccare il resto del corso Java Academy, passa a CoddyKit PRO. Il corso Java Academy include 4 lezioni in totale.

Cosa imparerò in «Espressioni regolari con Pattern e Matcher»?

Convalidi indirizzi email, estragga sottostringhe e sostituisca pattern utilizzando le regex di Java. Eserciti Java Academy con codice pratico che esegui direttamente nel browser, e un tutor IA 24/7 risponde alle tue domande mentre lavori sulla lezione.

Ho bisogno di esperienza per iniziare Java Academy?

Non è richiesta alcuna esperienza precedente. Java Academy su CoddyKit è strutturato per principianti e studenti avanzati, quindi puoi iniziare da qui o dall'inizio e procedere al tuo ritmo. Questa è la lezione 4 di 4.

Quanto tempo richiede la lezione «Espressioni regolari con Pattern e Matcher»?

La maggior parte delle lezioni CoddyKit richiede circa 5–10 minuti. Ogni lezione è breve e interattiva, quindi fai progressi costanti e riprendi esattamente da dove hai lasciato su web e app.

Posso scrivere ed eseguire codice in questa lezione Java Academy?

Sì. Ogni lezione Java Academy include un editor di codice integrato, quindi scrivi ed esegui codice reale direttamente nel tuo browser e ricevi feedback istantaneo dall'IA — nessuna configurazione locale necessaria.

Tutte le lezioni di questo corso

  1. Immutabilità di String e string pool
  2. StringBuilder per concatenazioni efficienti
  3. Text block e String.format
  4. Espressioni regolari con Pattern e Matcher
← Torna a Java Academy