Java Academy · Lezione

Ricerca e corrispondenza

matches, find, lookingAt

Lezione 2 di 413 passaggi

Ricerca e corrispondenza è una lezione Java Academy gratuita su CoddyKit. Questa è la lezione 2 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.

Tre modi per applicare un pattern

Matcher offre tre verifiche fondamentali:

matches() richiede che corrisponda l'input intero.
lookingAt() richiede una corrispondenza all'inizio.
find() cerca una corrispondenza ovunque.

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

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("\\d+").matcher("42");
        System.out.println(m.matches());
    }
}

matches: input completo

matches restituisce true solo se l'intera stringa è conforme al pattern, come se fosse delimitata da un ancoraggio a entrambe le estremità.

import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("\\d+");
        System.out.println(p.matcher("123").matches());
        System.out.println(p.matcher("123abc").matches());
    }
}

lookingAt: corrispondenza all'inizio

lookingAt ha successo se l'input inizia con una corrispondenza, anche se il resto non corrisponde.

import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("\\d+");
        System.out.println(p.matcher("123abc").lookingAt());
        System.out.println(p.matcher("abc123").lookingAt());
    }
}

find: corrispondenza ovunque

find scorre in avanti alla ricerca della corrispondenza successiva. Restituisce true se ne esiste una a partire dalla posizione corrente.

import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("\\d+");
        System.out.println(p.matcher("abc123def").find());
    }
}

Iterare su tutte le corrispondenze con find

Chiamando find in un ciclo si attraversano tutte le corrispondenze presenti nell'input.

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

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("\\d+").matcher("a1bb22ccc333");
        while (m.find()) {
            System.out.println(m.group());
        }
    }
}

Posizioni della corrispondenza: start ed end

Dopo una corrispondenza riuscita, start() ed end() indicano l'intervallo di indici, mentre group() restituisce il testo corrispondente.

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

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("\\d+").matcher("abc123");
        if (m.find()) {
            System.out.println(m.group() + " at [" + m.start() + "," + m.end() + ")");
        }
    }
}

Ancoraggi con find

Gli ancoraggi ^ e $ consentono a find di comportarsi come un controllo di inizio o fine. Qui ^\d+ corrisponde solo alle cifre all'inizio dell'input.

import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        Pattern p = Pattern.compile("^\\d+");
        System.out.println(p.matcher("123abc").find());
        System.out.println(p.matcher("abc123").find());
    }
}

Reimpostare un Matcher

reset() riporta il matcher all'inizio, così può analizzare nuovamente lo stesso input.

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

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("a").matcher("aaa");
        int first = 0;
        while (m.find()) first++;
        m.reset();
        int second = 0;
        while (m.find()) second++;
        System.out.println(first + " " + second);
    }
}

Riutilizzare un Matcher con un nuovo input

reset(newInput) riutilizza lo stesso oggetto matcher con una stringa diversa, evitando una nuova allocazione.

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

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("\\d+").matcher("abc");
        m.reset("xyz789");
        System.out.println(m.find());
        System.out.println(m.group());
    }
}

Riepilogo di matches e find

Scelga in base all'obiettivo: usi matches per convalidare un valore completo, ad esempio un ID intero, e find per estrarre o individuare parti all'interno di un testo più ampio.

import java.util.regex.Pattern;

public class Main {
    public static void main(String[] args) {
        Pattern id = Pattern.compile("[A-Z]{2}\\d{4}");
        System.out.println(id.matcher("AB1234").matches());
        System.out.println(id.matcher("id=AB1234;").find());
    }
}

Contare le corrispondenze

Un'attività comune consiste nel contare le occorrenze. Esegua un ciclo con find e incrementi un contatore.

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

public class Main {
    public static void main(String[] args) {
        Matcher m = Pattern.compile("o").matcher("foo boo zoo");
        int count = 0;
        while (m.find()) count++;
        System.out.println(count);
    }
}

Verifica rapida

Quale metodo richiede che l'intera stringa di input corrisponda al pattern?

Rispondi nella lezione interattiva

Riepilogo

Ha individuato le corrispondenze:

matches verifica l'intero input; lookingAt verifica l'inizio; find cerca ovunque.
Esegua un ciclo con find per iterare su tutte le corrispondenze e leggere group, start ed end.
reset riporta il matcher all'inizio, mentre reset(input) lo riutilizza con un nuovo testo.

Gratis per iniziare

Impara Java con un tutor IA — gratis

Scrivi ed esegui vero codice nel tuo browser, ricevi aiuto istantaneo da un tutor IA disponibile 24/7, e riprendi da dove hai lasciato sul web o nell'app.

Corsi: 104
Lezioni: 374

Inizia a imparare gratis Visualizza il corso completo

Domande Frequenti

La lezione «Ricerca e corrispondenza» è gratuita?

Sì — il testo completo di «Ricerca e corrispondenza» è 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 «Ricerca e corrispondenza»?

matches, find, lookingAt 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 2 di 4.

Quanto tempo richiede la lezione «Ricerca e corrispondenza»?

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

Compilazione dei pattern
Ricerca e corrispondenza
Gruppi di cattura
Sostituzione con le espressioni regolari

← Torna a Java Academy