Tutorial de expresiones regulares de Java | Expresiones Regulares en Java

La extracción o validación de datos es un aspecto importante de todo lenguaje de programación. Una de las formas más populares de validación de datos es mediante el uso de expresiones regulares. Java usa estas expresiones regulares para describir un patrón de caracteres. este artículo sobre expresión regular de Java enumerará los diversos métodos de uso de expresiones.

¡Empecemos!

¿Qué son las expresiones regulares?

A Expresión regular es una secuencia de caracteres que construye un patrón de búsqueda. Cuando busca datos en un texto, puede usar este patrón de búsqueda para describir lo que está buscando.

Una expresión regular puede ser un solo carácter o un patrón más complicado. Se puede utilizar para cualquier tipo de búsqueda de texto y operaciones de reemplazo de texto. Un patrón Regex consta de caracteres simples, como /a B C/o una combinación de caracteres simples y especiales, como /a B C/ o /ejemplo(d+).d*/.

¿Qué es la expresión regular de Java?

los expresión regular de Java es una API que se utiliza para definir un patrón para buscar o manipular cadenas. Se usa ampliamente para definir la restricción en cadenas, como contraseña y validación de correo electrónico.

Existen diferentes métodos para usar Java Regex. Así que avancemos y echemos un vistazo a las diferentes expresiones.

Clase de emparejamiento

Esta clase se utiliza para realizar operaciones de coincidencia en una secuencia de caracteres. La siguiente tabla representa varios métodos de la clase Matcher.

Captura.PNG

Clase de patrón

Pattern Class es una versión compilada de expresión regular que se utiliza para definir el patrón para el motor de expresiones regulares.

Captura.PNG

Ahora tomemos un pequeño ejemplo para entender cómo escribir una expresión regular.

import java.util.regex.*;
  public class RegexExample{
    public static void main (String[] args){
       Pattern pattern = Pattern.compile(".xx.");
       Matcher matcher = pattern.matcher("AxxB");
       System.out.println("String matches the given Regex - +matcher.matches());
   }
}

En este caso, internamente usa Pattern y Matcher Java clases de expresiones regulares para hacer el procesamiento pero, obviamente, reduce las líneas de código. La clase de patrón también contiene un método de coincidencias que toma la expresión regular y la cadena de entrada como argumento y devuelve un resultado booleano después de hacer coincidirlos. Entonces el código funciona bien para la entrada coincidente Cuerdacon una expresión regular en Java. Por lo tanto, la salida será verdadera como se muestra a continuación.

Producción:
true

Ahora veamos algunas categorías más de expresiones regulares de Java.

Clase de caracteres Regex

La siguiente tabla representa la combinación de clases de caracteres diferentes.

Captura.PNG

Ejemplo:

import java.util.regex.*;
  public class CharacterExample{
    public static void main(String args[]){     
      //false (not x or y or z)
      System.out.println(Pattern.matches("[xyz]", "wbcd"));
      //true (among x or y or z)
      System.out.println(Pattern.matches("[xyz]", "x"));
      //false (x and y comes more than once)
      System.out.println(Pattern.matches("[xyz]", "xxyyyyyz"));
    }
}

Cuantificadores Regex

Los cuantificadores especifican el número de ocurrencias de un carácter. La siguiente tabla representa varios cuantificadores.

Captura.PNG

Ejemplo:

import java.util.regex.*;
   public class Example{
     public static void main(String args[]){
       System.out.println("? quantifier ....");

       //(a or y or z comes one time)
       System.out.println(Pattern.matches("[ayz]?", "a")); //output: true
       System.out.println(Pattern.matches("[ayz]?", "aaa")); 

       //(a y and z comes more than one time)
       System.out.println(Pattern.matches("[ayz]?", "ayyyyzz")); //output: false

       //(a comes more than one time)
       System.out.println(Pattern.matches("[ayz]?", "amnta")); //output: false

       //(a or y or z must come one time)
       System.out.println(Pattern.matches("[ayz]?", "ay")); //output: false 
       System.out.println("+ quantifier ....");

       //(a or y or z once or more times)
       System.out.println(Pattern.matches("[ayz]+", "a")); //output: true

       //(a comes more than one time)
       System.out.println(Pattern.matches("[ayz]+", "aaa")); //outpu: true

       //(a or y or z comes more than once)
       System.out.println(Pattern.matches([amn]+", "aayyyzz")); //output: true

       //(z and t are not matching pattern)
       System.out.println(Pattern.matches("[ayz]+", "aammta")); //output: false
       System.out.println("* quantifier ....");

       //(a or y or z may come zero or more times)
       System.out.println(Pattern.matches("[ayz]*", "ayyyza")); //output: true
    }
}

Básicamente, buscará el cuantificador coincidente y coincidirá con el resultado de la búsqueda.

Metacaracteres Regex

Los metacaracteres de expresiones regulares funcionan como códigos abreviados. Echemos un vistazo a la siguiente tabla para comprender varios tipos de metacaracteres.

Captura.PNG

Ejemplo:

import java.util.regex.*;
   public class MetacharExample{
     public static void main(String args[]){
       // d means digit
       System.out.println("metacharacters d...."); 
       //(non-digit)
       System.out.println(Pattern.matches("d", "abc"));//Output: false 

       //(digit and comes once)
       System.out.println(Pattern.matches("d", "1"));//Output: true 

       //(digit but comes more than once)
       System.out.println(Pattern.matches("d", "4443")); //Output: false

       //(digit and char)
       System.out.println(Pattern.matches("d", "323abc"));//Output: false
       //D means non-digit
       System.out.println("metacharacters D....");

       //(non-digit but comes more than once)
       System.out.println(Pattern.matches("D", "abc")); // Output: false

       //Its a Digit
       System.out.println(Pattern.matches("D", "1")); //Output: false 
       System.out.println(Pattern.matches("D", "4443")); //Output: false 

       // (digit and char)
       System.out.println(Pattern.matches("D", "323abc")); //Output: false
       //(non-digit and comes once)
       System.out.println(Pattern.matches("D", "m")); //Output: true 

       System.out.println("metacharacters D with quantifier....");
       //(non-digit and may come 0 or more times)
       System.out.println(Pattern.matches("D*", "abc")); //Output: true 

     }
}

Según las condiciones mencionadas anteriormente, mostrará la salida. Asi es como funciona. Entonces, eso fue todo sobre varios tipos de Java Regex. Con esto, llegamos al final de este artículo. Espero que lo hayas encontrado informativo.

Tienes una pregunta para nosotros? Menciónelo en la sección de comentarios de este artículo de “Java Regex” y nos pondremos en contacto con usted lo antes posible.

Similar Posts

Leave a Reply

Your email address will not be published.