Convalida dei pattern

Pulizia dei dati in Java

Dennis Lee

Software Engineer

Perché serve la convalida dei pattern

I dati devono seguire formati specifici per essere accurati
Esempio: le date devono seguire un formato coerente come d-MMM-yy
Problema: formati data incoerenti come "24/02/22"
Soluzione: usa la convalida dei pattern per trovare formati incoerenti

// Abbiamo estratto queste date dal dataset
List<String> dates = Arrays.asList("4-Jan-22", "1-Aug-22", "7-Jul-22", 
                                   "27-Apr-22", "24/02/22");

Tre tipi di convalida dei pattern

Corrispondenza completa
- Usa quando il formato deve essere esatto
- Esempio: validare date nel formato d-MMM-yy
Ricerca di pattern
- Usa quando la posizione non conta
- Esempio: trovare o controllare categorie prodotto nelle descrizioni
- Prodotti con "Dark Chocolate": "85% Dark Chocolate Bar", "Dark Chocolate with Nuts"
Confronto di caratteri
- Usa per screening rapido dei dati
- Esempio: controllare se un campo quantità contiene lettere ("12.5x")

Definire pattern con regex

Fai combaciare il pattern d-MMM-yy (es. "4-Jan-22")
Regex: \\d{1,2}-[A-Za-z]{3}-\\d{2}

\\d{1,2}     // 1-2 cifre per il giorno (es. 4 o 27)
-            // trattino letterale come separatore

[A-Za-z]{3}  // esattamente 3 lettere per il mese, es. Jan; maiusc. o minusc.
-            // trattino letterale come separatore

\\d{2}       // esattamente 2 cifre per l'anno (es. 22)

Corrispondenza completa

import java.util.regex.Pattern;

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


for (String date : dates) {
    // Verifica se date combacia con datePattern
    boolean isValid = datePattern.matcher(date).matches();
    System.out.println(date + " è valida: " + isValid);
}

Corrispondenza completa: output

4-Jan-22 è valida: true
1-Aug-22 è valida: true
7-Jul-22 è valida: true
27-Apr-22 è valida: true
24/02/22 è valida: false

Ricerca di pattern

import java.util.regex.Matcher;

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

for (String date : dates) {
    Matcher matcher = monthPattern.matcher(date);  // monthPattern è in date?

    if (matcher.find()) { // Restituisce true se trova il pattern

        // matcher.group() restituisce il contenuto trovato
        System.out.println("Mese trovato: " + matcher.group());
    } else {
        System.out.println("Nessun mese in: " + date);
    }
}

Ricerca di pattern: output

Mese trovato: Jan
Mese trovato: Aug
Mese trovato: Jul
Mese trovato: Apr
Nessun mese in: 24/02/22

Confronto di caratteri

import com.google.common.base.CharMatcher;

for (String date : dates) {
    boolean isValid =
            // Verifica cifre in date
            CharMatcher.inRange('0', '9').matchesAnyOf(date) &&

             // Verifica lettere (maiusc. e minusc.) in date
            CharMatcher.inRange('a', 'z')
                    .or(CharMatcher.inRange('A', 'Z')).matchesAnyOf(date) &&

            CharMatcher.is('-').matchesAnyOf(date); // Verifica i trattini in date
    System.out.println(date + " ha caratteri validi: " + isValid);
}

Confronto di caratteri: output

4-Jan-22 ha caratteri validi: true
1-Aug-22 ha caratteri validi: true
7-Jul-22 ha caratteri validi: true
27-Apr-22 ha caratteri validi: true
24/02/22 ha caratteri validi: false

Mettere tutto insieme

// Definisci il pattern d-MMM-yy, es. 4-Jan-22
Pattern datePattern = Pattern.compile("\\d{1,2}-[A-Za-z]{3}-\\d{2}");

// Corrispondenza completa (date rispetta datePattern?)
boolean matchesPattern = datePattern.matcher(date).matches();

// Ricerca nel testo (date contiene il mese?)
boolean hasMonth = Pattern.compile("[A-Za-z]{3}").matcher(date).find();

// Confronto di caratteri (date contiene cifre?)
boolean hasDigits = CharMatcher.digit().matchesAnyOf(date);

Passons à la pratique !

Pulizia dei dati in Java