Validador Regex de Email em Java

O que é Regex de Email em Java?

Em Java, padrões regex de email são usados para verificar se a entrada do usuário segue um formato de email válido. Isso inclui a presença de uma parte local, um símbolo @, e um domínio com um TLD válido.

A validação típica de email verifica:

• Caracteres alfanuméricos

• Pontos, hífens e underscores nos nomes de usuário

• Um domínio válido com pelo menos um . e 2 ou mais caracteres na extensão

Endereços de Email Válidos x Inválidos

Válidos:

• username@domain.com

• user.name@domain.com

• user-name@domain.com

• username@domain.co.in

• user+tag@gmail.com

Inválidos:

• username.@domain.com (ponto no final)

• .user.name@domain.com (ponto no início)

• user..name@domain.com (pontos consecutivos)

• username@.com (sem nome de domínio)

Tabela de Comparação de Padrões Regex de Email

Escolha o padrão certo para o seu caso de uso:

Exemplos de Código Java Prontos para Produção

Exemplo 1: Validação Padrão de Email

Teste em: Testador de Regex Java

import java.util.regex.*;
public class EmailValidator {
private static final Pattern EMAIL_PATTERN = Pattern.compile(
"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,}$"
);
public static boolean isValid(String email) {
    return EMAIL_PATTERN.matcher(email).matches();
}

public static void main(String[] args) {
    System.out.println(isValid("user@example.com"));    // true
    System.out.println(isValid("user@.com"));           // false
    System.out.println(isValid("john.doe@company.co.in")); // true
}

}

Exemplo 2: Validação Rigorosa (Sem Pontos Consecutivos, Limites de Comprimento)

import java.util.regex.*;
public class StrictEmailValidator {
private static final Pattern STRICT_PATTERN = Pattern.compile(
"^(?=.{1,64}@)[A-Za-z0-9_-]+(\.[A-Za-z0-9_-]+)" +
"@[^-][A-Za-z0-9-]+(\.[A-Za-z0-9-]+)(\.[A-Za-z]{2,})$"
);
public static void main(String[] args) {
    String[] emails = {
        "user.name@domain.com",      // true
        "user..name@domain.com",     // false (pontos consecutivos)
        ".user@domain.com",          // false (ponto no início)
        "username.@domain.com"       // false (ponto no final)
    };
    for (String email : emails) {
        System.out.println(email + ": " + STRICT_PATTERN.matcher(email).matches());
    }
}

}

Exemplo 3: Correspondência sem Distinção de Maiúsculas

import java.util.regex.*;
public class CaseInsensitiveEmail {
public static void main(String[] args) {
Pattern pattern = Pattern.compile(
"^[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}$",
Pattern.CASE_INSENSITIVE
);
Matcher matcher = pattern.matcher("John.Doe@Example.COM");
System.out.println("Email Valid: " + matcher.matches()); // true
}
}

Exemplo 4: Endereços de Email Unicode / Internacionais

Para validar emails com caracteres não latinos (chinês, cirílico, árabe), substitua [A-Za-z] por \p{L}:

import java.util.regex.*;
public class UnicodeEmailValidator {
private static final Pattern UNICODE_PATTERN = Pattern.compile(
"^(?=.{1,64}@)[\p{L}0-9.%+-]+(\.[\p{L}0-9.%+-]+)" +
"@[^-][\p{L}0-9-]+(\.[\p{L}0-9-]+)(\.[\p{L}]{2,})$"
);
}

Como Funciona

1. Cole seu padrão regex e o email de teste no validador.

2. Usa Pattern.compile() e Matcher.matches() do Java internamente.

3. Veja instantaneamente se seu regex corresponde corretamente ao endereço de email fornecido.

Anatomia de um Endereço de Email

Todo endereço de email tem três partes:

• Parte local: O nome de usuário antes do @ (ex.: emma)

• Símbolo @: O separador

• Parte do domínio: O provedor após o @ (ex.: qodex.ai)

Regras de validação a considerar:

• Caracteres permitidos: Letras, números, . _ - + % na parte local

• Restrições de pontos: Sem pontos no início, final ou consecutivos em nenhuma das partes

• Limites de comprimento: Parte local máx. 64 caracteres, domínio máx. 255 caracteres

• Formato do TLD: 2 a 6 caracteres alfabéticos (ex.: .com, .museum)

• Endereçamento com mais: Aliases no estilo Gmail como user+tag@gmail.com devem ser permitidos

Metacaracteres Usados no Regex de Email

• . : Corresponde a qualquer caractere exceto nova linha

• ^ : Ancora no início da string

• $ : Ancora no final da string

• [] : Classe de caracteres

• + : Uma ou mais repetições

• * : Zero ou mais repetições

• {n,} : Pelo menos n repetições

• () : Agrupa partes do regex

• \ : Escapa caracteres especiais

Limitações do Regex de Email RFC 5322

Embora os padrões regex compatíveis com RFC 5322 busquem seguir os padrões oficiais de email, podem apresentar problemas:

• Excessivamente permissivos: Podem permitir caracteres inseguros para seus sistemas

• Riscos de segurança: Alguns padrões excluem intencionalmente o pipe (|) e aspas simples (') para prevenir injeção SQL

• Complexidade: Padrões compatíveis com RFC podem ter centenas de caracteres, sendo difíceis de manter

Para a maioria das aplicações, o padrão Rigoroso ou OWASP da tabela acima é o melhor equilíbrio entre segurança e cobertura.

Por que Usar o Apache Commons Validator?

Para aplicações Java em produção, considere o Apache Commons Validator como alternativa ao regex personalizado:

• Compatível com padrões: Segue as regras RFC 822, trata casos extremos automaticamente

• Suporte a Unicode: Trata endereços de email internacionais nativamente

• Mantido ativamente: Atualizado pela comunidade open-source

• Código mais simples: Uma chamada de método em vez de padrões regex complexos

// Adicione a dependência: commons-validator
import org.apache.commons.validator.routines.EmailValidator;
EmailValidator validator = EmailValidator.getInstance();
boolean isValid = validator.isValid("user@example.com"); // true

Dicas Rápidas

1. Escape corretamente em Java: Use barras duplas em strings regex: \. e não .

2. Adicione insensibilidade a maiúsculas: Use Pattern.compile(regex, Pattern.CASE_INSENSITIVE)

3. Permita endereçamento com mais: Inclua + na classe de caracteres da parte local: [a-zA-Z0-9._%+-]

4. Valide além do regex: O regex verifica apenas o formato. Sempre combine com verificação real de email ou verificações DNS de domínio.

5. Compile uma vez, reutilize: Use Pattern.compile() como campo estático para evitar recompilação a cada chamada.

Casos de Uso Comuns

• Formulários de Login/Cadastro: Valide entrada de email no frontend e backend

• Limpeza de Dados: Filtre registros de email inválidos de conjuntos de dados

• Validação de API: Verifique formatos de email antes de processar requisições POST

• Sistemas CRM: Aplique o formato de email correto em registros de contato

Combine com Essas Ferramentas

• Testador de Regex Java: Teste e depure padrões regex personalizados em Java instantaneamente.

• Validador Regex de Senha em Java: Valide políticas de senha forte em Java.

• Validador Regex de UUID em Java: Verifique conformidade de formato UUID em aplicações Java.

• Validador de Número de Telefone em Java: Valide números de telefone internacionais em Java.

• Validador de URL em Java: Garanta que URLs correspondam ao formato esperado em apps baseados em Java.