Las expresiones regulares de Java - Tutorial con ejemplos

Las expresiones regulares se utilizan para definir patrones de cadena que se pueden utilizar para la búsqueda, la manipulación y edición de un texto.


Estas expresiones también se conocen como expresiones regulares (forma corta de expresiones regulares).


Vamos a tomar un ejemplo para entenderlo mejor:


En el siguiente ejemplo, la expresión regular. * Libro. * Se utiliza para buscar la ocurrencia de cadena "libro" en el texto.

import java.util.regex.*;  
class RegexEjemplo1{  
   public static void main(String args[]){  
      String content1 = "Este es Pedro " +
   "de holalibro.com.";

      String pattern = ".*libro.*";

      boolean esMatch = Pattern.matches(pattern, content1);
      System.out.println("El texto contiene 'libro'? " + esMatch);
   }
}  

Salida:

El texto contiene 'libro'? true

En este tutorial vamos a aprender a definir los patrones y la forma de utilizarlos. La API java.util.regex (el paquete que tenemos que importar al tratar con expresiones regulares) tiene dos clases principales:


1) java.util.regex.Pattern - Se utiliza para definir los patrones

2) java.util.regex.Matcher - Se utiliza para realizar operaciones de los partidos en los patrones de texto usando


java.util.regex.Pattern clase:

1) Pattern.matches ()

Ya hemos visto el uso de este método en el ejemplo anterior, donde se realizó la búsqueda de la cadena "libro" en un texto dado. Este es uno de los más simple y más fácil de buscar una cadena en un texto usando expresiones regulares.

String content1 = "Este es un tutorial!";
String patternCadena = ".*tutorial.*";
boolean esMatch = Pattern.matches(patternCadena, content1);
System.out.println("El texto contiene 'tutorial'? " + esMatch);

Como se puede ver, tenemos método de clase de patrón coincide utilizados () para buscar el patrón en el texto dado. El patrón. * Tutorial. * Permite cero o más caracteres al principio y al final de la "tutorial" String (la expresión. * Se utiliza para cero y más caracteres).

Limitaciones: De esta manera podemos buscar una sola aparición de un patrón en un texto. Para hacer coincidir múltiples ocurrencias se debe utilizar el método Pattern.compile () (discutido en la siguiente sección).

2) Pattern.compile ()

En el ejemplo anterior se realizaron búsquedas en una cadena "tutorial" en el texto, que es una búsqueda sensible caso, sin embargo, si usted quiere hacer una búsqueda que ignore o quiere hacer buscar múltiples ocurrencias entonces puede que tenga que compilar primero el patrón utilizando el patrón .compile () antes de buscar en el texto. Así es como este método se puede utilizar para este caso.

String content1 = "Este es un tutorial!";
String patternCadena = ".*tutoRiAl.";
Pattern pattern1 = Pattern.compile(patternCadena, Pattern.CASE_INSENSITIVE);

Aquí hemos utilizado un Pattern.CASE_INSENSITIVE bandera para búsqueda que ignore, hay varias otras banderas que se pueden utilizar para diferentes 2-fines.

Ahora lo que: Hemos obtenido una instancia del patrón, sino cómo hacerlo coincidir? Para que iba a necesitar una instancia Matcher, que podemos obtener mediante el método Pattern.matcher (). Vamos a discutir él.

3) Método de Pattern.matcher ()

En la sección anterior hemos aprendido cómo obtener una instancia de patrón mediante el método compile (). Aquí vamos a aprender cómo conseguir ejemplo Matcher de instancia de patrón mediante el método de coincidencias ().

String content1 = "Este es un tutorial!";
String patternCadena = ".*tutoRiAl.*";
Pattern pattern1 = Pattern.compile(patternCadena, Pattern.CASE_INSENSITIVE);
Matcher matcher1 = pattern1.matcher(content1);
boolean esMatched = matcher1.matches();
System.out.println("Este matchea?" + esMatched);

Salida:

Este matchea? true

4) Pattern.split ()

Para dividir un texto en varias cadenas basadas en un delimitador (delimitador Aquí se especifica el uso de expresiones regulares), podemos utilizar el método Pattern.split (). Esta es la forma en que puede hacerse.

import java.util.regex.*;  
class RegexEjemplo2{  
public static void main(String args[]){  
String texto1 = "EsteEsPedro.EsteEsMiEjemplo";
    // Pattern for delimiter
String patternCadena = "Es";
Pattern pattern1 = Pattern.compile(patternCadena, Pattern.CASE_INSENSITIVE);
String[] misCadenas = pattern1.split(texto1);
for(String temp1: misCadenas){
   System.out.println(temp1);
}
System.out.println("Cantidad de cadenas: "+misCadenas.length);
}}

Salida:

te
Pedro.
te
MiEjemplo
Cantidad de cadenas: 4


Clase java.util.regex.Matcher

Ya hemos discutido poco sobre la clase Matcher anteriormente. Vamos a recordar algunas cosas:

Creación de una instancia Matcher

String content1 = "Algun texto";
String patternCadena = ".*algunascadenas.*";
Pattern pattern1 = Pattern.compile(patternCadena);
Matcher matcher1 = pattern1.matcher(content1);

Principales métodos

matches(): Coincide con la expresión regular en contra de todo el texto se pasa al método Pattern.matcher () al crear instancia Matcher.

Matcher matcher1 = pattern1.matcher(content1);
boolean esMatch = matcher1.matches();

lookingAt(): Similar al método matches(), excepto que coincida con la expresión regular sólo contra el principio del texto, mientras que los partidos () de búsqueda en todo el texto: lookingat ().

find(): busca las ocurrencias de las expresiones regulares en el texto. Se utiliza principalmente cuando estamos en busca de múltiples ocurrencias.

start() y al end(): Ambos métodos se utilizan generalmente junto con el método find (). Se utilizan para obtener los índices de inicio y final de un partido que se encontró método find () usando.

Vamos a tomar un ejemplo para descubrir las múltiples ocurrencias utilizando métodos Matcher:

package hola.com;
import java.util.regex.*;  
class RegexEjemploMatcher{  
public static void main(String args[]){  
  String content1 = "ZZZ JJ PP JJ QQQ JJJ ZZ";

  String cadena = "JJ";
  Pattern pattern1 = Pattern.compile(cadena);
  Matcher matcher1 = pattern.matcher(contenido);

  while(matcher1.find()) {
     System.out.println("Encontrado en: "+ matcher1.start()
    + 
    " - " + matcher1.end());
  }
}
}

Salida:

Encontrado en: 4 - 6
Encontrado en: 10 - 12
Encontrado en: 17 - 19

Ahora estamos familiarizados con el modelo y la clase Matcher y el proceso de búsqueda de una expresión regular en contra del texto. Vamos a ver qué tipo de varias opciones que tenemos para definir una expresión regular:

1) Los literales de cadena

Digamos lo que desea es buscar una cadena en particular en el texto de ejemplo "Abc" entonces simplemente puede escribir el código como este: Aquí el texto y expresiones regulares ambos son iguales.
Pattern.matches ( "abc", "abc")

2) Clases de caracteres

Una clase de caracteres coincide con un único carácter en el texto de entrada contra múltiples caracteres permitidos en la clase de caracteres. Por ejemplo [CC] asandra coincidiría con todas las ocurrencias de "Casandra" cadena, ya sea con minúsculas o mayúsculas C ". Algunos ejemplos más:
Pattern.matches ( "[]" PQR, "ABCD"); Sería dar un falso ya que no p, q o r en el texto
Pattern.matches ( "[PQR]", "r"); Devuelve verdadero como se encuentra r
Pattern.matches ( "[PQR]", "pq"); Return false como uno cualquiera de ellos puede estar en texto no tanto.

Esta es la lista completa de las diversas clases de personajes construye:
[ABC]: Sería coincida con el texto si el texto está teniendo cualquiera de ellos (a, b, c) y sólo una vez.
[^ Abc]: Cualquier carácter excepto a, b, oc (^ denota negación)
[A-zA-Z]: A a la Z, o la A a la Z, ambos inclusive (rango)
[A-d [m-p]]: A a la D, o m p a través de: [a-dm-p] (unión)
[A-z && [def]]: Cualquiera de ellos (d, e, o f)
[A-z && [^ bc]]: a través de z, a excepción de b y c: [ad-z] (sustracción)
[A-z && [^ m-p]]: A a la Z, y no a través de m p: [a-LQ-z] (sustracción)

Clases de caracteres predefinidos - Metacaracteres

Estos son como los códigos de acceso que se pueden utilizar al escribir expresiones regulares.

Construir          Descripción
.                ->      Cualquier carácter (puede o no coincidir con las terminaciones de línea)
\D            ->      Un dígito: [0-9]
\D            ->      A no dígito: [^ 0-9]
\S            ->       Un espacio en blanco: [\ t \ n \ x0B \ f \ r]
\S            ->       A no está en blanco: [^ \ s]
\W           ->      Un carácter de palabra: [a-zA-Z_0-9]
\W           ->      Un carácter no-palabra: [^ \ w]

Por Ejemplo:

Pattern.matches ("\\d", "1"); volvería verdadera
Pattern.matches ("\\D", "z"); return true
Pattern.matches (".P", "qp"); de vuelta verdad, no (.) representa cualquier carácter

Comparadores de limites

^   Coincide con el comienzo de una línea.
$   Coincidencias entonces el final de una línea.
\b  Coincide con un límite de palabra.
\B  Coincide con un límite de palabra.
\A  Coincide con el comienzo del texto de entrada.
\G  Coincidir el final del partido anterior
\Z   Coincidir el final del texto de entrada, excepto el terminador final, si los hubiere.
\z   Coincidir el final del texto de entrada.

Por Ejemplo:

Pattern.matches("^Hola$", "Hola"): de vuelta verdad, comienza y termina con Hola
Pattern.matches("^Hola$", "Prueba! Hola"): Retorna false, no comienza con Hola
Pattern.matches("^Hola$", "Hola Prueba!"): Retorna false, no termina con Hola