Java Academy · Aula

Localizando e fazendo correspondências

matches, find, lookingAt.

Localizando e fazendo correspondências é uma aula grátis de Java Academy no CoddyKit. Esta é a aula 2 de 4. Você pode ler a aula completa abaixo gratuitamente — depois pratica ao vivo no navegador com um editor de código integrado e um tutor de IA 24/7. Faz parte do caminho de aprendizado de Java Academy, e seu progresso é sincronizado entre a web e o app CoddyKit. O curso de Java Academy inclui 4 aulas no total.

Três maneiras de aplicar um padrão

O objeto de correspondência Matcher oferece três testes principais:

matches() exige que a entrada inteira corresponda.
lookingAt() exige uma correspondência no início.
find() procura uma correspondência em qualquer lugar.

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: entrada inteira

matches retorna verdadeiro somente se a cadeia inteira estiver de acordo com o padrão, como se estivesse ancorada nas duas extremidades.

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: correspondência no início

lookingAt é bem-sucedido quando a entrada começa com uma correspondência, mesmo que o restante não corresponda.

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: correspondência em qualquer lugar

find percorre a entrada para frente em busca da próxima correspondência. Retorna verdadeiro se houver uma a partir da posição atual.

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());
    }
}

Percorrendo todas as correspondências com find

Chamar find em um laço percorre todas as correspondências na entrada.

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());
        }
    }
}

Posições da correspondência: start e end

Depois de uma correspondência bem-sucedida, start() e end() fornecem o intervalo de índices, e group() fornece o texto correspondente.

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() + ")");
        }
    }
}

Âncoras com find

As âncoras ^ e $ permitem que find se comporte como uma verificação de início ou fim. Aqui, ^\d+ corresponde apenas a dígitos no início exato.

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());
    }
}

Redefinindo um objeto de correspondência

reset() retorna o objeto de correspondência ao início, para que você possa percorrer a mesma entrada novamente.

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);
    }
}

Reutilizando um objeto de correspondência com uma nova entrada

reset(newInput) reutiliza o mesmo objeto de correspondência com uma cadeia diferente, evitando uma nova alocação.

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());
    }
}

Resumo: matches versus find

Escolha conforme a intenção: use matches para validar um valor completo (como um ID inteiro) e find para extrair ou localizar partes dentro de um texto maior.

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());
    }
}

Contando correspondências

Uma tarefa comum é contar ocorrências. Use find em um laço e incremente um contador.

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ção rápida

Qual método exige que a cadeia de entrada inteira corresponda ao padrão?

Recapitulação

Você localizou correspondências:

matches testa a entrada inteira; lookingAt testa o início; find procura em qualquer lugar.
Use find em um laço para percorrer todas as correspondências e ler group, start e end.
reset retorna ao início, e reset(input) reutiliza o objeto de correspondência com um novo texto.

Perguntas Frequentes

A aula “Localizando e fazendo correspondências” é grátis?

Sim — o texto completo de “Localizando e fazendo correspondências” é grátis para ler aqui na web. Para praticá-la interativamente (um editor de código integrado e um tutor de IA 24/7) e desbloquear o restante do curso de Java Academy, atualize para CoddyKit PRO. O curso de Java Academy inclui 4 aulas no total.

O que vou aprender em “Localizando e fazendo correspondências”?

matches, find, lookingAt. Você pratica Java Academy com código prático que executa diretamente no navegador, e um tutor de IA 24/7 responde suas dúvidas enquanto trabalha na aula.

Preciso ter experiência prévia para começar Java Academy?

Nenhuma experiência prévia é necessária. Java Academy no CoddyKit é estruturado para alunos iniciantes até avançados, então você pode começar aqui ou desde o início e aprender no seu ritmo. Esta é a aula 2 de 4.

Quanto tempo leva a aula “Localizando e fazendo correspondências”?

A maioria das aulas CoddyKit leva cerca de 5–10 minutos. Cada uma é compacta e interativa, então você faz progresso constante e retoma exatamente de onde parou entre web e app.

Posso escrever e executar código nesta aula de Java Academy?

Sim. Cada aula de Java Academy inclui um editor de código integrado, então você escreve e executa código real direto no navegador e recebe feedback de IA instantaneamente — nenhuma configuração local necessária.

Todas as aulas deste curso

← Voltar para Java Academy