Ejemplos de expresiones regulares en Java

Mirando las estadísticas del blog, me he dado cuenta de que mucha gente pasa por aquí para ver el apartado de las expresiones regulares.Viendo los apartados más vistos(el de Pattern y Matcher), me he dado cuenta de que posiblemente el lector no vea del todo como funcionan de forma conjunta, así que he decidido poner algunos ejemplos en los cuales se usan las dos clases.La forma en la que están programadas, no es la más eficiente, pero para alquien que quiera introducirse en este tema, podrá aprender facilmente(o eso espero) con estos ejemplos…

Estos ejemplos los he sacado de un trabajo que hice para la asignatura de Ampliación de Lenguajes Formales y Autómatas.

Los enunciados de los ejemplos están sacados de las transparencias de la asignatura de la parte práctica, disponibles aquí.

Los ejemplos que pondré a continuación serán las soluciones de los ejercicios de las transparencias de perl anteriormente mencionadas.Estos ejemplos tambien servirían para aquellos que saben perl pero quieren aprender la forma de portar su manejo con las expresiones regulares a java.

Pues empecemos con los ejemplos:

expreg.java

import java.util.regex.Matcher;

import java.util.regex.Pattern;

public class expreg {

public static void main(String[] args) {

/* PROGRAMA HECHO EN PERL equivalente

$_=»Para todo x: |x|=|-x|»;

print «[$`]\n[$&]\n[$’]\n» if /x/; # imprime [Para todo ]

# [x]

# [: |x|=|-x|]

print «[$&]\n» if m/todo/; # imprime [todo]

$e=»la menor: la si do re mi fa(#) sol(#) la»;

print «[$&]\n» if $e=~/\(#\)/; # imprime [(#)]

*/

Pattern pat=null;

Matcher mat=null;

String texto=»Para todo x: |x|=|-x|»;

pat=Pattern.compile(«x»);

mat=pat.matcher(texto);

System.out.println(«Texto –> «+texto);

if(mat.find()){

System.out.println(«\tExpresion regular –> /x/»);

System.out.println(«\t[«+texto.substring(0,mat.start())+»]»);

System.out.println(«\t[«+mat.group()+»]»);

System.out.println(«\t[«+texto.substring(mat.end(),texto.length())+»]»);

}

pat=Pattern.compile(«todo»);

mat=pat.matcher(texto);

if(mat.find()){

System.out.println(«\n\tExpresion regular –> /todo/»);

System.out.println(«\t[«+mat.group()+»]»);

}

texto=»la menor: la si do re mi fa(#) sol(#) la»;

pat=Pattern.compile(«\\(#\\)»);

mat=pat.matcher(texto);

System.out.println(«\n\nTexto –> «+texto);

if(mat.find()){

System.out.println(«\tExpresion regular –> /\\(#\\)/»);

System.out.println(«\t[«+mat.group()+»]»);

}

}

}

escape.java

import java.util.regex.Matcher;

import java.util.regex.Pattern;

public class escape {

public static void main(String[] args) {

Matcher mat=null;

Pattern pat=null;

String texto=»Falta de ortografía:\t la e de America se acentúa»;;

System.out.println(«Cadena –> «+texto);

pat=Pattern.compile(«.centú.»);

mat=pat.matcher(texto);

if(mat.find()){

System.out.println(«Patron que encaja con .centú. –> [«+mat.group()+»]»);

}

}

}

silabas.java

import java.io.BufferedReader;
import java.io.FileReader;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class silabas {

public static void main(String[] args) {

Matcher mat=null;

Pattern pat=Pattern.compile(«-…$»);

try{

FileReader fr=new FileReader(«silabas.in»);

BufferedReader br =new BufferedReader(fr);

String line;

while((line=br.readLine())!=null){

mat=pat.matcher(line);

if(mat.find()){

//La expresion regular coincide

System.out.println(line);

}

}

}catch(Exception e){

e.printStackTrace();

}

}

}

alternancia.java

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class alternancia {

public static void main(String[] args) {

/*PROGRAMA HECHO EN LENGUAJE PERL $_=»En el priorato en el que estaba aquel prior»;
print «[$`][$&]\n» if /aquel|e(n|l)/; # imprime [En ][el]
*/
Matcher mat=null;
Pattern pat=null;
String texto=»En el priorato en el que estaba aquel prior»;pat=Pattern.compile(«aquel|e(n|l)»);
mat=pat.matcher(texto);
if(mat.find()){

String cad=mat.group();
System.out.println(«[«+texto.substring(0,texto.indexOf(cad))+»] «+
«[«+cad+»]»);

}

}

}

sufijos.java

import java.io.BufferedReader;
import java.io.FileReader;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class sufijos {

public static void main(String[] args) {

Matcher mat=null;
Pattern pat=Pattern.compile(«(dad|endo|mente)$»);

try{

FileReader fr=new FileReader(«sufijos.in»);
BufferedReader br =new BufferedReader(fr);
String line;
while((line=br.readLine())!=null){

mat=pat.matcher(line);
if(mat.find()){

System.out.println(line);

}

}

}catch(Exception e){

e.printStackTrace();

}

}

}

clases.java

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class clases {

public static void main(String[] args) {

/*PROGRAMA HECHO EN LENGUAJE PERL
$_=»Vivaldi (1678-1741) compuso alrededor de 500 conciertos.»;
print «[$&]\n» if /\w[aeiou][^A-Z\d][a-z]/; # imprime [Viva]
print «[$&]\n» if /\d\d[\s.()\-]\d\d/; # imprime [78-17]
*/
Matcher mat=null;
Pattern pat=null;
String texto=»Vivaldi (1678-1741) compuso alrededor de 500 conciertos.»;

pat=Pattern.compile(«\\w[aeiou][^A-Z\\d][a-z]»);
mat=pat.matcher(texto);
if(mat.find()) System.out.println(«[«+mat.group()+»]»);

pat=Pattern.compile(«\\d\\d[\\s.()\\-]\\d\\d»);
mat=pat.matcher(texto);
if(mat.find()) System.out.println(«[«+mat.group()+»]»);

}

}

horas.java

import java.io.BufferedReader;
import java.io.FileReader;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class horas {

public static void main(String[] args) {

Matcher mat=null;
Pattern pat=Pattern.compile(«\\|([0-9]|([0-1][0-9])|(2[0-3]))\\:[0-5][0-9]\\|»);

try{

FileReader fr=new FileReader(«horas.in»);
BufferedReader br =new BufferedReader(fr);
String line;
while((line=br.readLine())!=null){

mat=pat.matcher(line);
if(!mat.find()){

System.out.println(line);

}

}

}catch(Exception e){

e.printStackTrace();

}

}

}

cuantificadores.java

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class cuantificadores {

public static void main(String[] args) {

/*PROGRAMA HECHO EN LENGUAJE PERL
$_=»QUINTAS: fa do sol re la mi si fa# do# sol# re# la# (mi#)»;
print «[$&]\n» if /[a-z]{1,5}/; # imprime [fa]
print «[$&]\n» if /[a-z]{3}/; # imprime [sol]
print «[$&]\n» if /[#a-z]{4,}/; # imprime [sol#]
print «[$&]\n» if /[a-z]* /; # imprime []
print «[$&]\n» if /[a-z]+ /; # imprime [fa]
print «[$&]\n» if /do#?/; # imprime [do]
print «[$&]\n» if /#.*#/; # imprime [# do# sol# re# la# (mi#]
print «[$&]\n» if /#.*?#/; # imprime [# do#]
*/
Matcher mat=null;
Pattern pat=null;

String texto=»QUINTAS: fa do sol re la mi si fa# do# sol# re# la# (mi#)»;

pat=Pattern.compile(«[a-z]{1,5}»);
mat=pat.matcher(texto);
if(mat.find()) System.out.println(«[«+mat.group()+»]»);

pat=Pattern.compile(«[a-z]{3}»);
mat=pat.matcher(texto);
if(mat.find()) System.out.println(«[«+mat.group()+»]»);

pat=Pattern.compile(«[#a-z]{4,}»);
mat=pat.matcher(texto);
if(mat.find()) System.out.println(«[«+mat.group()+»]»);

pat=Pattern.compile(«[a-z]*»);
mat=pat.matcher(texto);
if(mat.find()) System.out.println(«[«+mat.group()+»]»);

pat=Pattern.compile(«[a-z]+»);
mat=pat.matcher(texto);
if(mat.find()) System.out.println(«[«+mat.group()+»]»);

pat=Pattern.compile(«do#?»);
mat=pat.matcher(texto);
if(mat.find()) System.out.println(«[«+mat.group()+»]»);

pat=Pattern.compile(«#.*#»);
mat=pat.matcher(texto);
if(mat.find()) System.out.println(«[«+mat.group()+»]»);

pat=Pattern.compile(«#.*?#»);
mat=pat.matcher(texto);
if(mat.find()) System.out.println(«[«+mat.group()+»]»);
}

}

binarios.java

import java.io.BufferedReader;
import java.io.FileReader;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class binarios {

public static void main(String[] args) {

Matcher mat=null;
Pattern pat=Pattern.compile(«[0-1]*[\t \r\f]*([\t \r\f])*0([\t \r\f])*[0-1]*[\t \r\f]*$»);

try{

FileReader fr=new FileReader(«binarios.in»);
BufferedReader br =new BufferedReader(fr);
String line;
while((line=br.readLine())!=null){

mat=pat.matcher(line);
if(mat.find()){

System.out.println(line);

}

}

}catch(Exception e){

e.printStackTrace();

}

}

}

grupos.java

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class grupos {

public static void main(String[] args) {

/*PROGRAMA HECHO EN LENGUAJE PERL
$_=»Renacimiento: Victoria (1548-1611), Guerrero (1527-1599) y Morales (1500-1553)»;
$fecha=»\\d\\d\\d\\d»; # Cadena alternativa ‘\d\d\d\d’
print «[$1 – $2]\n» if /($fecha)-($fecha)/; # imprime [1548 – 1611]
print «[$1-$3]\n» if /((\d\d)00)-\2(\d\d)/; # imprime [1500-53]
*/
Matcher mat=null;
Pattern pat=null;

String texto=»Renacimiento: Victoria (1548-1611), Guerrero (1527-1599) y Morales (1500-1553)»;
String fecha=»\\d\\d\\d\\d»;
pat=Pattern.compile(«(«+fecha+»)-(«+fecha+»)»);
mat=pat.matcher(texto);
if(mat.find()) System.out.println(«[«+mat.group()+»]»);

pat=Pattern.compile(«((\\d\\d)00)-\\2(\\d\\d)»);
mat=pat.matcher(texto);
if(mat.find()) System.out.println(«[«+mat.group(1)+» – «+mat.group(3)+»]»);

}

}

mesas.java

import java.io.BufferedReader;
import java.io.FileReader;
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class mesas {

public static void main(String[] args) {

Matcher mat=null;
Pattern pat=Pattern.compile(«((\\w+),\\d+,(\\d+),\\3,((\\d)+(\\.\\d{1,2})?))$([ ])*»);
Pattern pat2;
try{

FileReader fr=new FileReader(«mesas.in»);
BufferedReader br =new BufferedReader(fr);
String line;
while((line=br.readLine())!=null){

mat=pat.matcher(line);
if(mat.find()){

//Una vez obtenidas las medidas adecuadas,
//escribimos las medidas con formato.
pat2=Pattern.compile(«,»);
String []array=pat2.split(line);
System.out.println(array[0]+» vale «+ array[4] +» con medida «+array[2]+» X «+array[2]);

}

}

}catch(Exception e){

e.printStackTrace();

}

}

}

modificadores.java

import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class modificadores {

/*PROGRAMA HECHO EN LENGUAJE PERL
$c1=»Verde que te quiero verde.\nVerde viento. Verdes ramas.\nVerde»;print «La cadena original es\n[$c1]\n\n»;$cadena=»verde»;
while ($c1=~m/($cadena)/igo) {
print «m//gi encaja con [$1] y sigue buscando desde «,pos($c1),»\n»;
}

*/
public static void main(String[] args) {

Pattern pat=null;
Matcher mat=null;

String texto=»Verde que te quiero verde.\nVerde viento. Verdes ramas.\nVerde»;
System.out.println(«La cadena original es:\n\t[«+texto+»]\n\n»);

pat=Pattern.compile(«verde»,Pattern.CASE_INSENSITIVE);
mat=pat.matcher(texto);
while(mat.find()){

System.out.println(«m//gi encaja con [«+mat.group(0)+»] y sigue buscando desde «+mat.end());

}

}

}

faqs.java

import java.util.regex.Matcher;
import java.util.regex.Pattern;public class faqs {

/*PROGRAMA HECHO EN LENGUAJE PERL
$entrada=»faqs.in»;
$/=»\n\n»;
open(IN,$entrada) || die («No puedo abrir $entrada\n»);
while (<IN>) {
print «$1\n» while /(¿.*?\?)/gs;
}
close(IN);
*/
public static void main(String[] args) {

Pattern pat=null;
Matcher mat=null;
StringBuffer texto=Funciones.contenido_fichero(«faqs.in»);pat=Pattern.compile(«(¿(.|\n)*?\\?)»);
mat=pat.matcher(texto);
while(mat.find()){

System.out.println(«[«+mat.group()+»]\n»);

}

}

}

sustitucion.java

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class sustitucion {

public static void main(String[] args) {

/*PROGRAMA HECHO EN LENGUAJE PERL
$c0=$c1=»Hay un tono salvo de mi a fa, y de si a do.»;
$r=$c1=~s/do|re|mi|fa|sol|la|si/NOTA/g;
print «Original [$c0]\nResultante [$c1]»;$c0=$_=»El resultado del partido ha sido de de 2-2″;
s/(\d+)/$1+1/e;
print «\nOriginal [$c0]\nResultante [$_]»
*/

Matcher mat=null;
Pattern pat=null;

String texto=»Hay un tono salvo de mi a fa, y de si a do.»;

System.out.println(«==Primer Ejemplo======»);
pat=Pattern.compile(«do|re|mi|fa|sol|la|si»);
mat=pat.matcher(texto);
System.out.println(«Original —> «+texto);
System.out.println(«Resultante -> «+mat.replaceAll(«NOTA»));

System.out.println(«\n==Segundo Ejemplo====»);
texto=»El resultado del partido ha sido de de 2-2″;
pat=Pattern.compile(«(\\d+)»);
mat=pat.matcher(texto);
System.out.println(«Original —> «+texto);

System.out.println(mat.find());
System.out.println(«Resultante -> «+mat.replaceFirst((new Integer((new Integer(mat.group(1))).intValue()+1)).toString()));

}

}

intercambio.java

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class sustitucion {

public static void main(String[] args) {

/*PROGRAMA HECHO EN LENGUAJE PERL
$c0=$c1=»Hay un tono salvo de mi a fa, y de si a do.»;
$r=$c1=~s/do|re|mi|fa|sol|la|si/NOTA/g;
print «Original [$c0]\nResultante [$c1]»;$c0=$_=»El resultado del partido ha sido de de 2-2″;
s/(\d+)/$1+1/e;
print «\nOriginal [$c0]\nResultante [$_]»
*/

Matcher mat=null;
Pattern pat=null;

String texto=»Hay un tono salvo de mi a fa, y de si a do.»;

System.out.println(«==Primer Ejemplo=========»);
pat=Pattern.compile(«do|re|mi|fa|sol|la|si»);
mat=pat.matcher(texto);
System.out.println(«Original —> «+texto);
System.out.println(«Resultante -> «+mat.replaceAll(«NOTA»));

System.out.println(«\n==Segundo Ejemplo=======»);
texto=»El resultado del partido ha sido de de 2-2″;
pat=Pattern.compile(«(\\d+)»);
mat=pat.matcher(texto);
System.out.println(«Original —> «+texto);

System.out.println(mat.find());
System.out.println(«Resultante -> «+mat.replaceFirst((new Integer((new Integer(mat.group(1))).intValue()+1)).toString()));

}

}

anclas.java

import java.util.regex.Matcher;

import java.util.regex.Pattern;

public class anclas {

/*PROGRAMA HECHO EN LENGUAJE PERL

$_=»Aceite y Vinagre»;

print «Ancla B [$1]\n» while /(.\Be\B.)/gi; # imprime [cei] de aceite

print «Ancla b [$1]\n» while /(..\Be\b)/gi; # imprime [ite] de aceite y [gre] de vinagre

print «Ancla A [$1]\n» if /\A(\w+)/; # imprime [Aceite]

print «Ancla Z [$1]\n» if /(\w+)\Z/; # imprime [Vinagre]

print «Ancla z [$1]\n» if /(\w+)\z/; # imprime [Vinagre]

$_=»Aceite\nVinagre\nSal\n»;

print «Ancla Z [$1]\n» if /(\w+)\Z/; # imprime [Sal]

print «Ancla z [$1]\n» if /(\w+)\z/; # !!!!!! NO IMPRIME NADA

*/

public static void main(String[] args) {

Pattern pat=null;

Matcher mat=null;

String texto=»Aceite y Vinagre»;

pat=Pattern.compile(«(.\\Be\\B.)»);

mat=pat.matcher(texto);

if(mat.find()) System.out.println(«Ancla B [«+mat.group()+»]»);

pat=Pattern.compile(«(..\\Be\\b)»);

mat=pat.matcher(texto);

if(mat.find()) System.out.println(«Ancla b [«+mat.group()+»]»);

pat=Pattern.compile(«\\A(\\w+)»);

mat=pat.matcher(texto);

if(mat.find()) System.out.println(«Ancla A [«+mat.group()+»]»);

pat=Pattern.compile(«(\\w+)\\Z»);

mat=pat.matcher(texto);

if(mat.find()) System.out.println(«Ancla Z [«+mat.group()+»]»);

pat=Pattern.compile(«(\\w+)\\z»);

mat=pat.matcher(texto);

if(mat.find()) System.out.println(«Ancla z [«+mat.group()+»]»);

texto=»Aceite\nVinagre\nSal\n»;

pat=Pattern.compile(«(\\w+)\\Z»);

mat=pat.matcher(texto);

if(mat.find()) System.out.println(«Ancla Z [«+mat.group()+»]»);

pat=Pattern.compile(«(\\w+)\\z»);

mat=pat.matcher(texto);

if(mat.find()) System.out.println(«Ancla z [«+mat.group()+»]»);

}

}

Si os dais cuenta, casi todos los ejemplos son iguales y eso refleja la simplicidad de las expresiones regulares en Java con Pattern y Marcher. Una vez aprendido el patrón del codigo que forma la interpretación de la expresión regular, ¡todo es igual!

Para algún ejemplo en concreto que querais, podeis postearlo e intentaré hacerlo de la misma manera que los ejemplos anteriores.