Em qualquer software, sempre existem campos que passam por algumas validações. O objetivo de ter essas validações é simplesmente o fato de que os dados que são informados podem ter o valor e forma determinados pelo sistema. Podemos destacar que essas validações, são como mecanismos de defesa do sistema em relação ao usuário, pois muitos dos problemas são relacionados à gravação de dados incorretos por parte do usuário.
Um exemplo é o sistema permitir apenas letras em alguns campos e o usuário acaba inserindo letras e números. Essa ação pode gerar vários problemas, pois quando esse dado é gravado, pode gerar algum erro relacionado ao banco de dados por somente aceitar números, ou estourar uma exceção do programa por não saber como se comportar com a informação enviada. Enfim, é um fator que deve ser levado a sério.
Expressão Regular
Uma expressão regular é uma String especialmente formatada que mostra um padrão de pesquisa e substituição de textos. O principal objetivo dessas expressões é fazer validações nos dados de um programa, assegurando que estes dados estejam em um determinado formato. Uma expressão consiste em caracteres literais e símbolos especiais.
Para criar uma expressão regular é necessário informar caracteres especiais usados no padrão da expressão. Esses caracteres são conhecidos como metacaracteres, indicando a ocorrência de números, letras entre outros caracteres no texto. Na Figura 1 são exibidos alguns caracteres utilizados para construir a expressão regular.
Método matches
O método matches especifica uma expressão regular e localiza o conteúdo do objeto String em que está sendo aplicada essa expressão. Para saber se essa correspondência foi atendida ou não, é retornado um valor booleano (true ou false).
Na Listagem 1 desse artigo, são mostradas alguns exemplos do que pode ser inicialmente trabalhado. Para fins de ensino, as variáveis estão sendo impressas para mostrar o valor de retorno de cada padrão utilizado.
public class TestaExpressoes {
public static void main(String[] args) {
boolean nome = "Maria".matches("Maria");
System.out.println("Retorno = "+nome);
}
}
Modificadores
Um modificador é um caractere adicionado depois de um o delimitador final, onde acaba mudando o jeito como a função irá tratar a expressão. Abaixo estão relacionados os modificadores que podem ser usados:
- (?i) - Ignora maiúsculas de minúsculas.
- (?m) - Trabalha com multilinhas.
- (?s) - Faz com que o caractere encontre novas linhas.
- (?x) - Permite inclusão de espaços e comentários.
Na Listagem 2 foi usado o modificador (?i), que faz com que o resultado tenha o retorno verdadeiro (true), pois esse modificador tem o objetivo de ignorar letras maiúsculas e minúsculas.
public class TestaExpressoes_Modificadores {
public static void main(String[] args) {
boolean sobreNome = "Silveira".matches("(?i)silveira");
System.out.println("Retorno = "+sobreNome);
}
} Abaixo, nas Listagens 3 e 4, são mostrados algumas validações de ocorrências através dos metacaracteres.
public class TestaMetacaractere {
public static void main(String[] args) {
boolean email = "@".matches(".");
System.out.println("Qualquer caractere: "+email);
boolean numero = numero = "a".matches("\\d");
System.out.println("Possui número: "+numero);
numero = "2".matches("\\d");
System.out.println("Possui número: "+numero);
boolean letrasNumeros = "A2".matches("\\w\\d");
System.out.println("Possui letras e números? "+letrasNumeros);
boolean espaco = " ".matches("\\s");
System.out.println("Possui espaço? "+espaco);
}
}
public class TestaOcorrencias {
public static void main(String[] args) {
//Procura a ocorrencia de 1 caractere
boolean caractere = "E".matches(".");
System.out.println(caractere);
//Procura a ocorrência de 2 caracteres
caractere = "Ab".matches("..");
System.out.println(caractere);
//Validação de cep
String cep = "\\d\\d\\d\\d\\d-\\d\\d\\d";
boolean valida = "99855-000".matches(cep);
System.out.println(valida);
}
}
Quantificadores
Em alguns momentos é preciso fazer com que alguns caracteres se repitam, sendo por esse motivo que os metacaracteres precisam ter um controlador, conhecido como quantificador. O quantificador é um caractere que consegue informar quantas vezes um metacaractere pode ser repetido. Na Figura 2 e na Listagem 5 há a descrição desses quantificadores.
public class TestaQuantificador {
public static void main(String[] args) {
//Procura 2 dígitos no texto
boolean valor = "74".matches("\\d{2}");
System.out.println(valor);
//Procura mais de 2 dígitos no texto
valor = "211".matches("\\d{9,}");
System.out.println(valor);
//Procura dígitos entre os valores de 2 e 5
valor = "2121".matches("\\d{2,5}");
System.out.println(valor);
//Procura dígito entre 0 e 1 vezes
valor = "22".matches(".?");
System.out.println(valor);
//Procura dígito entre 0 e mais vezes
valor = "75411".matches(".*");
System.out.println(valor);
//Procura dígito entre 1 e mais vezes
valor = "".matches(".+");
System.out.println(valor);
//Cria expressão regular resumida da data
String data = "02/05/1995";
valor = data.matches("\\d{2}/\\d{2}/\\d{4}");
System.out.println("Data: "+valor);
//Cria a expressão regular resumida do cep
String cep = "8545-222";
valor = cep.matches("\\d{4}-\\d{3}");
System.out.println("Cep: "+valor);
}
}
Metacaracteres de fronteira
Esses metacaracteres definem se a String começa ou termina com um determinado padrão, como vemos na Figura 3 e Listagem 6.
public class Metacaractere_Fronteira {
public static void main(String[] args) {
//Começa na palavra Java, continua com qualquer caractere
//a partir do . 0 e mais vezes
boolean palavra = "Java322".matches("^Java.*");
System.out.println(palavra);
//Termina com 322
//O ponto (.) Começa com qualquer caractere e busca 0
//ou mais caracteres finalizando com o num 322
palavra = "Java322".matches(".*322$");
System.out.println(palavra);
//Pesquisa se uma palavra existe no texto
palavra = "Hello World Java".matches(".*Java.*");
System.out.println(palavra);
//Pesquisa os caracteres que estão depois da letra O e antes da palavra Java
palavra = "O mundo Java".matches("^O.*Java$");
System.out.println(palavra);
//Pesquisa pela palavra Inter ou Grêmio
boolean time = "Inter".matches("Inter|Grêmio");
System.out.println("Time: "+time);
}
}
Agrupadores
Tem como objetivo agrupar conjuntos de caracteres que tenham alguma das ações descritas na Figura 4 e Listagem 7.
public class TestaAgrupadores {
public static void main(String[] args) {
//Busca qualquer letra de a até z - faz diferença utilizar maiúsculas e minúsculas
boolean palavra = "g".matches("[a-z]");
System.out.println(palavra);
//Verifica se foi escrita em letra maiúscula ou minúscula
palavra = "Java".matches("[jJ]ava");
System.out.println(palavra);
//Verifica caracteres de A até Z e a até z
palavra = "Sql".matches("[A-Z][a-z]*");
System.out.println(palavra);
//Não permite que comece com as letras a e i
palavra = "Oracle".matches("[^aei]racle");
System.out.println(palavra);
//Verifica se foi digitado o caractere "j" e "s"
//Retorna false por causa da letra "z" onde que o padrão esperava a letra "s"
palavra = "Objetoz".matches("Ob[j]eto[s]");
System.out.println(palavra);
//Validação de email
boolean email = "java@teste.com.br".matches("\\w+@\\w+\\.\\w{2,3}\\.\\w{2,3}");
System.out.println(email);
}
}
Conclusão
Esse artigo teve o objetivo de mostrar alguns fundamentos básicos sobre as expressões regulares. Acredito que através da leitura e prática dos exemplos descritos nesse artigo, já é possível desenvolver alguns padrões personalizados.
