Programa Java para ilustrar caracteres de escape en Regex

Los caracteres especiales como punto (.), hash (#), etc., que tienen un significado especial para la expresión regular, deben escaparse para que coincidan en la expresión regular. Por ejemplo, si el punto (.) no se escapa en una expresión regular, coincide con cualquier carácter único, lo que genera resultados ambiguos.

Métodos: 

Los caracteres se pueden escapar en Java Regex de dos maneras que se enumeran a continuación y que analizaremos en profundidad:

1. Usar \Q y \E para escapar
2. Uso de barra invertida (\\) para escapar

Método 1: usar \Q y \E para escapar

• Podemos usar las secuencias de escape \Q y \E para escapar de los caracteres.
• \Q marca el inicio de la secuencia de escape mientras que \E marca el final de la secuencia de escape.
• Cualquier carácter entre \Q y \E se escapa.
• Generalmente se utiliza para escapar de varios caracteres.

Implementación:

En el siguiente código fuente, el patrón Regex p se escapa para el operador punto (.), mientras que el patrón p1 no se escapa para el punto (.). Por lo tanto, el patrón p coincide solo con la string s, mientras que el patrón p1 coincide con las strings s y s1.

Ejemplo

// Java Program to Illustrate Escaping Characters in Java
// Regex Using \Q and \E for escaping
 
// Importing required classes
import java.io.*;
import java.util.regex.*;
 
// Main class
class GFG {
 
    // Main driver method
    public static void main(String[] args)
    {
 
        // Sample strings as inputs
        String s = "Geeks.forGeeks";
        String s1 = "GeeksforGeeks";
 
        // Creating object of Pattern class
 
        // 1. Patterns with dot escaped
        Pattern p = Pattern.compile("\\Q.\\E");
 
        // 2, Pattern without dot escaped
        Pattern p1 = Pattern.compile(".");
 
        // Matchers for each pattern string combination
        Matcher m = p.matcher(s);
        Matcher m1 = p.matcher(s1);
        Matcher m2 = p1.matcher(s);
        Matcher m3 = p1.matcher(s1);
 
        // Print and display whether p,p1 matches
        // or not via boolean true false
        System.out.println("p matches s: " + m.find());
        System.out.println("p matches s1: " + m1.find());
        System.out.println("p1 matches s: " + m2.find());
        System.out.println("p1 matches s1: " + m3.find());
    }
}

p matches s: true
p matches s1: false
p1 matches s: true
p1 matches s1: true

Método 2: usar la barra invertida (\\) para escapar

• Podemos usar una barra invertida para escapar de los caracteres.
• Requerimos dos barras invertidas ya que la barra invertida es en sí misma un carácter y debe escaparse.
• Los caracteres después de \\ se escapan.
• Generalmente se usa para escapar caracteres al final de la string.

Implementación:

En el siguiente código fuente, el patrón Regex p se escapa para el operador punto ( . ), mientras que el patrón p1 no se escapa para el punto ( . ). Por lo tanto, el patrón p coincide solo con la string s, mientras que el patrón p1 coincide con las strings s y s1 .

Ejemplo:

/*package whatever //do not write package name here */
 
import java.io.*;
import java.util.regex.*;
 
class GFG {
    public static void main (String[] args) {
         
         
        String s="Geeks.forGeeks";//sample strings
        String s1="GeeksforGeeks";
          //patterns with dot escaped
        Pattern p=Pattern.compile("\\.");
          // pattern without dot escaped
          Pattern p1=Pattern.compile(".");
          //matchers for each pattern string combination
        Matcher m=p.matcher(s);
          Matcher m1=p.matcher(s1);
          Matcher m2=p1.matcher(s);
          Matcher m3=p1.matcher(s1);
          //outputs
        System.out.println("p matches s: "+m.find());
          System.out.println("p matches s1: "+m1.find());
          System.out.println("p1 matches s: "+m2.find());
          System.out.println("p1 matches s1: "+m3.find());
    }
}

Producción:

p matches s: true
p matches s1: false
p1 matches s: true
p1 matches s1: true