Validação por padrão

Limpeza de Dados em Java

Dennis Lee

Software Engineer

Por que precisamos de validação por padrão

Os dados precisam seguir formatos específicos para serem corretos
Ex.: datas devem seguir um padrão consistente como d-MMM-yy
Problema: formatos de data inconsistentes, como "24/02/22"
Solução: use validação por padrão para achar formatos inconsistentes

// Extraímos estas datas do dataset
List<String> dates = Arrays.asList("4-Jan-22", "1-Aug-22", "7-Jul-22", 
                                   "27-Apr-22", "24/02/22");

Três tipos de validação por padrão

Correspondência total
- Use quando o formato deve ser exato
- Ex.: validar datas no formato d-MMM-yy
Busca por padrão
- Use quando a posição exata não importa
- Ex.: achar ou checar categorias em descrições
- Produtos com "Dark Chocolate": "85% Dark Chocolate Bar", "Dark Chocolate with Nuts"
Correspondência de caracteres
- Use para triagem rápida de dados
- Ex.: checar se um campo de quantidade tem letras ("12.5x")

Definindo padrões com regex

Casar o padrão d-MMM-yy (como "4-Jan-22")
Regex: \\d{1,2}-[A-Za-z]{3}-\\d{2}

\\d{1,2}     // 1–2 dígitos para o dia (ex.: 4 ou 27)
-            // hífen literal

[A-Za-z]{3}  // exatamente 3 letras para o mês, como Jan; maiúsculas ou minúsculas
-            // hífen literal

\\d{2}       // exatamente 2 dígitos para o ano (ex.: 22)

Correspondência total

import java.util.regex.Pattern;

// Casar d-MMM-yy
Pattern datePattern = Pattern.compile("\\d{1,2}-[A-Za-z]{3}-\\d{2}");


for (String date : dates) {
    // Checa se date casa com datePattern
    boolean isValid = datePattern.matcher(date).matches();
    System.out.println(date + " é válida: " + isValid);
}

Correspondência total: saídas

4-Jan-22 é válida: true
1-Aug-22 é válida: true
7-Jul-22 é válida: true
27-Apr-22 é válida: true
24/02/22 é válida: false

Busca por padrão

import java.util.regex.Matcher;

Pattern monthPattern = Pattern.compile("[A-Za-z]{3}"); // 3 letras, tipo "Jan"

for (String date : dates) {
    Matcher matcher = monthPattern.matcher(date);  // monthPattern está em date?

    if (matcher.find()) { // Retorna true se encontrar o padrão

        // matcher.group() retorna o conteúdo casado
        System.out.println("Mês encontrado: " + matcher.group());
    } else {
        System.out.println("Nenhum mês em: " + date);
    }
}

Busca por padrão: saídas

Mês encontrado: Jan
Mês encontrado: Aug
Mês encontrado: Jul
Mês encontrado: Apr
Nenhum mês em: 24/02/22

Correspondência de caracteres

import com.google.common.base.CharMatcher;

for (String date : dates) {
    boolean isValid =
            // Verifica dígitos em date
            CharMatcher.inRange('0', '9').matchesAnyOf(date) &&

             // Verifica letras (maiúsculas e minúsculas) em date
            CharMatcher.inRange('a', 'z')
                    .or(CharMatcher.inRange('A', 'Z')).matchesAnyOf(date) &&

            CharMatcher.is('-').matchesAnyOf(date); // Verifica hífens em date
    System.out.println(date + " tem caracteres válidos: " + isValid);
}

Correspondência de caracteres: saídas

4-Jan-22 tem caracteres válidos: true
1-Aug-22 tem caracteres válidos: true
7-Jul-22 tem caracteres válidos: true
27-Apr-22 tem caracteres válidos: true
24/02/22 tem caracteres válidos: false

Juntando tudo

// Define o padrão d-MMM-yy, como 4-Jan-22
Pattern datePattern = Pattern.compile("\\d{1,2}-[A-Za-z]{3}-\\d{2}");

// Correspondência total (date casa com datePattern?)
boolean matchesPattern = datePattern.matcher(date).matches();

// Busca por padrão (date tem substring de mês?)
boolean hasMonth = Pattern.compile("[A-Za-z]{3}").matcher(date).find();

// Correspondência de caracteres (date tem dígitos?)
boolean hasDigits = CharMatcher.digit().matchesAnyOf(date);

Vamos praticar!

Limpeza de Dados em Java