Cómo comprobar si una cadena coincide con una expresión regular en Java

Introducción

En este laboratorio, aprenderás cómo verificar si una cadena coincide con una expresión regular en Java. Comenzaremos entendiendo los conceptos básicos de las expresiones regulares y cómo crear un patrón simple utilizando el paquete java.util.regex.

Luego, explorarás las clases Pattern y Matcher para realizar operaciones de coincidencia. Finalmente, aplicarás tus conocimientos para probar patrones de expresiones regulares con la entrada del usuario, ganando experiencia práctica en el uso de expresiones regulares para la validación y manipulación de cadenas en Java.

Crear un patrón básico de expresiones regulares

En este paso, comenzaremos por entender qué son las expresiones regulares (regex) y cómo crear un patrón básico en Java.

Las expresiones regulares son herramientas poderosas utilizadas para coincidir y manipular cadenas de texto. Puedes pensar en ellas como un mini-lenguaje para describir patrones en el texto. Son increíblemente útiles para tareas como buscar texto específico, validar formatos de entrada (como direcciones de correo electrónico o números de teléfono) y reemplazar texto basado en patrones.

En Java, las expresiones regulares son manejadas por el paquete java.util.regex. Las dos clases principales que utilizaremos son Pattern y Matcher.

Pattern: Esta clase representa una expresión regular compilada. Compilas una cadena de regex en un objeto Pattern.
Matcher: Esta clase se utiliza para realizar operaciones de coincidencia contra una cadena de entrada interpretando un Pattern.

Vamos a crear un simple programa de Java para definir e imprimir un patrón básico de regex.

Abre el archivo HelloJava.java en el editor WebIDE si no está abierto.
Reemplaza todo el contenido del archivo con el siguiente código:
```
import java.util.regex.Pattern;

public class HelloJava {
    public static void main(String[] args) {
        // Define a simple regex pattern to match the word "Java"
        String regexPattern = "Java";

        // Compile the regex pattern
        Pattern pattern = Pattern.compile(regexPattern);

        // Print the pattern
        System.out.println("Our regex pattern is: " + pattern.pattern());
    }
}
```
Veamos las nuevas partes:
- import java.util.regex.Pattern;: Esta línea importa la clase Pattern, que necesitamos para trabajar con regex.
- String regexPattern = "Java";: Esta línea define una simple variable de cadena regexPattern que contiene nuestra expresión regular. En este caso, el patrón es simplemente la palabra literal "Java".
- Pattern pattern = Pattern.compile(regexPattern);: Aquí es donde compilamos nuestra cadena de regex en un objeto Pattern. El método Pattern.compile() toma la cadena de regex como argumento y devuelve un objeto Pattern.
- System.out.println("Our regex pattern is: " + pattern.pattern());: Esta línea imprime la cadena de regex original que se utilizó para crear el objeto Pattern. El método pattern() del objeto Pattern devuelve la cadena de regex.
Guarda el archivo (Ctrl+S o Cmd+S).
Ahora, vamos a compilar nuestro programa. Abre la Terminal en la parte inferior del WebIDE y asegúrate de estar en el directorio ~/project. Ejecuta el siguiente comando:
```
javac HelloJava.java
```
Si no hay errores, se creará un archivo HelloJava.class en el directorio ~/project.
Finalmente, ejecuta el programa compilado:
```
java HelloJava
```
Deberías ver la siguiente salida:
```
Our regex pattern is: Java
```
Esto confirma que nuestro patrón básico de regex se ha definido y compilado con éxito. En el siguiente paso, utilizaremos este patrón para encontrar coincidencias en una cadena dada.

Utilizar las clases Pattern y Matcher

En este paso, aprenderemos cómo utilizar la clase Matcher junto con nuestro Pattern para encontrar ocurrencias del patrón dentro de una cadena de entrada dada.

Como discutimos en el paso anterior, la clase Pattern representa la expresión regular compilada. La clase Matcher es lo que usamos para realizar realmente las operaciones de búsqueda en una cadena de entrada específica utilizando ese patrón compilado.

Así es cómo generalmente funciona el proceso:

Compilar la expresión regular: Crea un objeto Pattern a partir de tu cadena de expresión regular utilizando Pattern.compile().
Crear un Matcher: Obtén un objeto Matcher llamando al método matcher() en el objeto Pattern, pasando la cadena de entrada en la que deseas buscar.
Realizar la coincidencia: Utiliza métodos del objeto Matcher para encontrar coincidencias. Métodos comunes incluyen find() (para encontrar la siguiente coincidencia) y matches() (para verificar si toda la cadena de entrada coincide con el patrón).

Modifiquemos nuestro programa HelloJava.java para utilizar un Matcher para encontrar la palabra "Java" en una frase de muestra.

Abre el archivo HelloJava.java en el editor WebIDE.
Reemplaza el código existente con lo siguiente:
```
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class HelloJava {
    public static void main(String[] args) {
        // Define a simple regex pattern to match the word "Java"
        String regexPattern = "Java";

        // The input string to search within
        String inputString = "Hello, Java! Welcome to Java programming.";

        // Compile the regex pattern
        Pattern pattern = Pattern.compile(regexPattern);

        // Create a Matcher object
        Matcher matcher = pattern.matcher(inputString);

        // Find and print the matches
        System.out.println("Searching for pattern: '" + regexPattern + "' in string: '" + inputString + "'");

        while (matcher.find()) {
            System.out.println("Found match at index: " + matcher.start());
        }
    }
}
```
Esto es lo nuevo:
- import java.util.regex.Matcher;: Importamos la clase Matcher.
- String inputString = "Hello, Java! Welcome to Java programming.";: Definimos la cadena en la que queremos buscar.
- Matcher matcher = pattern.matcher(inputString);: Creamos un objeto Matcher llamando al método matcher() en nuestro objeto pattern y pasando la inputString.
- while (matcher.find()) { ... }: Este bucle utiliza el método find() del Matcher. El método find() intenta encontrar la siguiente subsecuencia de la secuencia de entrada que coincide con el patrón. Devuelve true si se encuentra una coincidencia y false en caso contrario. El bucle while continúa mientras find() devuelva true.
- System.out.println("Found match at index: " + matcher.start());: Dentro del bucle, si se encuentra una coincidencia, matcher.start() devuelve el índice de inicio de la subsecuencia coincidente en la cadena de entrada. Imprimimos este índice.
Guarda el archivo (Ctrl+S o Cmd+S).
Compila el programa modificado en la Terminal:
```
javac HelloJava.java
```
Ejecuta el programa compilado:
```
java HelloJava
```
Deberías ver una salida similar a esta:
```
Searching for pattern: 'Java' in string: 'Hello, Java! Welcome to Java programming.'
Found match at index: 7
Found match at index: 27
```
Esta salida muestra que nuestro programa encontró con éxito dos ocurrencias de la palabra "Java" en la cadena de entrada y que imprimió el índice de inicio de cada coincidencia.

Ahora has utilizado con éxito las clases Pattern y Matcher para encontrar un patrón específico dentro de una cadena. En el siguiente paso, haremos que este programa sea interactivo permitiendo que el usuario ingrese la cadena en la que buscar.

Probar expresiones regulares con entrada del usuario

En este último paso, haremos que nuestro programa de expresiones regulares sea interactivo permitiendo que el usuario ingrese la cadena en la que desea buscar. Esto hará que el programa sea más flexible y demostrará cómo combinar expresiones regulares con la interacción del usuario.

Utilizaremos la clase Scanner, que quizás recuerdes del "Tu primer laboratorio de Java", para leer la entrada del usuario.

Abre el archivo HelloJava.java en el editor WebIDE.

Reemplaza el código existente con lo siguiente:

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

public class HelloJava {
    public static void main(String[] args) {
        // Define a simple regex pattern to match the word "Java"
        String regexPattern = "Java";

        // Create a Scanner object to read user input
        Scanner scanner = new Scanner(System.in);

        // Prompt the user to enter a string
        System.out.print("Enter the string to search within: ");
        String inputString = scanner.nextLine();

        // Compile the regex pattern
        Pattern pattern = Pattern.compile(regexPattern);

        // Create a Matcher object
        Matcher matcher = pattern.matcher(inputString);

        // Find and print the matches
        System.out.println("Searching for pattern: '" + regexPattern + "' in string: '" + inputString + "'");

        boolean found = false;
        while (matcher.find()) {
            System.out.println("Found match at index: " + matcher.start());
            found = true;
        }

        if (!found) {
            System.out.println("No match found.");
        }

        // Close the scanner
        scanner.close();
    }
}

Estos son los cambios que hicimos:

import java.util.Scanner;: Importamos la clase Scanner.
Scanner scanner = new Scanner(System.in);: Creamos un objeto Scanner para leer la entrada desde la consola.
System.out.print("Enter the string to search within: ");: Pedimos al usuario que ingrese la cadena.
String inputString = scanner.nextLine();: Leemos toda la línea de entrada del usuario y la almacenamos en la variable inputString.
Agregamos una variable boolean found = false; y un bloque if (!found) para imprimir un mensaje si no se encuentran coincidencias.
scanner.close();: Cerramos el Scanner para liberar recursos del sistema.

Guarda el archivo (Ctrl+S o Cmd+S).
Compila el programa en la Terminal:
```
javac HelloJava.java
```
Ejecuta el programa:
```
java HelloJava
```

El programa ahora esperará a que ingreses una cadena. Escribe una cadena que contenga la palabra "Java" (o no) y presiona Enter.

Por ejemplo, si ingresas:

Learning Java is fun!

La salida será:

Enter the string to search within: Learning Java is fun!
Searching for pattern: 'Java' in string: 'Learning Java is fun!'
Found match at index: 9

Si ingresas:

Python is also great.

La salida será:

Enter the string to search within: Python is also great.
Searching for pattern: 'Java' in string: 'Python is also great.'
No match found.

Ahora has creado con éxito un programa interactivo de Java que utiliza expresiones regulares para buscar un patrón en una cadena proporcionada por el usuario. Este es un ejemplo práctico de cómo se pueden utilizar las expresiones regulares en aplicaciones del mundo real.

Resumen

En este laboratorio, comenzamos por comprender los fundamentos de las expresiones regulares (regex) en Java, centrándonos en el paquete java.util.regex. Aprendimos que las expresiones regulares son una herramienta poderosa para la coincidencia y manipulación de patrones en cadenas, y que las clases clave son Pattern y Matcher. Luego, practicamos la creación de un patrón básico de expresiones regulares definiendo una cadena simple y compilándola en un objeto Pattern utilizando Pattern.compile(), demostrando cómo definir e imprimir un patrón básico de expresiones regulares en un programa de Java.