Posteado por: bpsmind | agosto 22, 2007

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.
About these ads

Responses

  1. [...] Si lo que quieres es ver algunos ejemplos de como se utilizaría junto con la clase Matcher mira el post de Ejemplos con expresiones regulares en java. [...]

  2. [...] Ejemplos con expresiones regulares en java (recomendado despues de leerse el apartado de Pattern y Matcher) [...]

  3. [...] Si lo que quieres es ver algunos ejemplos de como se utilizaría junto con la clase Pattern mira el post de Ejemplos con expresiones regulares en java. [...]

  4. Hola José David
    Me podrias decir como hago para que me de true..?
    ……….
    {
    String frase = “analia”;
    Pattern pat = Pattern.compile(“a{3}”);
    Matcher enc = pat.matcher(frase);
    System.out.println(“Devulve:” + enc.matches());
    }
    ……….

    En cuanto a lo expuesto en esta página es excelente, nunca dejare de agradecer a todo aquel que de una forma desinteresada decide ayudar a los demas.-

    un gran abrazo
    Daniel

  5. Hola, perdón por haber respondido tan tarde, pero es que he estado un poco ausente del blog.

    A tu pregunta:
    {
    String frase = “analia”;
    Pattern pat = Pattern.compile(”a{3}”);
    Matcher enc = pat.matcher(frase);
    System.out.println(”Devulve:” + enc.matches());
    }

    no puede dar true debido a que estás buscando un patrón con 3 aes, es decir buscas exactamente el patrón “aaa”. Y como ves, dicho patrón no se encuentra en “analia”.
    Para que te de true, simplemente debes poner un patrón que coincide con alguna de las posibles subcadenas de la cadena “analia”, como a{1}. Si supiera que patrón es lo que estabas buscando, te podría dar la expresión regular…

    Espero haberte ayudado.
    Saludos.

  6. Estoy echando un ojillo a tu blog, muy interesante por cierto.
    Te escribo porque tengo un problemilla que no soy capaz de resolver. Te explico la situación, creo que es interesante y seguro que ayuda a más de uno.
    Tengo un String que he sacado previamente de un Fichero y tengo que encontrar las estructuras que siguen el siguiente formato para hacer una modificación:
    “text1:=text2.text3″ (pat=Pattern.compile(“[a-zA-Z_0-9]+\\:\\=[a-zA-Z_0-9]+\\.[a-zA-Z_0-9]+”); )
    En el String puede haber otras estructuras similares como por ejemplo “text1:=text2″ pero estas no deberían verse afectadas.
    La idea, que es lo que no soy capaz de conseguir es que una vez tengamos localizadas las cadenas que cumplen el patrón que se ha definido (pat) tendría que substituir el := por un = dejando el resto de la cadena tal y como está y sin que las otras cadenas parecidas se vean afectadas.

    Espero haberme expresado con la suficiente claridad para que me puedas echar una manita porque estoy atascadísimo!!!

    Muchas gracias!!!!

  7. A ver si me he enterado correctamente; quieres sustituir en una cadena que coincida con tu patrón y de ahí sustituir por otra cosa,no?

    Se puede hacer con Pattern, pero creo que para tu caso, te viene perfecto la clase String, que tiene estos métodos muy útiles para lo que quieres:

    String replaceAll(String regex, String replacement)
    String replaceFirst(String regex, String replacement)

    Si quieres las descripcion de dichos métodos mira su documentación en :

    http://java.sun.com/j2se/1.4.2/docs/api/java/lang/String.html

    Mañana si no lo ves claro pongo el codigo, pero sería cambiar solo el Pattern y el matcher por el replaceAll o replaceFirst…

    Si se quieren hacer más cosas a parte de sustituir ciertas cosas en una cadena, podemos seguir la estructura que antes hemos visto, simplemente añadimos el replaceAll al bucle:
    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);

    //BLABLabLA

    TRATAMIENTO CON LA SUSTIUCION
    linea.replaceAll(…….);

    }

    }

    Espero haberte servido de ayuda…
    De hecho creo que voy a hacer un post con esto, ya que me lo habían preguntado antes…
    Saludos

  8. No es exactamente lo que dices ya que no quiero substituir toda la cadena que cumpla el patrón, sólo quiero modificar el := que está contendido en dicho patrón por un ::= dejando la parte izquierda y derecha del operador exactamente igual.
    Lo que pasa es que no puedo buscar := y simplemente substituirlo ya que puede haber otras expresiones similares que no cumplan exactamente el patron, y esas no deben verse afectadas.
    Patron: texto1:=texto2.texto3 ([a-zA-Z_0-9]+\\:\\=[a-zA-Z_0-9]+\\.[a-zA-Z_0-9])
    Otras cadenas que no deben verse afectadas: texto1:=texto2; texto1:=0; texto1:=texto2 …

    La idea sería localizar las expresiones que cumplen el patron y dejando los nombres de las variables (texto1,texto2.texto3) tal y como están, substituir el opeador := por ::=.

    No se si me he explicado con más claridad, la idea es que no quiero “substituir” una cadena, quiero modificar una cadena que cumpla un patron.
    La idea sería algo del estilo:
    replaceAll(“[a-zA-Z_0-9]+\\:\\:\\=[a-zA-Z_0-9]+\\.[a-zA-Z_0-9]“)
    Pero que no me ponga lo que está entre comillas, sino que respete los nombres de las variables que había y solo me modifique el operador := por ::=

    Espero haberme explicado con más claridad ahora.

    Muchas gracias!

  9. [...] Para una informacin completa sobre la clase Matcher: Matcher (Java 2 Platform SE v1.4.2) Ejemplos Ejemplos de expresiones regulares en Java Bpsm1nd – The beauty of the baud FUENTE : Expresiones regulares en Java (I) – Pattern y Matcher Bpsm1nd – The beauty of the baud [...]

  10. Hola, tengo una cadena que quiero dividir. ej
    texto = ‘hola a todos (hola)’
    quiero que me muestre hasta antes del (.

  11. Hola Estoy editando un Block De Notas en Java que reconosca palabras reservadas de un lenguaje de programacion ya encuentra la plabra reservada bueno este es mi codigo
    //buscar la palabra reservada Math
    pat=Pattern.compile(“Math”);
    mat=pat.matcher(l);
    if(mat.find()){
    System.out.println(“se encontro la palabra Math”); }
    mi problema es ya localizandola como la puedo pintar de otro color kisiera k me ayudaran

  12. HOOla gracias por compartir tus conocimientos, son muy utiles

  13. Estimado:

    Necesito rescatar a traves de java en un documento html el meta tad desccription del sitio web:

    ejm:

    este meta esta dentrop del header de un sitio web donde existen muchos mas tag

    necesito una expresion regular que recupere los datos del content que se encuentra dentro de este tipo de tag

    de antemano muchas gracias

  14. Alguien me puede ayudar…
    Necesito armar el siguiente patron…

    Por Ejemplo…
    AAABBCCCCDDDWJ

    Encuentreme la mayor ocurrencia de letras seguidas.. en este caso el resultado sería..
    1 ocurrencia: CCCC (por que hay 4)
    2 ocurrencia: AAA
    3 ocurrencia: DDD
    4 ocurrencia: BB
    5 ocurrencia: W
    6 ocurrencia: J

    aqui tenemos encuenta el orden de izq a derecha (me explico si la cadena esa BBBAAA)
    la salida sería
    1 ocurrencia:BBB
    2 ocurrencia:AAA

    Pattern.compile(“[A-Z]{4}”);

    en este caso para que el Pattern me busque cadena que empiezen con letras de la A-Z y que contengas 4 letras seguidas .

    pero no me funciona.. alguien me puede ayudar con algo

    GRacias por la ayuda


Deja un comentario

Introduce tus datos o haz clic en un icono para iniciar sesión:

Logo de WordPress.com

Estás comentando usando tu cuenta de WordPress.com. Cerrar sesión / Cambiar )

Imagen de Twitter

Estás comentando usando tu cuenta de Twitter. Cerrar sesión / Cambiar )

Foto de Facebook

Estás comentando usando tu cuenta de Facebook. Cerrar sesión / Cambiar )

Google+ photo

Estás comentando usando tu cuenta de Google+. Cerrar sesión / Cambiar )

Conectando a %s

Categorías

Seguir

Recibe cada nueva publicación en tu buzón de correo electrónico.

A %d blogueros les gusta esto: