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.

Lista de caracteres
Figura 1. Lista de caracteres

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);
	}
}
Listagem 1. Exemplo simples da classe matches

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);
	}
} 
Listagem 2. Modificador ignora letras maiúsculas e minúsculas

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);

	}
}
Listagem 3. Validações de caracteres
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);
	}
}
Listagem 4. Exemplos de ocorrências

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.

Lista dos quantificadores
Figura 2. Lista dos 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);
	}
}
Listagem 5. Demonstração dos quantificadores

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.

Lista dos metacaracteres de fronteira
Figura 3. Lista dos metacaracteres de fronteira
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);

	}
}
Listagem 6. Demonstração dos metacaracteres

Agrupadores

Tem como objetivo agrupar conjuntos de caracteres que tenham alguma das ações descritas na Figura 4 e Listagem 7.

Lista dos agrupadores
Figura 4. Lista dos agrupadores
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);
	}
}
Listagem 7. Demonstração de agrupadores

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.

Links de referência