[b]Introdução a Expressões Regulares com Java[/b]
Por Tadeu R. A. Santos
A partir da versão 1.4 do J2SE, Java conta com um bom suporte a expressões
regulares. Este tutorial tenta servir de introdução a este conceito com aplicação
Java.
1. O que são expressões regulares?
Trata-se de um método formal para se especificar um padrão de texto.
O uso de expressões regulares na computação é abundante e praticamente
pré-histórico. Isto se deve pela facilidade de se fazer comparações, a fim de achar
uma dada palavra (ou parte dela) em um texto.
2. Aplicações
Quando, em um SO de modo texto, deseja-se listar todos os arquivos começados por J
em um determinado diretório, basta fazer:
ls J* (unix like) ou
dir J* (dos)
Neste caso, o uso do caractere * dá-se de forma especial, significando "qualquer
cadeia de caractere (String)". Assim serão mostrados arquivos como:
Java.txt;
JavaFree.rox;
JavaDetona.net;
Entre outros começados com J.
Chamamos J*, então, de expressão regular.
Como esse exemplo, existem centenas de aplicações onde as expressões regulares
poupam um bom trabalho na implementação.
Para fim de exemplo didático, será mostrado um código simples para validar endereços
de email (hello world das expressões regulares :D).
[b]3. Gramática das Expressões Regulares[/b]
Antes do exemplo, porém, seria de bom tom o conhecimento dos caracteres especiais
usados em expressões regulares. Apesar de ser um assunto extenso, será abordado
somente alguns dos caracteres especiais mais usados e aceitos pela API do Java, a
saber: [\^]?*+-.
*
Qualquer cadeia de caractere.
Expressão Regular: J*Free // Qualquer coisa que comece com J e termine com Free
String comparada: JavaFree
String válida: sim
String comparada: JavaPago
String válida: não
[ ]
Um dos elementos do conjunto
Expressão Regular: [rgp]ato // Qualquer palavra com a primeira letra sendo ou 'r' ou
'g' ou 'p', e as letras seguintes sendo "ato"
String comparada: pato
String válida: sim
String comparada: gato
String válida: sim
String comparada: xato
String válida: não
^
Exclusão
Expressão Regular: [^rgp]ato // Qualquer palavra cuja primeira letra NÃO é 'r' nem
'g' nem 'p', sendo "ato" o resto da palavra
String comparada: rato
String válida: não
String comparada: xato
String válida: sim
-
Intervalo
Expressão Regular: [H-L]avaFree // A primeira letra da palavra deve está entre H e L
(inclusive H e L)
String comparada: JavaFree
String válida: sim
String comparada: RavaFree
String válida: não
.
Qualquer caractere
Expressão Regular: JavaFre.
String comparada: JavaFree
String válida: sim
Classe de caracteres pré-definidos. São eles:
\d : Um dígito,
\D : Algo que não seja um dígito,
\s : Um espaço em branco,
\S : Algo que não seja um espaço em branco,
\w : Qualquer letra, dígito ou underscore ( _ )
\W : Algo que não seja letra, dígito ou underscore
Expressão regular: \wJavaFree\s200\d\w
String comparada: _JavaFree 2004_
String válida: sim
?
Uma ou nenhuma vez, assim como '*', '?' é um elemento [i]quantificador[/i].
Expressão regular: a? // Uma ou nenhuma ocorrência de 'a'
String comparada:
String válida: sim
String comparada: a
String válida: sim
+
Uma ou mais vezes, assim como '*' e '?', é um elemento [i]quantificador[i].
Expressão regular: a+ // Uma ou mais ocorrências de 'a'
String comparada:
String válida: não
String comparada: aaa
String válida: sim
Pode-se ainda combinar todos esses caracteres especiais em uma só expressão regular,
formando uma busca mais restringente.
[b]4. Java API[/b]
Java dispõe de mecanismos muito bons para o tratamento de expressões regulares no
pacote java.util.regex . Para um melhor aproveitamento, é aconselhável o estudo da
documentação deste pacote disponível em:
[url]http://java.sun.com/j2se/1.4.2/docs/api/java/util/regex/package-summary.html[/url]
Um objeto da classe Pattern contém a expressão regular desejada que será usada em
uma comparação. Já um objeto da classe Matcher contém os métodos que validarão nossa
String, dada uma expressão regular.
Ex.:
Pattern padrao = Pattern.compile("Java*");
Matcher pesquisa = padrao.matcher("JavaFree");
if (pesquisa.matches())
{
System.out.println("JavaFree Rox");
}
else
{
System.out.println("Hum..?");
}
O exemplo acima poderia, ainda, ser feito somente com o uso do método [b]boolean
matches(String regex, CharSequence entrada)[/b] da classe Pattern, da seguinte
forma:
if (Pattern.matches("Java*", "JavaFree"))
{
System.out.println("JavaFree Rox");
}
else
{
System.out.println("Hum..?");
}
Estes exemplos mostram que é bem fácil trabalhar com expressões regulares em Java.
5. Exemplo: Validar um Endereço de Email
Fica bem simples, agora, validar um endereço de email (ou outro dado qualquer).
/* Exemplo prático
*
* Verifica se um endereço de email é válido
*
* Compilar: javac ValidarEmail.java
* Executar: java ValidarEmail teste@meuemail.com
*/
// --------------------------------------------------------------- classes nativas
import java.util.regex.*;
// --------------------------------------------------------------- nossa classe
class ValidarEmail
{
public static void main (String[] args)
{
if (args.length < 1) // Falta argumentos de execução
{
System.out.println("Uso: java ValidarEmail <seu@email.com>");
}
else
{
// Email válido é na forma usario@endereco.com , usario@endereco.com.br, etc.
// Tente fazer um expressão mais restringente :D
Pattern padrao = Pattern.compile(".+@.+\\.[a-z]+");
Matcher pesquisa = padrao.matcher(args[0]);
if (pesquisa.matches())
{
System.out.println("O email " + args[0] + " eh valido!");
}
else
{
System.out.println("O email " + args[0] + " nao eh valido!");
}
}
}//end main()
}//ValidarEmail.class
Vale sempre estudar a documentação das classes. O exemplo dado aqui é bem trivial,
exitem mais métodos com outras funcionalidade muito boas no pacote.
6. Referências
[1] Sun Microsystems Inc, The Java[tm] Tutorial Lesson: Regular Expressions
[url]java.sun.com/docs/books/tutorial[/url]
[2] JARGAS, Aurélio Marinho, EXPRESSÕES REGULARES
[url]guia-er.sourceforge.net/guia-er.html#toc1[/url], 25 abr, 2003]
[3] SHAH, Hetal C. , Regular Expressions in J2SE [onjava.com, 26 nov, 2003]
Até o próximo,
Tadeu R. A. Santos
