Expresiones regulares en Java

En PC Resumen hablaremos de como funcionan las expresiones regulares en Java. Las expresiones regulares son secuencias de caracteres y símbolos que definen un conjunto de cadenas. Son útiles para validar la entrada y asegurar que los datos estén en un formato específico. Una aplicación de las expresiones regulares es facilitar la construcción de un compilador. A menudo se utiliza una expresión regular larga y compleja para validar sintaxis de un programa. Si el código del programa no coincide con la expresión regular, el compilador sabe que hay un error de sintaxis en el código.

La clase String proporciona diferentes métodos para realizar operaciones con expresiones regulares, siendo la más simple la operación de concordancia. El método matches recibe una cadena que especifica la expresión regular, igualando el contenido del objeto String que llama al método con la expresión regular. Este método devuelve un booleano indicando si ha habido concordancia o no.

Una expresión regular está formada por caracteres literales y símbolos especiales. la tabla siguiente especifica algunas clases predefinidas de caracteres que pueden utilizarse con las expresiones regulares. Una clase de carácter es una secuencia de escape que representa a un grupo de caracteres. Un dígito es cualquier carácter numérico. Un carácter de palabra es cualquier letra, cualquier dígito o el carácter de guión bajo. Un carácter de espacio en blanco, es un espacio, tabulador, retorno de carro nueva línea o avance de página. cada clase de carácter iguala con un solo carácter en la cadena que intentamos hacer concordar con la expresión regular.

Clases predefinidas de caracteres

Caracter	Concuerda con
\d	Cualquier dígito
\w	Cualquier carácter de palabra
\s	Cualquier espacio en blanco
\D	Cualquier carácter que no sea dígito
\W	Cualquier carácter que no sea de palabra
\S	Cualquier carácter que no sea un espacio en blanco

Las expresiones regulares no están limitadas a estas clases predefinidas de caracteres. Las expresiones utilizan diferentes operadores y otras formas de notación para igualar patrones complejos. Veremos algunas de estas técnicas en la aplicación siguiente, lo valida la entrada del usuario mediante expresiones regulares.

Observación: Esta aplicación no está diseñada para igualar todos los posibles datos de entrada del usuario.

public class ValidacionEntrada {
    public static boolean validarNombre(String nombre) {
        return nombre.matches("[A-Z][a-zA-Z]*");
    }

    public static boolean validarApellido(String apellido) {
        return apellido.matches( "[a-zA-z]+([ '-][a-zA-Z]+)*" );
    } 

    public static boolean validarDireccion(String direccion) {
        return direccion.matches("([a-zA-Z]+|[a-zA-Z]+\\s[a-zA-Z]+)+\\s+\\d");
    }

    public static boolean validarCiudad(String ciudad) {
        return ciudad.matches("([a-zA-Z]+|[a-zA-Z]+\\s[a-zA-Z]+)");
    }

    public static boolean validarCP(String cp) {
        return cp.matches("\\d{5}");
    }

    public static boolean validarTelefono(String telefono) {
        return telefono.matches("[1-9]\\d{8}");
    }
}

import java.util.Scanner;

public class Validacion {
    public static void main(String[] args) {
        Scanner scanner = new Scanner(System.in);
        System.out.println("Escribe el nombre:");
        String nombre = scanner.nextLine();
        System.out.println("Escribe el apellido:");
        String apellido = scanner.nextLine();
        System.out.println("Escribe la direccion:");
        String direccion = scanner.nextLine();
        System.out.println("Escribe la ciudad:");
        String ciudad = scanner.nextLine();
        System.out.println("Escribe el código postal:");
        String cp = scanner.nextLine();
        System.out.println("Escribe el teléfono:");
        String telefono = scanner.nextLine();
        System.out.println("\nValidar resultado:");
        if (!ValidacioEntrada.validarNombre(nombre)) {
            System.out.println("Nombre inválido");
        } else if (!ValidacioEntrada.validarApellido(apellido)) {
            System.out.println("Apellido inválido");
        } else if (!ValidacioEntrada.validarDireccion(direccion)) {
            System.out.println("Dirección inválida");
        } else if (!ValidacioEntrada.validarCiudad(ciudad)) {
            System.out.println("Ciudad inválida");
        } else if (!ValidacioEntrada.validarCP(cp)) {
            System.out.println("Código postal inválido");
        } else if (!ValidacioEntrada.validarTelefono(telefono)) {
            System.out.println("Número de teléfono inválido");
        } else {
            System.out.println("La entrada es válida. Gracias.");
        }
    }
}

En este programa es valida la entrada del usuario. Para hacer que concuerde un conjunto de caracteres que no tiene una clase predefinida utilizan los corchetes ([]). Por ejemplo, el patrón "[aeiou]" representa una sola vocal. Los rangos de caracteres pueden representarse mediante un guión entre dos caracteres. En el ejemplo, "[A-Z]" representa una sola letra mayúscula. Si el primer carácter entre los corchetes es "^", la expresión acepta cualquier carácter diferente a los que se indican. Los rangos en las clases de caracteres se determinan mediante los valores enteros de las letras. Por ejemplo "[A-Za-z]" concuerda con todas las letras mayúsculas y minúsculas. El rango "[A-z]" concuerda con todas las letras y también concuerda con los caracteres que tengan un valor mayor que "Z" y más pequeño que "a" (consultar la tabla ASCII). Al igual que las clases predefinidas, las clases delimitadas entre corchetes concuerdan con un solo carácter en la búsqueda.

En la línea:

return nombre.matches("[A-Z][a-zA-Z]*");

El asterisco situado después de la segunda clase indica que puede concordar con cualquier número de letras. En general cuando aparece el operador "*", el programa intenta hacer que concuerden cero o más ocurrencias de la subexpresión. El operador "+" intenta hacer que concuerden una o más ocurrencias. Por lo tanto, "A*" y "A+" concordarán con "AAA" pero sólo "A*" concordará con una cadena vacía.

La validación del apellido:

return apellido.matches("[a-zA-z]+([ '-][a-zA-Z]+)*");

Concuerda con cualquier número de letras divididas por espacios, apóstrofes o guiones.

En la expresión:

return direccion.matches("([a-zA-Z]+|[a-zA-Z]+\\s[a-zA-Z]+)+\\s+\\d");

El carácter "|" concuerda con la expresión a la derecha o la izquierda (es una 'o'). por ejemplo "Hola (Juan | Juana)" concuerda tanto con "Hola Juan" como con "Hola Joana". Los paréntesis se utilizan para agrupar partes de la expresión regular. En este ejemplo la parte izquierda concuerda con una sola palabra y la parte derecha concuerda con dos palabras separadas por cualquier cantidad de espacios en blanco.

Software

Expresiones regulares en Java

Clases predefinidas de caracteres