Expresiones Regulares en Java

Expresiones regulares o Regex (en resumen) en Java es una API para definir patrones de string que se pueden usar para buscar, manipular y editar una string en Java. La validación de correo electrónico y las contraseñas son algunas áreas de strings donde Regex se usa ampliamente para definir las restricciones. Las expresiones regulares se proporcionan en el paquete java.util.regex . Este consta de 3 clases y 1 interfaz . El paquete java.util.regex consta principalmente de las siguientes tres clases, como se muestra a continuación en formato tabular de la siguiente manera:

Regex en Java nos proporciona 3 clases y 1 interfaz que se enumeran a continuación de la siguiente manera:

1. Clase de patrón
2. Clase de emparejamiento
3. Clase PatternSyntaxException
4. Interfaz de resultado de coincidencia

Se puede interpretar una mayor comprensión a partir de la imagen proporcionada a continuación de la siguiente manera:

Clase 1: Clase de patrón 

Esta clase es una compilación de expresiones regulares que se pueden usar para definir varios tipos de patrones, sin proporcionar constructores públicos. Esto se puede crear invocando el método compile() que acepta una expresión regular como primer argumento, por lo que devuelve un patrón después de la ejecución.

Ejemplo: clase de patrón 

// Java Program Demonstrating Working of matches() Method
// Pattern class
 
// Importing Pattern class from java.util.regex package
import java.util.regex.Pattern;
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String args[])
    {
 
        // Following line prints "true" because the whole
        // text "geeksforgeeks" matches pattern
        // "geeksforge*ks"
        System.out.println(Pattern.matches(
            "geeksforge*ks", "geeksforgeeks"));
 
        // Following line prints "false" because the whole
        // text "geeksfor" doesn't match pattern "g*geeks*"
        System.out.println(
            Pattern.matches("g*geeks*", "geeksfor"));
    }
}

true
false

Clase 2: Clase de emparejamiento

Este objeto se utiliza para realizar operaciones de coincidencia para una string de entrada en java, interpretando así los patrones explicados anteriormente. Esto tampoco define a los constructores públicos. Esto se puede implementar invocando un matcher() en cualquier objeto de patrón.

Nota: T Pattern.matches() comprueba si todo el texto coincide con un patrón o no. Otros métodos (que se muestran a continuación) se utilizan principalmente para encontrar múltiples ocurrencias de patrones en el texto.

Analicemos algunos programas de muestra como lo hicimos para la clase Pattern. Aquí discutiremos algunos programas Java que demuestran el funcionamiento de compile(), find(), start(), end() y split() para comprender mejor la clase Matcher.

Ejemplo 1: búsqueda de patrones 

// Java program to demonstrate working of
// String matching in Java
 
// Importing Matcher and Pattern class
import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String args[])
    {
 
        // Create a pattern to be searched
        // Custom pattern
        Pattern pattern = Pattern.compile("geeks");
 
        // Search above pattern in "geeksforgeeks.org"
        Matcher m = pattern.matcher("geeksforgeeks.org");
 
        // Finding string using find() method
        while (m.find())
 
            // Print starting and ending indexes
            // of the pattern in the text
            // using this functionality of this class
            System.out.println("Pattern found from "
                               + m.start() + " to "
                               + (m.end() - 1));
    }
}

Pattern found from 0 to 4
Pattern found from 8 to 12

Ejemplo 2: búsqueda de expresión regular simple 

// Java program to demonstrate working of
// String matching in Java
 
// Importing Matcher and Pattern class
// from java.util package
import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String args[])
    {
 
        // Creating a pattern to be searched
        // Custom pattern to be searched
        Pattern pattern = Pattern.compile("ge*");
 
        // Searching for the above pattern in
        // "geeksforgeeks.org"
        Matcher m = pattern.matcher("geeksforgeeks.org");
 
        // Checking whether the pattern is there or not
        // using find() method
        while (m.find())
 
            // Print starting and ending indexes of the
            // pattern in text using method functionality of
            // this class
            System.out.println("Pattern found from "
                               + m.start() + " to "
                               + (m.end() - 1));
    }
}

Pattern found from 0 to 2
Pattern found from 8 to 10
Pattern found from 16 to 16

Ejemplo 3: búsqueda de patrones que no distingue entre mayúsculas y minúsculas  

// Java Program Demonstrating Working of String matching
 
// Importing Matcher class and Pattern classes
// from java.util.regex package
import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String args[])
    {
 
        // Creating a pattern to be searched
        Pattern pattern = Pattern.compile(
            "ge*", Pattern.CASE_INSENSITIVE);
 
        // Searching above pattern in "geeksforgeeks.org"
        Matcher m = pattern.matcher("GeeksforGeeks.org");
 
        // Find th above string using find() method
        while (m.find())
 
            // Printing the starting and ending indexes of
            // the pattern in text using class method
            // functionalities
            System.out.println("Pattern found from "
                               + m.start() + " to "
                               + (m.end() - 1));
    }
}

Pattern found from 0 to 2
Pattern found from 8 to 10
Pattern found from 16 to 16

Ejemplo 4: método split() para dividir un texto basado en un patrón delimitador.

El método string split() divide una string dada alrededor de las coincidencias de la expresión regular dada. Existen dos variaciones de este método, así que revíselas antes de pasar a la implementación de este método.

Ilustración:

Input  --> String: 016-78967
Output -->  Regex: {"016", "78967"}

// Java program Illustrating Working of split() Method
// by Splitting a text by a given pattern
 
// Importing Matcher and Pattern classes from
// java.util.regex package
import java.util.regex.Matcher;
import java.util.regex.Pattern;
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String args[])
    {
 
        // Custom string
        String text = "geeks1for2geeks3";
 
        // Specifies the string pattern
        // which is to be searched
        String delimiter = "\\d";
        Pattern pattern = Pattern.compile(
            delimiter, Pattern.CASE_INSENSITIVE);
 
        // Used to perform case insensitive search of the
        // string
        String[] result = pattern.split(text);
 
        // Iterating using for each loop
        for (String temp : result)
            System.out.println(temp);
    }
}

geeks
for
geeks

Ahora hemos terminado con la discusión de ambas clases. Ahora le presentaremos dos nuevos conceptos que dejan absolutamente claro También hay una clase de excepción asociada con  

Clase 3: Clase PatternSyntaxException

Este es un objeto de Regex que se utiliza para indicar un error de sintaxis en un patrón de expresión regular y es una excepción no verificada . Los siguientes son los métodos que se encuentran en la clase PatternSyntaxException como se proporciona a continuación en formato tabular de la siguiente manera.

Interfaz 1: Interfaz MatchResult

Esta interfaz se utiliza para determinar el resultado de una operación de coincidencia para una expresión regular. Cabe señalar que aunque se pueden ver los límites de coincidencia, los grupos y los límites de grupo, no se permite la modificación a través de MatchResult. Los siguientes son los métodos que se encuentran aquí en esta interfaz como se proporciona a continuación en formato tabular de la siguiente manera:

Por último, analicemos algunas de las observaciones importantes recuperadas del artículo anterior.

1. Creamos un objeto de patrón llamando a Pattern.compile(), no hay constructor. compile() es un método estático en la clase Pattern.
2. Como arriba, creamos un objeto Matcher usando matcher() en objetos de la clase Pattern.
3. Pattern.matches() también es un método estático que se usa para verificar si el texto dado en su totalidad coincide con el patrón o no.
4. find() se usa para encontrar múltiples ocurrencias de patrones en el texto.
5. Podemos dividir un texto basado en un patrón delimitador usando el método split()

Este artículo es una contribución de Akash Ojha . Si le gusta GeeksforGeeks y le gustaría contribuir, también puede escribir un artículo y enviarlo por correo a review-team@geeksforgeeks.orgerror-index. Vea su artículo que aparece en la página principal de GeeksforGeeks y ayude a otros Geeks. Escriba comentarios si encuentra algo incorrecto o si desea compartir más información sobre el tema tratado anteriormente.