Generated Skill

YAML
---
name: validating-email-addresses
description: Validates email addresses using Java regex patterns or Apache Commons Validator. Use when implementing user registration, form validation, or input sanitization requiring email format verification.
---

Java
import java.util.regex.Pattern;

public class EmailValidator {
    private static final String EMAIL_PATTERN = 
        "^[a-zA-Z0-9_+&*-]+(?:\\.[a-zA-Z0-9_+&*-]+)*@" +
        "(?:[a-zA-Z0-9-]+\\.)+[a-zA-Z]{2,7}$";
    
    private static final Pattern pattern = Pattern.compile(EMAIL_PATTERN);
    
    public static boolean isValid(String email) {
        return email != null && pattern.matcher(email).matches();
    }
}

// Usage
boolean valid = EmailValidator.isValid("user@example.com"); // true

1. Choose validation approach - Regex pattern or Apache Commons Validator
2. Compile pattern once - Store as static final for reuse
3. Validate input - Check null/empty before pattern matching
4. Handle edge cases - International domains, special characters
5. Return boolean result - Simple true/false for validation

Progress checklist:

• Add validation dependency or create regex pattern
• Create validator class with static method
• Handle null/empty inputs
• Write unit tests for valid/invalid cases
• Integrate into form processing

Example 1: Basic validation Input: "john.doe+newsletter@company.co.uk" Output: true

Example 2: Invalid format Input: "invalid.email" Output: false

Example 3: Apache Commons Validator

Java
import org.apache.commons.validator.routines.EmailValidator;

boolean isValid = EmailValidator.getInstance().isValid("test@domain.com");
// Output: true

Example 4: Batch validation

Java
public static List<String> validateEmails(List<String> emails) {
    return emails.stream()
        .filter(EmailValidator::isValid)
        .collect(Collectors.toList());
}
// Input: ["valid@test.com", "invalid", "another@valid.org"]
// Output: ["valid@test.com", "another@valid.org"]

Use Apache Commons Validator for production:

XML
<dependency>
    <groupId>commons-validator</groupId>
    <artifactId>commons-validator</artifactId>
    <version>1.7</version>
</dependency>

Compile patterns once:

Java
private static final Pattern EMAIL_PATTERN = Pattern.compile(regex);

Normalize before validation:

Java
public static boolean isValid(String email) {
    if (email == null) return false;
    email = email.trim().toLowerCase();
    return pattern.matcher(email).matches();
}

Use RFC 5322 compliant pattern for strict validation:

Java
private static final String RFC5322_PATTERN = 
    "^[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-zA-Z0-9!#$%&'*+/=?^_`{|}~-]+)*@" +
    "(?:[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?\\.)+[a-zA-Z0-9](?:[a-zA-Z0-9-]*[a-zA-Z0-9])?$";

Don't use overly restrictive regex:

Java
// BAD: Too restrictive
"^[a-zA-Z0-9]+@[a-zA-Z0-9]+\\.[a-zA-Z]{2,3}$"

Don't forget null checks:

Java
// Always validate input before regex matching
if (email == null) return false;

Don't validate domains too strictly:

Java
// BAD: Hardcoded TLD list
"\\.(com|org|net)$"

Don't use simple regex for international domains:

Java
// Use libraries that support IDN
EmailValidator.getInstance().isValid(email);

Don't confuse validation with security - Email validation ≠ SQL injection protection