Você está na página 1de 28

Introduo a Expresses Regulares com Java

Introduo a Expresses Regulares com Java


Por Tadeu R. A. Santos

A partir da verso 1.4 do J2SE, Java conta com um bom suporte a expresses
regulares. Este tutorial tenta servir de introduo a este conceito com aplicao
Java.

1. O que so expresses regulares?

Trata-se de um mtodo formal para se especificar um padro de texto.
O uso de expresses regulares na computao abundante e praticamente
pr-histrico. Isto se deve pela facilidade de se fazer comparaes, a fim de achar
uma dada palavra (ou parte dela) em um texto.


2. Aplicaes

Quando, em um SO de modo texto, deseja-se listar todos os arquivos comeados por J
em um determinado diretrio, basta fazer:
1. ls J* (unix like) ou
2. dir J* (dos)



Neste caso, o uso do caractere * d-se de forma especial, significando "qualquer
cadeia de caractere (String)". Assim sero mostrados arquivos como:
1. Java.txt;
2. JavaFree.rox;
3. JavaDetona.net;


Entre outros comeados com J.


Chamamos J*, ento, de expresso regular.
Como esse exemplo, existem centenas de aplicaes onde as expresses regulares
poupam um bom trabalho na implementao.

Para fim de exemplo didtico, ser mostrado um cdigo simples para validar endereos
de email (hello world das expresses regulares :D).


3. Gramtica das Expresses Regulares

Antes do exemplo, porm, seria de bom tom o conhecimento dos caracteres especiais
usados em expresses 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.

Expresso Regular: J*Free // Qualquer coisa que comece com J e termine com Free

String comparada: JavaFree
String vlida: sim

String comparada: JavaPago
String vlida: no

[ ]
Um dos elementos do conjunto

Expresso 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 vlida: sim

String comparada: gato
String vlida: sim

String comparada: xato
String vlida: no

^
Excluso

Expresso Regular: [^rgp]ato // Qualquer palavra cuja primeira letra NO 'r' nem
'g' nem 'p', sendo "ato" o resto da palavra

String comparada: rato
String vlida: no

String comparada: xato
String vlida: sim

-
Intervalo

Expresso Regular: [H-L]avaFree // A primeira letra da palavra deve est entre H e L
(inclusive H e L)

String comparada: JavaFree
String vlida: sim

String comparada: RavaFree
String vlida: no

.
Qualquer caractere

Expresso Regular: JavaFre.

String comparada: JavaFree
String vlida: sim

\
Classe de caracteres pr-definidos. So eles:
1. \d : Um dgito,
2. \D : Algo que no seja um dgito,
3. \s : Um espao em branco,
4. \S : Algo que no seja um espao em branco,
5. \w : Qualquer letra, dgito ou underscore ( _ )
6. \W : Algo que no seja letra, dgito ou underscore


Expresso regular: \wJavaFree\s200\d\w

String comparada: _JavaFree 2004_
String vlida: sim
?
Uma ou nenhuma vez, assim como '*', '?' um elemento quantificador.

Expresso regular: a? // Uma ou nenhuma ocorrncia de 'a'

String comparada:
String vlida: sim

String comparada: a
String vlida: sim

+
Uma ou mais vezes, assim como '*' e '?', um elemento [i]quantificador[i].

Expresso regular: a+ // Uma ou mais ocorrncias de 'a'

String comparada:
String vlida: no

String comparada: aaa
String vlida: sim


Pode-se ainda combinar todos esses caracteres especiais em uma s expresso regular,
formando uma busca mais restringente.

4. Java API

Java dispe de mecanismos muito bons para o tratamento de expresses regulares no
pacote java.util.regex . Para um melhor aproveitamento, aconselhvel o estudo da
documentao deste pacote disponvel em:
http://java.sun.com/j2se/1.4.2/docs/api/java/util/regex/package-summary.html

Um objeto da classe Pattern contm a expresso regular desejada que ser usada em
uma comparao. J um objeto da classe Matcher contm os mtodos que validaro
nossa
String, dada uma expresso regular.

Ex.:
1. Pattern padrao = Pattern.compile("Java*");
2. Matcher pesquisa = padrao.matcher("JavaFree");
3.
4. if (pesquisa.matches())
5. {
6. System.out.println("JavaFree Rox");
7. }
8. else
9. {
10. System.out.println("Hum..?");
11. }


O exemplo acima poderia, ainda, ser feito somente com o uso do mtodo boolean
matches(String regex, CharSequence entrada) da classe Pattern, da seguinte
forma:
1. if (Pattern.matches("Java*", "JavaFree"))
2. {
3. System.out.println("JavaFree Rox");
4. }
5. else
6. {
7. System.out.println("Hum..?");
8. }


Estes exemplos mostram que bem fcil trabalhar com expresses regulares em Java.

5. Exemplo: Validar um Endereo de Email

Fica bem simples, agora, validar um endereo de email (ou outro dado qualquer).
1. /* Exemplo prtico
2. *
3. * Verifica se um endereo de email vlido
4. *
5. * Compilar: javac ValidarEmail.java
6. * Executar: java ValidarEmail teste@meuemail.com
7. */
8.
9. // --------------------------------------------------------------- classes nativas
10. import java.util.regex.*;
11.
12. // --------------------------------------------------------------- nossa classe
13. class ValidarEmail
14. {
15. public static void main (String[] args)
16. {
17. if (args.length < 1) // Falta argumentos de execuo
18. {
19. System.out.println("Uso: java ValidarEmail <seu@email.com>");

20. }
21. else
22. {
23. // Email vlido na forma usario@endereco.com , usario@ender
eco.com.br, etc.
24. // Tente fazer um expresso mais restringente :D
25. Pattern padrao = Pattern.compile(".+@.+\\.[a-z]+");
26.
27. Matcher pesquisa = padrao.matcher(args[0]);
28.
29. if (pesquisa.matches())
30. {
31. System.out.println("O email " + args[0] + " eh valido!");
32. }
33. else
34. {
35. System.out.println("O email " + args[0] + " nao eh valido!");

36. }
37. }
38. }//end main()
39. }//ValidarEmail.class


Vale sempre estudar a documentao das classes. O exemplo dado aqui bem trivial,
exitem mais mtodos com outras funcionalidade muito boas no pacote.


Validando dados com expresses regulares em Java
O que validar dados? Podemos dizer que validar dados verificar se os dados
informados pelos usurios( insira aqui seu apelido carinhoso ) esto em um formato que
no ir danificar nosso programa,ou seja, que os dados informados tero a forma e os
valores desejados( acredite o usurio vai digitar letras em um campo numrico).
Como voc pode ver no titulo deste post vamos utilizar expresses regulares para
validar nossos dados, mas que diabos uma expresso regular? Simplificando uma
expresso regular uma srie de caracteres capaz de descrever outras sries de
caracteres. Complicado? Um pouco no inicio talvez, mas vamos com calma analisando
um exemplo simples, um telefone por exemplo
1 3412-1234
Como podemos ver este dado composto somente de caracteres numricos e
formatado com quatro caracteres numricos, um caractere - e mais quatro caracteres
numricos. Vejamos como ficaria a expresso regular que expressaria essa regra:
1 \d{4,4}-\d{4,4}
Esta expresso poderia descrever diversos telefones que seguirem esta regra de
formatao, por exemplo os telefones abaixo:
1
2
3
3414-4974
9698-1101
3412-1234
e no encontraria os seguintes.
1
2
3
12902398
13244-54452
asdf-hjkl
Ento vamos destrinchar a expresso
\d: um meta caractere do tipo representante, que no caso representa um caractere
numrico, ou seja de 0-9
{4,4}: um quantificador ele representa quantas vezes o caractere anterior pode ser
repetido, no caso no minimo quatro e no mximo quatro.
- : o caractere - mesmo!
Meta caractere, quantificador?
Calma no criemos pnico! Um representante um caractere que representa uma srie
de outros caracteres.
Meta caracteres
\d: Um dgito
\s: Um caractere de espao em branco
\w: Um caractere de palavra(letras, dgitos ou _)
. : Qualquer caractere
Um aviso importante que para utiliz-los em uma aplicao dentro de uma String
devemos escapar as barras com mais uma barra. Ento para validar um nmero inteiro
devemos utilizar a seguinte expresso:
1 "\\d"
Se nos interessar pesquisar por um grupo limitado de caracteres podemos especificar
uma lista atravs de colchetes. Por exemplo a lista [abc] ir somente encontrar os
caracteres a, b ou c
[bcf]aixa ir encontrar as seguintes palavras baixa, caixa e faixa
Texto[1234] ir encontrar as seguintes palavras Texto1, Texto2, Texto3
Tambm podemos especificar um intervalo de valores utilizando um hfen dentro do
colchete.
[a-z]teste ir encontrar as seguintes palavras ateste, dteste, oteste, pteste
Bom at agora vimos como encontrar um caractere, mas se quisermos que este caractere
pudesse ser repetido inmeras vezes? Utilizaramos um quantificador, que um
caractere que informa quantas vezes um meta caractere pode/deve ser repetido.
Quanificadores
?: Pode se repetir 0 ou 1 vez
*: Pode se repetir uma ou vrias vezes
+: Pode se repetir uma ou vrias vezes
{n,m}: Pode se repetir de n at m vezes
Agora podemos criar algumas expresses um pouco mais rebuscadas, como uma para
validar placas de carros:
1 [a-zA-Z]{3,3}-\\d{4,4}
Vamos analisar a expresso, temos entre colchetes duas listas que informam que s ser
aceito caractere de a at z tanto maisculo como minusculo que podem ser repetido
no minimo 3 vezes e no mximo 3 vezes. Seguido deve possuir um trao e aps um
caractere numrico que pode se repetir no minimo 4 vezes e no mximo 4 vezes.
Agora vamos ao cdigo Java para validar:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class ValidaPlaca {


public static void main(String args[]){
Pattern pattern = Pattern.compile("[a-zA-Z]{3,3}-\\d{4,4}");
Matcher matcher = pattern.matcher("ETE-1234");

if( matcher.find() ){
System.out.println("Encontrou");
}else{
System.out.println("No encontrou");
}
}
}
Na linha 8 criamos um objeto Pattern que responsvel por armazenar uma expresso
regular que ser utilizado pelo objeto Matcher que responsvel pelas buscar.
O mtodo find()(linha 11) retorna true se encontrar o padro de caracteres especificado
pelas expresses regulares na String passada na linha 12.
O objeto Matcher pode buscar vrias ocorrncias do padro em sua String possuindo
mtodos para retornar estas ocorrncias e e suas posies. Veja o exemplo abaixo:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class ValidaPlaca {


public static void main(String args[]){
Pattern pattern = Pattern.compile("[a-zA-Z]{3,3}-\\d{4,4}");
Matcher matcher = pattern.matcher("ETE-1234 ZXC-4567 cdr-0987");

boolean b = false;
while( b = matcher.find() ){
if( b ){
System.out.println( matcher.group()+" - Posio: "+matcher.start() );
}else{
System.out.println("No encontrou");
}
}
}
}
Voc pode fazer mais uns teste com outras expresses como:
CEP
1 "^\\d{5,5}-?\\d{3,3}$"
E-mail(no est 100% mas d para ter uma idia)
1 "^[a-zA-Z0-9_\\.-]+@([a-zA-Z0-9]\\.)*([a-zA-Z0-9])*\\."
Expresses Regulares

Introduo
Para este tutorial, necessrio que voc j esteja familiarizado com expresses
regulares, como as utilizadas em Perl ou PHP. Utilizar Strings em java sempre foi muito
fcil, por causa do sobrecarregamento do operador de adio. Porm, fazer buscas e
substituies era o contrrio. A api da java.lang.String e java.lang.StringBuffer no
eram o suficiente para tarefas um pouco mais complicadas, o que forava os usurios a
buscarem alternativas opensource, como o projeto oro da Apache Jakarta. Aps o
lanamento da verso final do J2SE 1.4, as coisas melhoraram, e muito. Agora o J2SE
conta com o pacote java.util.regex, que implementa expresses regulares. Alm deste
pacote, as classes java.lang.String e java.lang.StringBuffer agora tem uma API que
trabalha em conjunto com este novo pacote, e elas implementam a nova interface
java.lang.String e java.lang.CharSequence, o que acabou com os pesadelos dos
programadore quando tinham de criar um mtodo sobrecarregado para aceitar tanto uma
String quanto um StringBuffer. Atravs deste tutorial, voc ir aprender o bsico de
como utilizar estas novas classes e mtodos.
Utilizando o pacote java.util.regex
incrvel, mas este pacote possui apenas 2 classes. A classe Pattern representa uma
expresso regular j compilada, isto , j preparada para o uso. Como "compilar" uma
expresso regular algo relativamente custoso, voc no tem acesso direto ao construtor
da classe, desta maneira, voc obrigado a utilizar o mtodo esttico compile(String
regex), dando oportunidade para a classe criar um pool de expresses j compiladas,
reaproveitando tempo no caso de voc querer compilar a mesma expresso regular.
Criando um Pattern
view plainprint?
1. Pattern pegaJava = Pattern.compile("java");

Com isto, temos uma expresso regular j engatilhada, que ir procurar pela String
"java". Agora, devemos utilizar o Pattern que j possumos, para isso, precisamos de um
Matcher, que ir "executar" a expresso em cima de uma dada String (CharSequence):
view plainprint?
1. Pattern pegaJava = Pattern.compile("java");
2. // primeiro Java est em mausculo!
3. Matcher m = pegaJava.matcher("O Java muito java!");
4.
5. // enquanto o Matcher encontrar o pattern na String fornecida:
6. while (m.find()) {
7. System.out.println(m.group());
8. }

Repare que desta maneira, o nosso Pattern apenas encontrou o "java" minsculo. Voc
tem uma srie de opes que pode utilizar quando cria um Pattern:
view plainprint?
1. Pattern pegaJava = Pattern.compile("java", CASE_INSENSITIVE);

Ok, este exemplo foi muito simples, e apenas para ter a idia bsica do funcionamento
da API. Agora vamos a um exemplo real, suponho que temos um texto, e queremos
encontrar todo o texto que est entre aspas simples. Isto : "E ele disse: 'java', 'guj',
'ninja'!" ir imprimir "java guj ninja". Vamos l:
view plainprint?
1. String frase = "E ele disse: 'java'!";
2. Pattern p = Pattern.compile("'(.*?)'");
3. Matcher m = p.matcher(frase);
4.
5. while (m.find()) {
6. // chamada diferente:
7. System.out.println(m.group(1));
8. }

Agora ns utilizamos o mtodo group(int) do Matcher ao invs do group(), porque?
Desta maneira, ser apenas retornado o contedo que foi encontrado referente ao
primeiro parnteses do expresso regular, no nosso caso, o que est entre aspas simples.
Caso houvessem mais grupos, a ordem definida pela ordem de apario dos parnteses
de abertura. Um "grupo" nada mais que o resultado da busca em relaao a um dos
parenteses. Se nenhum grupo for especificado, ser considerada a expresso por inteira,
como no caso anterior.
Utilizando expresses regulares pela API nova da String
Um exemplo clssico, fazer o split de uma data do formato americano, passando-a
para o formato brasileiro. Antes, utilizaramos um StringTokenizer, ainda correndo o
risco de encontrar alguns NullPointerExceptions, mas agora:
view plainprint?
1. String data = "12-30-2002"; // MM-DD-AAAA
2. /* usamos duas barras invertidas, pois caso
3. contrrio ela ser reconhecida apenas como caractere
4. de escape */
5. String dataBrasileira = data.replaceAll("(\\d\\d)-(\\d\\d)-
(\\d\\d\\d\\d)", "\$2/\$1/\$3");

Fcil no? Acho que agora foi um pouco rpido. O Smbolo "$n", onde n um nmero,
indica que esta parte deve ser substituida pelo respectivo grupo! Perl tem a mesma
funcionalidade. Alm disso, vamos dividir esse cdigo para utilizar o pacote
java.util.regex, para ficar claro o que acontece utilizando o replaceAll(String, String):
view plainprint?
1. String data = "12-30-2002"; // MM-DD-AAAA
2. Pattern p = Pattern.compile("(\\d\\d)-(\\d\\d)-(\\d\\d\\d\\d)");
3. Matcher m = p.matcher(data)
4. if (!m.find()) {
5. throw new Exception("A data no est no formato americano");
6. }
7. String dataBrasileira = m.replaceAll("\$2/\$1/\$3");

Repare que no trecho anterior adicionamos um if para saber se o formato estava ok. Isto
no iria acontecer se voc utilizasse diretamente o mtodo da String. Agora suponha que
voc queira remover todos os tags HTML de uma String. Com o StringTokenizer voc
ia ter um bom trabalho, mas com a nova API:
view plainprint?
1. String comHtml = "retirando <a href=zzz>cdigo html</a>";
2. String semHtml = comHtml.replaceAll("<.*?>", "");

A Pattern "<.*?>" que dizer o seguinte: encontre tudo (o "." indica qualquer caracter
exceto nova linha) que estiver entre < e >; o ? indica que o Pattern deve ser no guloso
(greedy), isto , ele deve parar o mais cedo possvel, seno o .* iria reconhecer a String
inteira (tente sem o ?). Novamente, repare que o cdigo anterior 100% equivalente
com este:
view plainprint?
1. String comHtml = "retirando <a href=zzz>cdigo html</a>";
2. Pattern p = Pattern.compile("<.*?>");
3. Matcher m = p.matcher(comHtml);
4. String semHtml = m.replaceAll("");

Com isto, voc no vai mais sentir saudades do seu velho amigo StringTokenizer...
Existem ainda outros mtodos como o split(String) que faz a exploso da tring em um
array, de acordo com a expresso regular passada para o mtodo. Este tutorial abrange
apenas o comeo, para maior referncia, consulte a api da classe java.util.regex.Pattern,
que uma boa explicao sobre os quantificadores que voc pode usar na expresso
regular.

Expresso regular no Java
Uma expresso regular, na Informtica, define um padro a ser usado para procurar
ou substituir palavras ou grupos de palavras. um meio preciso de se fazer buscas de
determinadas pores de texto.
O uso atual de expresses regulares inclui procura e substituio de texto em editores
de texto e linguagens de programao, validao de formatos de texto (validao de
protocolos ou formatos digitais), realce de sintaxe e filtragem de informao.
Referncia:
http://docs.oracle.com/javase/tutorial/essential/regex
Expresso regular foi usada nos posts:
1) Scanner java
Usando o mtodo matcher.find(), que veremos a seguir, voc pode localizar textos e
substitu-los, e usando o matcher.matches(), podemos conferir se toda a String bate
com a expresso.
O que veremos nesse tutorial:
1) String literal
2) Colocando caracteres especficos
3) Smbolos pr definidos
4) Quantificando nmero de caracteres
5) Usando expresso regular para checar e-mail

Passos:
1) Usaremos a classe Pattern para registrar a expresso
2) Usaremos a classe Matcher para armazenar nossa expressao, Pattern, e comparar com
a nossa String.
1) String literal:
Podemos bater nossas frases com uma palavra fixa.
Exemplo 1:
1
2
3
4
5
package br.com.byiorio;

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

6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
//Referencia
// http://docs.oracle.com/javase/tutorial/essential/regex/

public class Regex {
public Regex() {

//Bem simples, uma palavra somente
String frase = "foo";

//Onde registramos a expresso regular
Pattern pattern = Pattern.compile("foo");

//Onde registramos o comparador
Matcher matcher = pattern.matcher(frase);

//Loop para verificar o que foi encontrado
while (matcher.find()) {
System.out.printf("Encontrado: \"%s\" de %d %d.%n",
matcher.group(), matcher.start(), matcher.end());
}

//Testando se bate exatamente
if (matcher.matches()) {
System.out.println("Bateu exatamente");
}else{
System.out.println("Nao Bateu exatamente");
}
33
34
35
36
37
38
39
}

public static void main(String args[]) {
new Regex();
}

}
Resultado
1
2
Encontrado: "foo" de 0 3.
Bateu exatamente
Exemplo 2:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
package br.com.byiorio;

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

//Referencia
// http://docs.oracle.com/javase/tutorial/essential/regex/

public class Regex {
public Regex() {

//Bem simples, uma palavra somente
String frase = " foofoofoo foo foo fooo";

15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
//Onde registramos a expresso regular
Pattern pattern = Pattern.compile("foo");

//Onde registramos o comparador
Matcher matcher = pattern.matcher(frase);

//Loop para verificar o que foi encontrado
while (matcher.find()) {
System.out.printf("Encontrado: \"%s\" de %d %d.%n",
matcher.group(), matcher.start(), matcher.end());
}

//Testando se exatamente
if (matcher.matches()) {
System.out.println("Bateu exatamente");
}else{
System.out.println("Nao Bateu exatamente");
}
}

public static void main(String args[]) {
new Regex();
}

}
Resultado:
1
2
3
4
5
6
7
Encontrado: "foo" de 1 4.
Encontrado: "foo" de 4 7.
Encontrado: "foo" de 7 10.
Encontrado: "foo" de 11 14.
Encontrado: "foo" de 15 18.
Encontrado: "foo" de 19 22.
No Bateu exatamente
Para facilitar o tutorial, irei remover a parte de busca e vamos testar somente se a
expresso bate com a frase ou palavra. Caso tenha alguma dvida ou queira alguma
ajuda, deixe um comentrio.
2) Colocando caracteres especficos
[abc] Aceitar a, b, ou c. Pode colocar qualquer sequncia de letras por exemplo [fgh]
[^abc] Colocando o ^ fica a negao, portanto aceita todos menos a, b ou c.
[a-zA-Z] De A at Z minsculo e maisculo
[a-d[m-p]] De A at D OU M at P, podemos combinar RANGES usando [a-dm-p]
[a-z&&[def]] && seria igual o AND ou && no caso do JAVA, a frase teria que estar
dentro de A at Z e tambm ser d, e ou F.
[a-z&&[^bc]] A mesma coisa acima com negao.
[a-z&&[^m-p]] Mesma coisa com negao de ranges ao invs de letras.
Como ainda no vimos os quantificadores, veremos mais abaixo neste mesmo tutorial,
os testes sero feitos apenas com um caractere
Para facilitar, criei um mtodo para receber os valores e a expresso
Conforme o primeiro exemplo, os valores da expresso regular que aprendemos agora ,
sero colocados no mtodo Pattern.compile(expressao); exemplo
Pattern.compile([a-z]);
1
2
3
4
5
6
package br.com.byiorio;

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

public class RegexSimples {
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
public RegexSimples() {
//valores a serem testados em um array
String[] valores = {"a","b","c", "d", "1", "2", "3", "4"};
//chamando o metodo para printar na tela
//expressao que so aceita letras de A ate Z
checkRegex(valores,"[a-z]");

//expressao que so aceita letras de A ate B e de D ate Z
checkRegex(valores,"[a-bd-z]");

//Os mesmos valores para uma expressao diferente, so aceita numericos
checkRegex(valores,"[0-9]");

//Os mesmos valores para uma expressao diferente, so aceita numericos
retirando o numero 1
checkRegex(valores,"[0-9&&[^1]]");
}

public static void main(String[] args) {
//criar uma nova classe assim que o programa e executado
new RegexSimples();
}

private void checkRegex(String[] valores, String expressao) {

System.out.println("\r\nNovo Teste:");
//Looping para varrer todos os valores a serem testados
34
35
36
37
38
39
40
41
42
43
44
45
for (String valor : valores) {

//Setando a expressao regular passada de parametro
Pattern pattern = Pattern.compile(expressao);

//Setando com o valor atual, a ser testado, no loop
Matcher matcher = pattern.matcher(valor);

//imprimir resultado na tela
System.out.println("o Valor " + valor + " para a expressao " + expressao + "
resultou em " + matcher.matches());
}
}
}
Resultado:
1
2
3
4
5
6
7
8
9
10
11
Novo Teste:
o Valor a para a expressao [a-z] resultou em true
o Valor b para a expressao [a-z] resultou em true
o Valor c para a expressao [a-z] resultou em true
o Valor d para a expressao [a-z] resultou em true
o Valor 1 para a expressao [a-z] resultou em false
o Valor 2 para a expressao [a-z] resultou em false
o Valor 3 para a expressao [a-z] resultou em false
o Valor 4 para a expressao [a-z] resultou em false

Novo Teste:
12
13
14
15
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
o Valor a para a expressao [a-bd-z] resultou em true
o Valor b para a expressao [a-bd-z] resultou em true
o Valor c para a expressao [a-bd-z] resultou em false
o Valor d para a expressao [a-bd-z] resultou em true
o Valor 1 para a expressao [a-bd-z] resultou em false
o Valor 2 para a expressao [a-bd-z] resultou em false
o Valor 3 para a expressao [a-bd-z] resultou em false
o Valor 4 para a expressao [a-bd-z] resultou em false

Novo Teste:
o Valor a para a expressao [0-9] resultou em false
o Valor b para a expressao [0-9] resultou em false
o Valor c para a expressao [0-9] resultou em false
o Valor d para a expressao [0-9] resultou em false
o Valor 1 para a expressao [0-9] resultou em true
o Valor 2 para a expressao [0-9] resultou em true
o Valor 3 para a expressao [0-9] resultou em true
o Valor 4 para a expressao [0-9] resultou em true

Novo Teste:
o Valor a para a expressao [0-9&&[^1]] resultou em false
o Valor b para a expressao [0-9&&[^1]] resultou em false
o Valor c para a expressao [0-9&&[^1]] resultou em false
o Valor d para a expressao [0-9&&[^1]] resultou em false
o Valor 1 para a expressao [0-9&&[^1]] resultou em false
o Valor 2 para a expressao [0-9&&[^1]] resultou em true
o Valor 3 para a expressao [0-9&&[^1]] resultou em true
39 o Valor 4 para a expressao [0-9&&[^1]] resultou em true
3) Smbolos pr definidos
\d Simboliza dgitos de 0 at 9 [0-9]
\D Dgitos que no esto entre 0 at 9 [^0-9]
\s Simboliza espao em branco. [ \t\n\x0B\f\r]
\S Sem espaos em branco [^\s]
\w Todos os caracteres de A at Z e 0 at 9 , incluindo underline _ [a-zA-Z_0-9]
\W No permitido os caracteres anteriormente mostrados [^\w]
Seguindo a mesma linha do exemplo anterior, como no vimos os quantificadores,
faremos os testes usando somente um caractere. No se preocupe o prximo exemplo
aprenderemos quantificadores poderemos usar expresso para frases, etc..
Para usarmos \ dentro da String, devemos acrescentar outra \ ficando \\d por
exemplo
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
package br.com.byiorio;

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

public class RegexSimples {
public RegexSimples() {
//valores a serem testados em um array
String[] valores = {" ","b","c", "_", "1", "2", "3", "4"};
//chamando o metodo para printar na tela
//expressao que so aceita letras de A ate Z
checkRegex(valores,"\\w");

//expressao que so aceita letras de A ate B e de D ate Z
checkRegex(valores,"\\s");

//Os mesmos valores para uma expressao diferente, so aceita numericos
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
43
checkRegex(valores,"\\d");

}

public static void main(String[] args) {
//criar uma nova classe assim que o programa e executado
new RegexSimples();
}

private void checkRegex(String[] valores, String expressao) {

System.out.println("\r\nNovo Teste:");
//Looping para varrer todos os valores a serem testados
for (String valor : valores) {

//Setando a expressao regular passada de parametro
Pattern pattern = Pattern.compile(expressao);

//Setando com o valor atual, a ser testado, no loop
Matcher matcher = pattern.matcher(valor);

//imprimir resultado na tela
System.out.println("o Valor " + valor + " para a expressao " + expressao + "
resultou em " + matcher.matches());
}
}
}
Temos como Resultado
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
20
21
22
23
24
25
Novo Teste:
o Valor para a expressao \w resultou em false
o Valor b para a expressao \w resultou em true
o Valor c para a expressao \w resultou em true
o Valor _ para a expressao \w resultou em true
o Valor 1 para a expressao \w resultou em true
o Valor 2 para a expressao \w resultou em true
o Valor 3 para a expressao \w resultou em true
o Valor 4 para a expressao \w resultou em true

Novo Teste:
o Valor para a expressao \s resultou em true
o Valor b para a expressao \s resultou em false
o Valor c para a expressao \s resultou em false
o Valor _ para a expressao \s resultou em false
o Valor 1 para a expressao \s resultou em false
o Valor 2 para a expressao \s resultou em false
o Valor 3 para a expressao \s resultou em false
o Valor 4 para a expressao \s resultou em false

Novo Teste:
o Valor para a expressao \d resultou em false
o Valor b para a expressao \d resultou em false
o Valor c para a expressao \d resultou em false
o Valor _ para a expressao \d resultou em false
26
27
28
29
o Valor 1 para a expressao \d resultou em true
o Valor 2 para a expressao \d resultou em true
o Valor 3 para a expressao \d resultou em true
o Valor 4 para a expressao \d resultou em true
4) Quantificando nmero de caracteres.
Considerando que X qualquer expresso citada anteriormente.
X? Uma vez ou nenhuma.
X* Nenhuma ou mais vezes.
X+ Uma ou mais vezes
X{n} Exatamente N vezes, onde N seria um nmero especfico.
X{n,} Pelo menos N vezes.
X{n,m} Pelo menos N e no pode ser mais que M. Onde M seria um nmero especfico.
Segue um exemplo mais completo
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package br.com.byiorio;

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

public class RegexSimples {
public RegexSimples() {
//valores a serem testados em um array
String[] valores = {"testando1palavra","teste numero","teste3", "123","abc"};


// \w{3} numero ou letras com exatamente 3 caracteres
checkRegex(valores,"\\w{3}");

//[a-z]+: uma letra obrigatorio ou mais que uma letra
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
//[1]? pode aparecer o numero 1 ou nao no meio da palavra
//[a-z]* pode aparecer nenhum ou varias letras depois
checkRegex(valores,"[a-z]+[1]?[a-z]*");

//[a-z]{1,5} no minimo 1 e no maximo 5
//[0-9]* nenhum ou varios numeros
checkRegex(valores,"[a-z]{1,5}[0-9]*");

}

public static void main(String[] args) {
//criar uma nova classe assim que o programa e executado
new RegexSimples();
}

private void checkRegex(String[] valores, String expressao) {

System.out.println("\r\nNovo Teste:");
//Looping para varrer todos os valores a serem testados
for (String valor : valores) {

//Setando a expressao regular passada de parametro
Pattern pattern = Pattern.compile(expressao);

//Setando com o valor atual, a ser testado, no loop
Matcher matcher = pattern.matcher(valor);

43
44
45
46
47
//imprimir resultado na tela
System.out.println("o Valor " + valor + " para a expressao " + expressao + "
resultou em " + matcher.matches());
}
}
}
5) Usando expresso regular para checar e-mail
Usando tudo que foi mostrado aqui, montei um checador de e-mails, caso tenha
algum e-mail que no passe nessa expresso, deixe um comentrio que eu arrumarei. A
expresso usada foi [\\w-_.&]+@[\\w-_&]+[.]{1}[\\w-_]+[.]?[\\w-_]+, seguem
algumas observaes:
1) O & so para os e-mails que os clientes usam aqui.
2) Antes do @ no importa quantos pontos tenham e se eles esto juntos, porem aps o
@ devem estar no formato correto.
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
package br.com.byiorio;

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

//Referencia
// http://docs.oracle.com/javase/tutorial/essential/regex/

public class Regex {
public Regex() {

//E-mail que gostaria de testar
String[] emails = { "lucaso@aeae", "lucaso@@", "", "l", "lucaso",
"luaas.ior.io@gmail.com", "lucaso@gmail..com",
"lucaso@gmail.a", "lucaso@a.com", "luca3o@a.com",
16
17
18
19
20
21
22
23
24
25
26
27
28
29
30
31
32
33
34
35
36
37
38
39
40
41
42
"lucaso@gmail.com.", "lucaso@gmail.com",
"lucas.ioro@gmail.com", "lucas-iorio@gmail.com",
"lucas2-iorio@gmail.com", "lucas2-iorio@cas-tecnologia.com.br",
"capitani.lucas.iorio@br.experian.com",
"capitani....lucas.iorio@br.experian.com",
"&capitani....lucas.iorio@br.experian.com" };

//Testando todos os e-mails
for (String email : emails) {
if (email != null) {
System.out.println(email + " : " + checkEmail(email));
}

}
}

public static void main(String args[]) {
new Regex();
}

private boolean checkEmail(String email) {
//Registrando a expressao
Pattern pattern = Pattern.compile("[\\w-_.&]+@[\\w-_&]+[.]{1}[\\w-_]+[.]?[\\w-
_]+");
Matcher matcher = pattern.matcher(email);

//checando
43
44
return matcher.matches();
}
}
Resultado desse cdigo:
1
2
3
4
5
6
7
8
9
10
11
12
13
14
15
16
17
18
19
lucaso@aeae : false
lucaso@@ : false
: false
l : false
lucaso : false
luaas.ior.io@gmail.com : true
lucaso@gmail..com : false
lucaso@gmail.a : false
lucaso@a.com : true
lucaso@a.com : true
lucaso@gmail.com. : false
luca3o@gmail.com : true
lucas.iorio@gmail.com : true
lucas-iorio@gmail.com : true
lucas2-iorio@gmail.com : true
lucas2-iorio@cas-tecnologia.com.br : true
capitani.lucas.iorio@br.experian.com : true
capitani....lucas.iorio@br.experian.com : true
&capitani....lucas.iorio@br.experian.com : true

Você também pode gostar