Validador Regex de Data em Java

O que é Regex de Data?

Regex de data é uma expressão regular projetada para corresponder a padrões de data como DD/MM/YYYY, MM-DD-YYYY ou ISO YYYY-MM-DD. Diferentemente de parsers de data integrados, regex pode filtrar entradas mal formatadas antes de um processamento mais profundo.

Regex é frequentemente usado para:

• Validar campos de data enviados por usuários em formulários

• Filtrar logs ou entradas de texto por formato de data

• Aplicar entrada padronizada em APIs ou pipelines de dados

Como Funciona o Regex de Data?

Uma expressão regular (regex) é simplesmente uma sequência de caracteres que forma um padrão de busca. No contexto de datas, esse padrão consiste em metacaracteres, literais e quantificadores que definem o formato que você deseja corresponder. Por exemplo, você pode querer permitir apenas datas onde dia e mês sejam dois dígitos e o ano seja quatro dígitos, separados por barras ou hífens.

Mas regex não se resume apenas à correspondência básica de padrões. É uma ferramenta poderosa que pode lidar com cenários mais complexos, como verificar múltiplas ocorrências de um padrão, agrupar elementos ou adicionar correspondência condicional quando certos critérios forem atendidos. Essa flexibilidade torna regex indispensável para manipulação de texto e extração de dados, especialmente quando você precisa analisar grandes volumes de dados não estruturados para encontrar entradas de data válidas.

Padrões Comuns de Regex para Data

DD/MM/YYYY (com zeros à esquerda)

^(0[1-9]|[12][0-9]|3[01])/(0[1-9]|1[0-2])/\\d{4}$

Aceita:

• 01/01/2023

• 31/12/1999

Rejeita:

• 32/12/2023

• 15/13/2020

Construindo um Regex para Datas MM/DD/YYYY

Para validar datas no formato MM/DD/YYYY, certifique-se de que seu padrão:

• Aceite meses de 01 a 12

• Capture dias de 01 a 31

• Permita apenas anos de quatro dígitos

• Use / ou - como separador (se necessário)

Abordagem passo a passo:

1. Mês: Para corresponder apenas a meses válidos de dois dígitos (01 a 12), use: (0[1-9]|1[0-2])

2. Separador: Adicione [/\-]

3. Dia: Dias de 01 a 31: (0[1-9]|[12][0-9]|3[01])

4. Outro separador: [/\-]

5. Ano: Qualquer ano de quatro dígitos: \d{4}

O padrão completo:

^(0[1-9]|1[0-2])[/\-](0[1-9]|[12][0-9]|3[01])[/\-]\d{4}$

Aceita: 12/25/2020, 01-01-1999. Observação: este regex não verifica datas inválidas como 02/30/2023 - para validação mais estrita, use bibliotecas de data do Java.

MM-DD-YYYY (formato com hífen)

^(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])-\\d{4}$

Formato ISO YYYY-MM-DD

^\\d{4}-(0[1-9]|1[0-2])-(0[1-9]|[12][0-9]|3[01])$

Variações: Sem Zeros à Esquerda e Anos de Dois Dígitos

Para datas sem zeros à esquerda (como 8/5/2023) ou com anos de dois dígitos (como 08/05/23):

• Sem zeros à esquerda: Use [1-9] para dígitos únicos, permitindo tanto 8 quanto 08.

• Anos de dois dígitos: Substitua \d{4} por \d{2}.

^(0?[1-9]|1[0-2])[\/\-\.](0?[1-9]|[12][0-9]|3[01])[\/\-\.](\d{2}|\d{4})$

Exemplo Completo em Java (DD/MM/YYYY)

import java.util.regex.Pattern;
import java.util.regex.Matcher;
public class DateValidator {
public static void main(String[] args) {
String date = "15/08/2023";
String regex = "^(0[1-9]|[12][0-9]|3[01])/(0[1-9]|1[0-2])/\d{4}$";
    Pattern pattern = Pattern.compile(regex);
    Matcher matcher = pattern.matcher(date);

    if (matcher.matches()) {
        System.out.println("Valid date format.");
    } else {
        System.out.println("Invalid date format.");
    }
}

}

Por que Usar Expressões Regulares para Validação de Data?

Se você já tentou analisar datas de entradas de usuários, sabe como as coisas podem ficar complicadas. É aqui que as expressões regulares entram, trazendo ordem aos seus dados.

Capture Erros Antes que Entrem

Regex permite definir precisamente como uma data válida deve parecer, por exemplo, exigindo dois dígitos para o mês ou garantindo que haja um hífen em vez de barra. Isso inclui rejeitar entradas como 13-45-2020, prevenir trocas acidentais entre formatos como MM-DD-YYYY e DD-MM-YYYY, e evitar dias impossíveis como o 32.

Consistência é Fundamental

Ao padronizar a entrada do usuário, regex garante que sua aplicação não precise de um decodificador para interpretar um campo de data. Resultado: menos bugs e processamento posterior mais confiável.

Definindo Expressões Regulares para Validação de Data em Java

A classe Pattern do Java é útil aqui: defina seu regex como string e compile com Pattern.compile().

Para validar datas no formato YYYY-MM-DD:

String regex = "^\d{4}-\d{2}-\d{2}$";
Pattern pattern = Pattern.compile(regex);

Formatos comuns e seus regex:

• MM/DD/YYYY (com ou sem zeros à esquerda):

  ^(0?[1-9]|1[0-2])/(0?[1-9]|[12][0-9]|3[01])/([0-9]{4})$

• YYYY-MM-DD (estrito):

  ^\d{4}-\d{2}-\d{2}$

• DD-MMM-YYYY (como "05-Oct-2023"):

  ^(0?[1-9]|[12][0-9]|3[01])-(Jan|Feb|Mar|Apr|May|Jun|Jul|Aug|Sep|Oct|Nov|Dec)-\d{4}$

• YYYY/MM/DD HH:MM:SS (data com hora):

  ^\d{4}/\d{2}/\d{2} \d{2}:\d{2}:\d{2}$

Passos Gerais para Validar Formatos de Data em Java

• 1. Aceite a data como String. Obtenha sua data em formato de string, seja da entrada do usuário, um arquivo ou outra fonte.

• 2. Divida a data em componentes. Separe a string nas partes de mês, dia e ano usando substring() ou split().

• 3. Defina padrões regex para cada parte. Crie expressões regulares para validar cada segmento: meses de 01 a 12, dias no intervalo aceitável, e anos de quatro dígitos.

• 4. Faça a correspondência de cada componente com seu padrão. Use o método .matches() em strings Java.

• 5. Retorne o resultado com base nas correspondências. Só aceite a data como válida se todos os segmentos corresponderem.

Por que a Validação de Formato de Data é Importante

Garantir que os usuários insiram datas no formato correto não é apenas sobre organizar dados: é sobre prevenir confusão, bugs e dores de cabeça futuras. Imagine um usuário tentando inserir 12/31/2024 quando seu sistema espera 31-12-2024. Formatos de data consistentes ajudam sua aplicação a armazenar, processar e exibir datas de forma confiável, minimizando erros ao gerar relatórios, trabalhar com fusos horários ou sincronizar com serviços externos.

Como um Programa Java Valida o Formato "MM/dd/yyyy"

O programa pega a string de data e a divide:

• O mês vem dos dois primeiros caracteres (substring(0,2)).

• O dia vem do próximo par (substring(3,5)).

• O ano vem dos últimos quatro caracteres (substring(6,10)).

Cada parte é verificada com regex:

• Mês (MM): De 01 a 12. Padrão: 0[1-9] cobre 01 a 09, 1[0-2] cobre 10, 11 e 12.

• Dia (dd): De 01 a 31. Padrão: 0[1-9], [12][0-9] e 3[01].

• Ano (yyyy): Verifica anos começando com 19 ou 20.

if(month.matches("0[1-9]|1[0-2]")
&& day.matches("0[1-9]|[12][0-9]|3[01]")
&& year.matches("(19|20)\d\d")) {
// Date format matched!
}

Validando Datas com as Classes Pattern e Matcher do Java

Veja como validar uma string de data no formato YYYY-MM-DD:

1. Construa seu Pattern

Pattern pattern = Pattern.compile("^\d{4}-\d{2}-\d{2}$");

2. Faça a correspondência da string de data

String dateStr = "2023-05-02";
Matcher matcher = pattern.matcher(dateStr);
if (matcher.matches()) {
// Date format is valid!
} else {
// Nope, not a match.
}

Dica: isso verifica apenas o formato, não se a data é real (por exemplo, "2023-99-99" passaria). Adicione validação extra se necessário.

Considerando Anos Bissextos

Anos bissextos podem causar erros se sua lógica de validação os ignorar. Aceitar datas inválidas como 29 de fevereiro em anos não bissextos ou rejeitar datas válidas em anos bissextos são problemas reais. Para lidar com anos bissextos, seu regex precisa verificar:

• Se o ano é divisível por 4, mas

• Não divisível por 100, a menos que

• Também seja divisível por 400

Exemplos de Entrada

Válidas:

• 01/01/2022

• 12-31-2020

• 1990-07-15

Inválidas:

• 32/01/2023

• 13-15-2022

• 2021-02-30

Melhores Práticas para Validar Formatos de Data em Java

• Divida a data em componentes: Em vez de abordar toda a string de uma vez, separe em partes de mês, dia e ano.

• Use intervalos explícitos: Para meses: 0[1-9]|1[0-2]. Para dias: 0[1-9]|[12][0-9]|3[01].

• Ancore seus padrões: Não esqueça ^ e $ no início e no fim do regex.

• Teste com valores limite: Alimente seu regex com exemplos válidos e inválidos, como "02-29-2024" ou "13-01-2019".

Exemplo conciso para MM-DD-YYYY:

^((0[1-9])|(1[0-2]))-((0[1-9])|([12][0-9])|(3[01]))-((19|20)\d\d)$

Lembre-se: para precisão total, considere usar LocalDate do Java após a validação de formato. Essa abordagem de duas etapas cobre estrutura e validade real.

Tratando Exceções ao Validar Datas em Java

• Proteja contra erros de padrão: Se o padrão regex tiver um erro de sintaxe, Java lançará PatternSyntaxException.

• Correspondência segura: Chamar .matcher() e .matches() com uma string de data normal não lança exceção - retorna false se a entrada não corresponder.

String dateString = "2023-05-02T12:34:56";
try {
Matcher matcher = pattern.matcher(dateString);
if (matcher.matches()) {
System.out.println("Date is valid");
} else {
System.out.println("Date is invalid");
}
} catch (PatternSyntaxException e) {
System.out.println("Regex pattern error: " + e.getMessage());
}

Regex para Formatos de Data-Hora com UTC e Fuso Horário

Para strings de data-hora no formato "YYYY-MM-DDTHH:MM:SSZ" (UTC):

^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}Z$

Para suportar deslocamentos de fuso horário personalizados (como "+12:00"):

^\d{4}-\d{2}-\d{2}T\d{2}:\d{2}:\d{2}([+-]\d{2}:\d{2})$

Exemplos reais: UTC ISO 8601: 2024-05-24T14:30:00Z, Fuso de Fiji: 2024-05-24T14:30:00+12:00.

Metacaracteres Utilizados

• ^ : Ancora o regex ao início da string

• $ : Ancora o regex ao fim da string

• \d : Corresponde a um dígito (0-9)

• {n} : Corresponde exatamente a n ocorrências

• | : Atua como operador OR

• ( ) : Grupo capturador

• [ ] : Corresponde a qualquer caractere dentro dos colchetes

• - : Caractere hífen literal (usado no formato MM-DD-YYYY)

Dicas Profissionais

• Sempre remova espaços das entradas antes de aplicar regex para evitar que espaços acidentais quebrem a correspondência.

• Regex não valida anos bissextos ou contagens de dias por mês - use LocalDate.parse() para validação profunda após o regex.

• Use regex como primeira linha de defesa, não como validador final. Encadeie com as classes de data do Java para segurança total.

• Para suportar múltiplos formatos, use padrões regex combinados ou valide um de cada vez.

Armadilhas Comuns a Observar

• Zeros à esquerda: Certifique-se de que seu padrão espera tanto 01 quanto 1, dependendo do caso de uso.

• Datas impossíveis: Regex não impede "30 de fevereiro" de passar. Ele verifica apenas o padrão, não a realidade do calendário.

• Intervalos numéricos: Padrões básicos podem permitir meses como 00 ou dias como 39. Verifique seus intervalos.

Casos de Uso

• Validação de Formulários: Garanta que datas de nascimento, reservas ou prazos estejam no formato correto.

• Filtragem de Logs: Extraia e processe entradas de log com datas específicas.

• Design de API: Aplique padrões de data em payloads de requisição e resposta.

• Entrada de Banco de Dados: Verifique e sanitize strings de data antes de salvar.

Combine com Estas Ferramentas

• Java Regex Tester: Teste padrões de data personalizados ou complexos diretamente.

• Validador Regex de UUID em Java: Combine IDs de usuário com timestamps.

• Codificador Base64: Codifique dados com timestamps para transmissão.

• Gerador de Token: Combine strings de data validadas com tokens seguros.

• Validador Regex de Email em Java: Valide datas junto com campos de email em formulários.