¿Qué es String.matches() en Java y cómo funciona con expresiones regulares?

Un día estaba intentando validar un formato específico en una cadena de texto, pero no sabía cómo. De hecho, también quería asegurarme de que un número de teléfono y un email cumplían con unas reglas. Cuando ya estaba por rendirme, encontré String.matches() en Java y me ayudó a comprobar fácilmente si una cadena coincidía de forma exacta con un patrón definido, todo por medio de las expresiones regulares. Voy a enseñarte su funcionamiento.

¿Qué es String.matches() en Java?

String.matches() en Java es un método de la clase String que puedes usar para verificar si una cadena coincide exactamente con un patrón definido mediante una expresión regular. Algo que no puedes pasar por alto es que este método devuelve un valor booleano:

• true cuando la cadena coincide con la expresión regular.
• false en caso de que no haya coincidencia.

Sintaxis del método:

public boolean matches(String regex)

Parámetros:

• regex: Una expresión regular que define el patrón a buscar.

Valor de retorno: Un booleano (true o false).

¿Cómo funciona String.matches() en Java?

Verifica si una cadena contiene solo letras

Para que te asegures de que una cadena solo contenga letras del alfabeto (sin números ni símbolos), te aconsejo hacer esto:

public class MatchesExample {
    public static void main(String[] args) {
        String texto = "Java";
        System.out.println(texto.matches("[a-zA-Z]+")); // true

        String texto2 = "Java123";
        System.out.println(texto2.matches("[a-zA-Z]+")); // false
    }
}

En este caso:

• [a-zA-Z]+ es una expresión regular que significa “una o más letras”.

Valida un número de teléfono

Ahora, cuando vayas a validar un formato de número de teléfono con exactamente 9 dígitos, puedes hacerlo así:

public class MatchesExample {
    public static void main(String[] args) {
        String telefono = "123456789";
        System.out.println(telefono.matches("\\d{9}")); // true

        String telefono2 = "12345";
        System.out.println(telefono2.matches("\\d{9}")); // false
    }
}

Aquí sucedió esto:

• \\d{9} indica “exactamente 9 dígitos”.

Comprueba si una cadena empieza con una letra específica

De esta manera que te explico aquí, podrás validar que una cadena comience con la letra “J”:

public class MatchesExample {
    public static void main(String[] args) {
        String texto = "Java es genial";
        System.out.println(texto.matches("J.*")); // true

        String texto2 = "C es genial";
        System.out.println(texto2.matches("J.*")); // false
    }
}

Mira cómo queda:

• J.* significa “empieza con J y puede tener cualquier cosa después”.

Valida una dirección de correo electrónico

Cuando vayas a comprobar un email simple, lo mejor es que uses una expresión regular como esta:

public class MatchesExample {
    public static void main(String[] args) {
        String email = "[email protected]";
        System.out.println(email.matches("[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}")); // true

        String emailInvalido = "[email protected]";
        System.out.println(emailInvalido.matches("[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}")); // false
    }
}

¿Te diste cuenta? Mira que usamos una expresión regular que cubre el formato básico de un correo electrónico.

Consejos para aprovechar String.matches() en Java

Voy a dejarte algunos consejos que a mí me sirvieron para aprovechar bastante String.matches() en Java:

1. No abuses de las expresiones regulares complejas: Aunque son muy buenas, te cuento que a veces son difíciles de leer y mantener, entonces no es bueno que las uses tanto.
2. Valida los datos de entrada: Asegúrate de que las cadenas no sean null antes de llamar a matches() para evitar errores.
3. Comprende las expresiones regulares: Si apenas estás empezando, lo mejor es que comiences con patrones simples y ve avanzando progresivamente.
4. Usa herramientas de prueba: Plataformas como regex101 te ayudan a probar expresiones regulares antes de implementarlas.

Conoce las diferencias entre String.matches() y otros métodos de validación

Ya te expliqué lo fantástico que puede llegar a ser String.matches(), pero quiero que veas que hay otras alternativas para trabajar con expresiones regulares en Java, como:

• Pattern y Matcher: Estas te proporcionan más control sobre las coincidencias y permiten encontrar patrones en diferentes partes de una cadena.
• String.contains(): Con esta compruebas si una cadena contiene una subcadena específica, sin expresiones regulares.

Aunque sí te diré que, desde mi punto de vista, para verificar coincidencias exactas con patrones simples, String.matches() en Java es la solución más directa y fácil de usar.

Espero haberte ayudado a comprender que con String.matches() en Java puedes validar cadenas de texto usando expresiones regulares de manera rápida y sencilla. Ya te enseñé a verificar formatos de teléfono y validar correos electrónicos, ahora ponlo en práctica.

Con nosotros puedes convertirte en el experto en desarrollo de aplicaciones que siempre has querido ser. Solo debes apuntarte a nuestro Bootcamp de Java Full Stack en KeepCoding. En poco tiempo, aprenderás a construir buenas aplicaciones, preparándote para una carrera de éxito en el sector IT. ¡Da el primer paso hacia tu futuro!