Metacaracteres en Java Regex

Regex significa expresión regular , que se utiliza para definir un patrón para una string. Se utiliza para encontrar el texto o para editar el texto. Las clases Java Regex están presentes en el paquete java.util.regex , que debe importarse antes de usar cualquiera de los métodos de las clases regex.

El paquete java.util.regex consta de 3 clases:

1. Patrón
2. emparejador
3. PatternSyntaxException

Clases en el paquete regex

Metacaracteres

Los metacaracteres son como códigos cortos para patrones de coincidencia comunes.

Uso de metacaracteres

• Preceda el metacarácter con una barra invertida (\).

Explicación de Metacaracteres

1. Metacaracteres relacionados con dígitos y no dígitos: (\d, \D)

// Java program to demonstrate the
// Digit & Non Digit related Metacharacters
  
import java.io.*;
import java.util.regex.*;
class GFG {
    public static void main(String[] args)
    {
        // \d represents a digit
        // represents a number so return true
        System.out.println(Pattern.matches("\\d", "2")); //true
  
        // Comparing a number with character so return false
        System.out.println(Pattern.matches("\\d", "a")); //false
  
        // \D represents non digits
        // Comparing a non digit with character so return
        // true
        System.out.println(Pattern.matches("\\D", "a")); //true
  
        // comparing a non digit with a digit so return
        // false
        System.out.println(Pattern.matches("\\D", "2")); //false
    }
}

true
false
true
false

Explicación

• El metacarácter d representa un dígito del 0 al 9. Entonces, cuando comparamos » d » dentro del rango, devuelve verdadero . De lo contrario, devuelve falso.
• El metacarácter D representa un no dígito que acepta cualquier cosa excepto números . Entonces, cuando comparamos » D » con cualquier número , devuelve falso . Más cierto.

2. Metacaracteres con espacios en blanco y sin espacios en blanco: (\s, \S)

// Java program to demonstrate the
// Whitespace and Non-Whitespace Metacharacters
  
import java.io.*;
import java.util.regex.*;
class GFG {
    public static void main(String[] args)
    {
        // comparing any whitespace character with a white
        // space so return true else false
        System.out.println(Pattern.matches("\\s", " ")); //true
        System.out.println(Pattern.matches("\\s", "2")); //false
        
        // comparing any non whitespace character with a non
        // white space character so return true else false
        System.out.println(Pattern.matches("\\S", "2")); //true
        System.out.println(Pattern.matches("\\S", " ")); //false
    }
}

true
false
true
false

Explicación

• s representa caracteres de espacio en blanco como espacio, espacio de tabulación, nueva línea, etc. Entonces, cuando comparamos » s » con caracteres de espacio en blanco , devuelve verdadero . De lo contrario falso.
• S representa un carácter que no es un espacio en blanco que acepta todo excepto espacios en blanco, por lo que cuando comparamos » S » con caracteres de espacio en blanco , devuelve falso . más cierto

3. Metacaracteres verbales y no verbales: (\w, \W)

// Java program to demonstrate the
// Word & Non Word Metacharacters
  
import java.io.*;
import java.util.regex.*;
  
class GFG {
    public static void main(String[] args)
    {
        // comparing any word character with a word
        // character so return true else false
        System.out.println(Pattern.matches("\\w", "a")); //true
        System.out.println(Pattern.matches("\\w", "2")); //true
        System.out.println(Pattern.matches("\\w", "$")); //false
  
        // comparing any non word character with special
        // symbols & whitespaces return true else false
        System.out.println(Pattern.matches("\\W", "2")); //false
        System.out.println(Pattern.matches("\\W", " ")); //true
        System.out.println(Pattern.matches("\\W", "$")); //true
    }
}

true
true
false
false
true
true

Explicación

• w representa un carácter de palabra que acepta alfabetos (mayúsculas y minúsculas) y dígitos [0-9]. Entonces, cuando comparamos » w » con un alfabeto o un número, devuelve verdadero . De lo contrario falso.
• W representa un carácter que no es una palabra que acepta cualquier cosa excepto alfabetos y dígitos . Entonces, cuando comparamos » W » con un alfabeto o un número, devuelve falso . De lo contrario cierto.

4. Metacaracteres de límite de palabra y no palabra : (\b, \B)

// Java program to demonstrate the
// Word & Non Word Boundary Metacharacters
  
import java.io.*;
import java.util.regex.*;
class GFG {
    public static void main(String[] args)
    {
        // \b says that a string must have boundary letters
        // of word characters
        System.out.println(
            Pattern.matches("\\bGFG\\b", "GFG")); // true
        System.out.println(
            Pattern.matches("\\b@GFG\\b", "@GFG")); // false
  
        // \B says that a string must have non word
        // characters as boundaries
        System.out.println(Pattern.matches(
            "\\B@GFG@\\B", "@GFG@")); // true
        System.out.println(
            Pattern.matches("\\BGFG\\B", "GFG")); // false
    }
}

true
false
true
false

Explicación:

• b indica que una string debe tener elementos de límite de caracteres de palabras , es decir , dígitos o letras. Así que aquí, la string GFG tiene límites G, G , que son caracteres de palabra, por lo que devuelve true . Para la string @GFG , los elementos de límite son @, G donde @ no es un carácter de palabra , por lo que devuelve falso .
• B indica que una string debe tener elementos de límite de caracteres que no son palabras , es decir , puede tener cualquier cosa excepto dígitos o letras. Así que aquí la string @GFG@ tiene límites @,@ que son caracteres que no son palabras, por lo que devuelve verdadero . Para la string GFG , los elementos de límite son G, G , que son caracteres de palabra y devuelven false .

Ejemplo:

// Java program to demonstrate all the 
// Metacharacters in the Java Regex
  
import java.io.*;
import java.util.regex.*;
  
class GFG {
    public static void main(String[] args)
    {
        // \d-number
        // \D-Non Digit
        // \s-Any White Space
        // \S-Non White Space character
        // \w-any word character like  numbers/characters
        // \W-special symbols
        System.out.println(Pattern.matches(
            "\\d\\D\\s\\S\\w\\W", "1G FG!")); // true
        
        System.out.println(Pattern.matches(
            "\\d\\D\\s\\S\\w\\W", "Geeks!")); // false
    }
}

true
false