Validando dados com expressões regulares em Java

O que é validar dados? Podemos dizer que validar dados é verificar se os dados informados pelos usuários( insira aqui seu apelido carinhoso ) estão em um formato que não irá danificar nosso programa,ou seja, que os dados informados terão a forma e os valores desejados( acredite o usuário vai digitar letras em um campo numérico).

Como você pode ver no titulo deste post vamos utilizar expressões regulares para validar nossos dados, mas que diabos é uma expressão regular? Simplificando uma expressão regular é uma série de caracteres capaz de descrever outras séries de caracteres. Complicado? Um pouco no inicio talvez, mas vamos com calma analisando um exemplo simples, um telefone por exemplo

3412-1234

Como podemos ver este dado é composto somente de caracteres numéricos e é formatado com quatro caracteres numéricos, um caractere “-” e mais quatro caracteres numéricos. Vejamos como ficaria a expressão regular que expressaria essa regra:

\d{4,4}-\d{4,4}

Esta expressão poderia descrever diversos telefones que seguirem esta regra de formatação, por exemplo os telefones abaixo:

3414-4974 
9698-1101 
3412-1234

e não encontraria os seguintes.

12902398 
13244-54452 
asdf-hjkl

Então vamos destrinchar a expressão

\d: É um meta caractere do tipo representante, que no caso representa um caractere numérico, 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 máximo quatro.
– : o caractere “-” mesmo!

Meta caractere, quantificador?

Calma não criemos pânico! Um representante é um caractere que representa uma série de outros caracteres.

Meta caracteres

\d: Um dígito
\s: Um caractere de espaço em branco
\w: Um caractere de palavra(letras, dígitos ou “_”)
. : Qualquer caractere

Um aviso importante é que para utilizá-los em uma aplicação dentro de uma String devemos escapar as barras com mais uma barra. Então para validar um número inteiro devemos utilizar a seguinte expressão:

"\\d"

Se nos interessar pesquisar por um grupo limitado de caracteres podemos especificar uma lista através 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”

Também podemos especificar um intervalo de valores utilizando um hífen 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 inúmeras vezes? Utilizaríamos um quantificador, que é um caractere que informa quantas vezes um meta caractere pode/deve ser repetido.

Quantificadores

?: Pode se repetir 0 ou 1 vez
*: Pode se repetir ~~uma~~ nenhuma ou várias vezes
+: Pode se repetir uma ou várias vezes
{n,m}: Pode se repetir de n até m vezes

Agora podemos criar algumas expressões um pouco mais rebuscadas, como uma para validar placas de carros:

"[a-zA-Z]{3,3}-\\d{4,4}"

Vamos analisar a expressão, temos entre colchetes duas listas que informam que só será aceito caractere de “a” até “z” tanto maiúsculo como minusculo que podem ser repetido no minimo 3 vezes e no máximo 3 vezes. Seguido deve possuir um traço e após um caractere numérico que pode se repetir no minimo 4 vezes e no máximo 4 vezes.

Agora vamos ao código Java para validar:

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("Não encontrou");
        }
    }
}

Na linha 8 criamos um objeto Pattern que é responsável por armazenar uma expressão regular que será utilizado pelo objeto Matcher que é responsável pelas buscar.

O método find()(linha 11) retorna true se encontrar o padrão de caracteres especificado pelas expressões regulares na String passada na linha 12.

O objeto Matcher pode buscar várias ocorrências do padrão em sua String possuindo métodos para retornar estas ocorrências e e suas posições. Veja o exemplo abaixo:

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()+" - Posição: "+matcher.start() );
            }else{
                System.out.println("Não encontrou");
            }
        }
    }
}

Você pode fazer mais uns teste com outras expressões como: