Expressões regulaers são ferramentas poderosas para validação de padrões em strings. Este artigo explora seu uso em Java, com exemplos práticos de validação e uma visão geral da sintaxe.

Validação de um Identificador Numérico

Considere a necessidade de validar um identificador numérico com as seguintes regras: comprimento entre 6 e 20 caracteres, o primeiro caractere não pode ser zero, e todos os caracteres devem ser dígitos.

Implementação sem Expressões Regulares

Uma abordagem tradicional usando métodos de String e loops:

public class Validador {
    public static void main(String[] args) {
        String idNumerico = "0123456789";
        System.out.println(validar(idNumerico));
    }

    public static boolean validar(String entrada) {
        int comprimento = entrada.length();
        if (comprimento < 6 || comprimento > 20) {
            return false;
        }
        if (entrada.startsWith("0")) {
            return false;
        }
        for (int indice = 0; indice < comprimento; indice++) {
            char caractere = entrada.charAt(indice);
            if (caractere < '0' || caractere > '9') {
                return false;
            }
        }
        return true;
    }
}

Implementação com Expressões Regulares

Utilizando o método matches com uma expressão regular concisa:

public class ValidadorRegex {
    public static void main(String[] args) {
        String idNumerico = "0123456789";
        String padrao = "[1-9]\\d{5,19}";
        boolean ehValido = idNumerico.matches(padrao);
        System.out.println(ehValido);
    }
}

Classes de Caracteres

Classes de caracteres permitem definir conjuntos de caracteres para correspondência.

Exemplos de Classes de Caracteres

Alguns testes práticos para ilustrar:

// [abc]
System.out.println("a".matches("[abc]")); // true
System.out.println("x".matches("[abc]")); // false
System.out.println("ab".matches("[abc][abc]")); // true

// [^abc]
System.out.println("d".matches("[^abc]")); // true
System.out.println("a".matches("[^abc]")); // false

// [a-zA-Z]
System.out.println("B".matches("[a-zA-Z]")); // true
System.out.println("3".matches("[a-zA-Z]")); // false
System.out.println("3".matches("[a-zA-Z0-9]")); // true

// [a-z[m-p]]
System.out.println("n".matches("[a-z[m-p]]")); // true
System.out.println("z".matches("[a-z[m-p]]")); // false

// Interseção com &&
System.out.println("e".matches("[a-z&&[def]]")); // true
System.out.println("a".matches("[a-z&&[def]]")); // false
System.out.println("&".matches("[a-z&&[def]]")); // false

// Interseção negativa
System.out.println("a".matches("[a-z&&[^bc]]")); // true
System.out.println("b".matches("[a-z&&[^bc]]")); // false

Caracteres Predefinidos

Caracteres predefinidos oferecem atalhos para conjuntos comuns de caracteres. Note que em Java, a barra invertida deve ser escapada dentro de strings.

Exemplos de Caracteres Predefinidos

// Ponto (.) corresponde a qualquer caractere único
System.out.println("X".matches(".")); // true
System.out.println("XY".matches(".")); // false
System.out.println("XY".matches("..")); // true

// \d para dígitos
System.out.println("9".matches("\\d")); // true
System.out.println("a".matches("\\d")); // false
System.out.println("12".matches("\\d")); // false

// \w para caracteres de palavra
System.out.println("_".matches("\\w")); // true
System.out.println("A".matches("\\w")); // true
System.out.println("!".matches("\\w")); // false
System.out.println("ab".matches("\\w")); // false

// \W para não caracteres de palavra
System.out.println("@".matches("\\W")); // true
System.out.println("a".matches("\\W")); // false

Quantificadores

Quantificadores controlam a frequência de ocorrência de um elemento na expressão.

Exemplos de Quantificadores

// \w{6,} exige pelo menos 6 caracteres de palavra
System.out.println("abc123".matches("\\w{6,}")); // true
System.out.println("abc12".matches("\\w{6,}")); // false

// \w{5} exige exatamente 5 caracteres de palavra
System.out.println("hello".matches("\\w{5}")); // true
System.out.println("hi".matches("\\w{5}")); // false