Expresiones Regulares en Java

Oct 17, 2011 1 Comment by

Las expresiones regulares (para los amigos regex) son una herramienta muy potente en el mundo del desarrollo, están presentes en la mayoría de los lenguajes modernos e incluso en comandos clásicos como grep y find.

Como no, en Java, disponemos de un package dedicado a las expresiones regulares, lo podemos “importar” desde java.util.regex.*.

Validación (match)

Es una de la tareas más fundamentales en cualquier sistema, consiste en validar si un dato (String) valida respecto a cierto patrón, ejemplo, representa a un número de teléfono, e-mail, etc.

El siguiente ejemplo, valida los elementos del arreglo contra el patrón fecha (pt_fecha), email (pt_email) y registro (pt_record) usando Pattern y Matcher.

package org.deerme.examples;
import java.io.BufferedInputStream;
import java.net.URL;
import java.util.regex.*;

public class EjemplosRegex {
    public static void main(String[] args) {
        String[] entradas = {"2011/10/17","deer@deerme.org","Soy un string xD","Jose Ignacio, 56975124554","Maria Jose, 56942641243","123 Soy un record incorrecto, 23523abc"};
        // Matcher
         Matcher mt;
        // Patrones
        Pattern pt_fecha = Pattern.compile("^d{4}/d{2}/d{2}");
        Pattern pt_email = Pattern.compile("^[w-.]{3,}@([w-]{2,}.)*([w-]{2,}.)[w-]{2,4}$");
        Pattern pt_record = Pattern.compile("^[A-Za-z ]+,[ 0-9]+");
        for(int i=0; i< entradas.length; i++)
        {
            // Fecha
            mt = pt_fecha.matcher( entradas[i] );
            if ( mt.find() )
            {
                System.out.println("El string '" + entradas[i]  + "' valida con el patrón de fecha.");
            }
            //Email
            mt = pt_email.matcher( entradas[i] );
            if ( mt.find() )
            {
                System.out.println("El string '" + entradas[i]  + "' valida con el patrón de e-mail.");
            }
            // Registro del tipo "Nombre, Número Teléfonico"
            mt = pt_record.matcher( entradas[i] );
            if ( mt.find() )
            {
                System.out.println("El string '" + entradas[i]  + "' valida con el patrón de registro.");
            }
        }
    }
}

El método find (del objeto Matcher) devuelve true, si el string ingresado válida respecto al patrón, en caso contrario, devuelve false.

Tambien podriamos utilizar el método matches de la clase String.

String email = "deer@deerme.org";
if ( email.matches("^[w-.]{3,}@([w-]{2,}.)*([w-]{2,}.)[w-]{2,4}$") )
{
     System.out.println("El email es lexicamente válido");
}

Extraer (extract)

La extración de datos es otra tarea muy común de resolver con las expresiones regulares. Vamos a realizar un pequeño ejemplo que extrae el tiempo de Santiago desde el sitio web www.cooperativa.cl.

Fuente

<td align="center" width="290"><span class="resalta"><a href="/prontus_nots/site/extra/webget/clima/clima.html">El Tiempo</a>:</span> Santiago,
 temperatura: 17 °C
 humedad: 52 %</td>
package org.deerme.examples;
import java.io.BufferedInputStream;
import java.net.URL;
import java.util.regex.*;

public class EjemplosRegex {
    public static void main(String[] args) {
        // Example of extraction of data from a web site
        String cooperativa_site = "";
        byte[] buff = new byte[4096];
        try
        {
            URL url = new URL( "http://www.cooperativa.cl" );
            BufferedInputStream bis = new BufferedInputStream(url.openStream());

            int bytesRead = 0;
            while ((bytesRead = bis.read(buff)) != -1)
            {
                cooperativa_site = cooperativa_site + new String(buff, 0, bytesRead);
            }
            bis.close();

        } catch (Exception ex)
        {
            System.out.println("Problem extracting data : ( ");
        }

        Pattern pt_tiempo = Pattern.compile("El Tiempo</a>:</span>(.*?)</td>", Pattern.DOTALL | Pattern.MULTILINE );
        Matcher mt_tiempo = pt_tiempo.matcher( cooperativa_site );       

        if ( mt_tiempo.find()  )
        {
            System.out.println( "Tiempo: "  +  mt_tiempo.group(1).replace("°C", "°c").trim() );
        }
    }
}

A diferenciar del ejemplo anterior, ahora utilizamos el método group para acceder al elemento definido en nuestro patrón.

Reemplazo (replace)

Finalmente, el reemplazo es otra tarea útil que podemos resolver con la ayuda de las expresiones regulares. Podemos utilizar el método replaceAll de la clase String o Matcher.

        // Replace using String.replaceAll
        String query = "SelEct title, comment, author from articles UNION sELEct title, comment, author from comments";
        System.out.println( query.replaceAll("((S|s){1}(E|e){1}(L|l){1}(E|e){1}(C|c){1}(T|t){1})", "SELECT")  );

        // Replace using Matcher.replaceAll
        Pattern pt_select = Pattern.compile("((S|s){1}(E|e){1}(L|l){1}(E|e){1}(C|c){1}(T|t){1})");
        Matcher mt_select = pt_select.matcher(query);

        System.out.println( mt_select.replaceAll("SELECT") );
Java

About the author

Ingeniero en Informática, Oracle Certified Master Java EE 6 Enterprise Architect, Oracle Certified Professional Java Programmer. Experto en distintas ramas de la computación y otras "yerbas" xD. Si te gusto este post, sígueme en @deerme_org, escríbeme a info AT deerme.org o contactame por linkedin.

One Response to “Expresiones Regulares en Java”

  1. Jorge says:

    buen aporte, eso si, requiere que sepas ya algo de expresiones regulares

Leave a Reply


+ three = 10