Java Academy · Lección

Búsqueda y coincidencias

matches, find, lookingAt

Búsqueda y coincidencias es una lección gratuita de Java Academy en CoddyKit. Esta es la lección 2 de 4. Puedes leer la lección completa abajo gratuitamente — luego la practicas en el navegador con un editor de código integrado y un tutor de IA 24/7. Forma parte de la ruta de aprendizaje de Java Academy, y tu progreso se sincroniza en la web y la app de CoddyKit. El curso de Java Academy incluye 4 lecciones en total.

Tres formas de aplicar un patrón

Matcher ofrece tres pruebas principales:

matches() requiere que coincida la entrada completa.
lookingAt() requiere una coincidencia al principio.
find() busca una coincidencia en cualquier parte.

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 completa

matches devuelve true solo si toda la cadena se ajusta al patrón, como si este tuviera anclas en ambos extremos.

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: coincidencia al principio

lookingAt tiene éxito si la entrada comienza con una coincidencia, aunque el resto no coincida.

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: coincidencia en cualquier parte

find avanza por la entrada en busca de la siguiente coincidencia. Devuelve true si existe alguna desde la posición actual en adelante.

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

Iterar sobre todas las coincidencias con find

Llamar a find dentro de un bucle recorre todas las coincidencias de la 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());
        }
    }
}

Posiciones de coincidencia: start y end

Después de una coincidencia correcta, start() y end() indican el intervalo de índices, y group() devuelve el texto coincidente.

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

Anclas con find

Las anclas ^ y $ permiten que find se comporte como una comprobación del principio o del final. Aquí, ^\d+ solo coincide con dígitos al principio exacto.

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

Restablecer un Matcher

reset() devuelve el matcher al principio para que pueda analizar la misma entrada otra vez.

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

Reutilizar un Matcher con una entrada nueva

reset(newInput) reutiliza el mismo objeto matcher con una cadena diferente, evitando una nueva asignación.

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

Resumen de matches frente a find

Elija según su objetivo: use matches para validar un valor completo (como un ID entero) y find para extraer o localizar partes dentro de un texto más grande.

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

Contar coincidencias

Una tarea habitual es contar las apariciones. Ejecute find en un bucle e incremente un 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);
    }
}

Comprobación rápida

¿Qué método requiere que toda la cadena de entrada coincida con el patrón?

Recapitulación

Ha localizado coincidencias:

matches comprueba toda la entrada; lookingAt comprueba el principio; find busca en cualquier parte.
Ejecute find en un bucle para iterar sobre todas las coincidencias y leer group, start y end.
reset vuelve al principio y reset(input) reutiliza el matcher con un texto nuevo.

Preguntas frecuentes

¿La lección «Búsqueda y coincidencias» es gratis?

Sí — el texto completo de «Búsqueda y coincidencias» es gratis para leer aquí en la web. Para practicarla de forma interactiva (editor de código integrado y tutor de IA 24/7) y desbloquear el resto del curso de Java Academy, actualiza a CoddyKit PRO. El curso de Java Academy incluye 4 lecciones en total.

¿Qué aprenderé en «Búsqueda y coincidencias»?

matches, find, lookingAt Practicas Java Academy con código real que ejecutas directamente en el navegador, y un tutor de IA 24/7 responde tus preguntas mientras trabajas en la lección.

¿Necesito experiencia previa para empezar Java Academy?

No se requiere experiencia previa. Java Academy en CoddyKit está estructurado para principiantes hasta estudiantes avanzados, así que puedes empezar aquí o desde el inicio y avanzar a tu ritmo. Esta es la lección 2 de 4.

¿Cuánto tiempo toma la lección «Búsqueda y coincidencias»?

La mayoría de las lecciones de CoddyKit toman alrededor de 5–10 minutos. Cada una es compacta e interactiva, así que avanzas constantemente y retomas exactamente por donde dejaste en la web y la app.

¿Puedo escribir y ejecutar código en esta lección de Java Academy?

Sí. Cada lección de Java Academy incluye un editor de código integrado, así que escribes y ejecutas código real directamente en tu navegador y obtienes retroalimentación instantánea de IA — sin configuración local necesaria.

Todas las lecciones de este curso

← Volver a Java Academy