Lasexpresiones regulares se utilizan para definir patrones de cuerdas que pueden utilizarse para buscar, manipular y editar un texto. Estas expresiones también se conocen como Regex (forma corta de expresiones regulares).
Tomemos un ejemplo para entenderlo mejor:
En el siguiente ejemplo, la expresión regular .*book.* se utiliza para buscar la aparición de la cadena «book» en el texto.
importar java.util.regex.*; clase RegexEjemplo1{ public static void main(String args[]){ Contenido de la cadena = "Esto es Chaitanya " + "de Beginnersbook.com."; Patrón de la cadena = ".*libro.*"; booleana isMatch = Patrón.matches(patrón, contenido); System.out.println("El texto contiene 'libro'? " + isMatch); }}
Salida:
El texto contiene 'libro'? verdad
En este tutorial aprenderemos a definir los patrones y a utilizarlos. El API java.util.regex (el paquete que necesitamos importar al tratar con Regex) tiene dos clases principales:
1) java.util.regex.Pattern – Se utiliza para definir patrones
2) java.util.regex.Matcher – Se utiliza para realizar operaciones de coincidencia en el texto utilizando patrones
java.util.regex.Pattern class:
1) Pattern.matches()
Ya hemos visto el uso de este método en el ejemplo anterior, en el que realizamos la búsqueda de la cadena «book» en un texto determinado. Esta es una de las formas más simples y fáciles de buscar una cadena en un texto usando Regex.
String content = "This is a tutorial Website!";String patternString = ".*tutorial.*";boolean isMatch = Pattern.matches(patternString, content);System.out.println("El texto contiene 'tutorial'? " + isMatch);
Como puedes ver, hemos utilizado el método matches() de la clase Pattern para buscar el patrón en el texto dado. El patrón .*tutorial.* permite cero o más caracteres al principio y al final del String «tutorial» (la expresión .* se utiliza para cero y más caracteres).
Limitaciones: De esta manera podemos buscar una sola ocurrencia de un patrón en un texto. Para buscar múltiples ocurrencias se debe utilizar el método Pattern.compile() (discutido en la siguiente sección).
2) Pattern.compile()
En el ejemplo anterior buscamos una cadena «tutorial» en el texto, es decir, una búsqueda que distingue entre mayúsculas y minúsculas, sin embargo, si desea realizar una búsqueda INSENSIBLE AL CASO o desea realizar una búsqueda de múltiples ocurrencias, entonces puede que necesite primero compilar el patrón utilizando Pattern.compile() antes de buscarlo en el texto. Así es como se puede utilizar este método para este caso.
Contenido de la cadena = "¡Este es un sitio web de tutoriales!";Cadena patternString = ".*tuToRiAl";Patrón patrón = Pattern.compile(patternString, Pattern.CASE_INSENSITIVE);
Aquí hemos usado una bandera Pattern.CASE_INSENSITIVE para la búsqueda sin mayúsculas y minúsculas, hay varias otras banderas que pueden ser usadas para diferentes-2 propósitos. Para leer más sobre estos indicadores, consulte este documento.
Ahora qué: Hemos obtenido una instancia de Patrón pero ¿cómo hacerla coincidir? Para ello necesitaríamos una instancia de Matcher, que podemos obtener usando el método Pattern.matcher(). Vamos a discutirlo.
3) Método Pattern.matcher()
En la sección anterior aprendimos cómo obtener una instancia de Patrón usando el método compile(). Aquí aprenderemos cómo obtener una instancia de Pattern usando el método matcher().
String content = "This is a tutorial Website!";String patternString = ".*tuToRiAl.*";Pattern pattern = Pattern.compile(patternString, Pattern.CASE_INSENSITIVE);Matcher matcher = pattern.matcher(content);boolean isMatched = matcher.matches();System.out.println("Is it a Match?" + isMatched);
Salida:
¿Es una coincidencia?
4) Pattern.split()
Para dividir un texto en múltiples cadenas basadas en un delimitador (Aquí el delimitador se especificaría usando regex), podemos usar el método Pattern.split(). Así es como se puede hacer.
importar java.util.regex.*; class RegexExample2{ public static void main(String args[]){ String text = "ThisIsChaitanya.ItISMyWebsite"; // Patrón para el delimitador String patternString = "is"; Pattern pattern = Pattern.compile(patternString, Pattern.CASE_INSENSITIVE); String[] myStrings = pattern.split(text); for(String temp: myStrings){ System.out.println(temp); } System.out.println("Número de cadenas divididas: "+misCadenas.longitud);}}
Salida:
ThChaitanya.ItMyWebsiteNúmero de cadenas divididas: 4
El segundo String dividido es nulo en la salida.
java.util.regex.Matcher Class
Ya hemos discutido un poco sobre la clase de Matcher arriba. Recordemos algunas cosas:
Crear una instancia de Matcher
Contenido de la cadena = "Algo de texto";Cadena patrónCadena = ".*cadena.*";Patrón patrón = Patrón.compilar(patrónCadena);Coincidencia coincidente = patrón.coincidencia(contenido);
Métodos principales
…partidos(): Coincide con la expresión regular contra todo el texto pasado al método Pattern.matcher() mientras se crea la instancia Matcher.
...Matcher matcher = pattern.matcher(content);boolean isMatch = matcher.matches();
lookingAt(): Similar al método matches(), excepto que coincide con la expresión regular sólo contra el principio del texto, mientras que matches() busca en todo el texto.
find(): Busca las ocurrencias de las expresiones regulares en el texto. Se utiliza principalmente cuando se buscan múltiples ocurrencias.
start() y end(): Estos dos métodos se utilizan generalmente junto con el método find(). Se utilizan para obtener los índices de inicio y fin de una coincidencia que se está encontrando mediante el método find().
Tomemos un ejemplo para averiguar las múltiples ocurrencias usando los métodos Matcher:
paquete beginnersbook.com;importar java.util.regex.*; class RegexexampleMatcher{ public static void main(String args[]){ String content = "ZZZ AA PP AA QQQ AAA ZZ"; String string = "AA"; Pattern pattern = Pattern.compile(string); Matcher matcher = pattern.matcher(content); while(matcher.find()) { System.out.println("Found at: "+ matcher.start() + " - " + matcher.end()); }}}
Salida:
Encontrado en: 4 - 6Found en: 10 - 12Found en: 17 - 19
Ahora estamos familiarizados con la clase Pattern and Matcher y el proceso de cotejar una expresión regular con el texto. Veamos qué tipo de opciones tenemos para definir una expresión regular:
1) Literales de cuerda
Digamos que sólo quieres buscar una cadena particular en el texto para, por ejemplo, «abc», entonces podemos simplemente escribir el código así: Aquí el texto y el regex son lo mismo.
Pattern.matches(«abc», «abc»)
2) Clases de personaje
Una clase de carácter coincide con un solo carácter en el texto de entrada contra varios caracteres permitidos en la clase de carácter. Por ejemplo, [Cc]haitanya coincidiría con todas las ocurrencias de la cadena «chaitanya» con C minúscula o mayúscula». Algunos ejemplos más:
Pattern.matches(«[pqr]», «abcd»); Daría falso como no p,q o r en el texto
Pattern.matches(«[pqr]», «r»); Retorno verdadero como se encuentra r
Pattern.matches(«[pqr]», «pq»); Retorno falso ya que cualquiera de ellos puede estar en texto no ambos.
Aquí está la lista completa de varias construcciones de clases de caracteres:
[abc]: Coincidiría con el texto si el texto tiene alguno de ellos(a,b o c) y sólo una vez.
[^abc]: Cualquier carácter individual excepto a, b o c (^ denotan negación)
[a-zA-Z]: de la a a la z, o de la A a la Z, inclusive (rango)
de la a a la d, o de la m a la p: [a-dm-p] (unión)
[a-z&&[def]]: Cualquiera de ellos (d, e, o f)
de la a a la z, excepto la b y la c: [ad-z] (resta)
de la a a la z, y no de la m a la p: [a-lq-z] (resta)
Clases de caracteres predefinidos – Metacharacteres
Estos son como códigos cortos que puedes usar mientras escribes regex.
Construye una descripción. -> Cualquier carácter (puede o no coincidir con los terminadores de línea): [0-9]D -> Un no-dígito: [^0-9]N-> Un carácter de espacio en blanco: Un carácter no blanco: [^s]^w -> Un carácter de palabra: [a-zA-Z_0-9]N-> Un carácter no denominativo: [^w]
Por e.g.
El patrón… coincide (» ~ – 1″); volvería verdadero
Patrón. Coincide (» ~ – D», «z»); retorno verdadero
Pattern.matches(«.p», «qp»); return true, dot(.) representan cualquier personaje
Coincidencia de límites
Coincide con el comienzo de una línea. Coincide con el final de una línea. Coincide con un límite de palabra. Coincide con un límite no de palabra. Coincide con el comienzo del texto de entrada. Coincide con el final del texto anterior. Coincide con el final del texto de entrada excepto el terminador final si lo hay. Coincide con el final del texto de entrada.
Por ejemplo.
Pattern.matches(«^Hello$», «Hello»): devuelve true, Comienza y termina con Hello
Pattern.matches(«^Hello$», «Namaste! Hello»): devuelve falso, no empieza con Hello
Pattern.matches(«^Hello$», «Hello Namaste!»): devuelve falso, No termina con Hello
Cuantificadores
¿Reacio y codicioso a los fósforos posesivos? X?? X?+ Fósforos X una vez, o nada (0 o 1 vez).X* X*? X*+ Coincide con X cero o más veces.X+ X+? X++ Coincide con X una o más veces.X{n} ¿Xn? X{n}+ Coincide con X exactamente n veces. X{n,} X{n,}? X{n,}+ Coincide con X por lo menos n veces.X{n, m) X{n, m)? X{n, m)+ Coincide con X al menos n veces, pero como máximo m veces.
Pocos ejemplos
importar java.util.regex.*; clase RegexExample{ public static void main(String args[]){ // Devolvería true si la cadena coincide exactamente con "tom" System.out.println( Pattern.matches("tom", "Tom")); //False /* devuelve true si la cadena coincide exactamente con * "tom" o "Tom" */ System.out.println( Patrón.matches("[Tt]om", "Tom")); //True System.out.println("[Tt]om", "Tom")); //True /* Devuelve verdadero si la cadena coincide exactamente con "tim" * o "Tim" o "jin" o "Jin" */ Sistema.out.println( Pattern.matches("[tT]im|[jJ]in", "Tim"));//True System.out.println("[tT]im|[jJ]in", "jin"));//True /* Devuelve verdadero si la cadena contiene "abc" en * cualquier lugar */ Sistema.out.println( Pattern.matches(".*abc.*", "deabcpq"));//True /* devuelve verdadero si la cadena no tiene un * número al principio */ System.out.println( Pattern.matches("^[^d]).*", "123abc")); //Falso Sistema.out.println( Patrón.matches("^[^d].*", "abc123")); //Verdadero // devuelve verdadero si la cadena contiene de tres letras Sistema.out.println( Patrón.matches("[a-zA-Z][a-zA-Z][a-zA-Z]", "aPz"));//Verdadero Sistema.out.println("[a-zA-Z][a-zA-Z][a-zA-Z]", "aAA"));//True System.out.println("[a-zA-Z][a-zA-Z][a-zA-Z]", "apZx"));//False // devuelve verdadero si la cadena contiene 0 o más no-dígitos System.out.println( Pattern.matches("D*", "abcde")); //True System.out.println( Pattern.matches("D*", "abcde123")); //False /* Ejemplo de Boundary Matchers * ^ denota el comienzo de la línea * $ denota el final de la línea */ System.out.println( Patrón.matches("^Este$", "Esta es la Chaitanya")); //Falso Sistema.out.println( Patrón.matches("^Este$", "Este")); // Verdadero Sistema.out.println( Patrón.matches("^Este$", "Esta es la Chaitanya")); //Falso}}
Referencia
Expresiones regulares – Javadoc
