Email Validation in Java

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

Step-by-step Email Validation Process

1. Choose validation approach - Regex pattern or Apache Commons Validator
2. Compile pattern (for regex) - Do this once, reuse many times
3. Validate input - Check for null/empty before pattern matching
4. Handle edge cases - International domains, plus signs, dots
5. Return boolean result - Simple true/false for most use cases

Progress checklist for implementation:

• 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 Regex Validation Input: "john.doe+newsletter@company.co.uk" Output: true

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

Example 3: Using Apache Commons Validator

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

// Input: "test@domain.com"
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 regex 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();
}

Consider RFC 5322 compliance 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 complex regex - Can cause performance issues and false negatives

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

Don't forget null checks - Always validate input before regex matching

Don't validate domains too strictly - New TLDs appear regularly

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

Avoid regex for international domains - Use libraries that support IDN:

Java
// Use this for international domains
EmailValidator.getInstance().isValid(email);

Don't use email regex for security - Validation ≠ sanitization for SQL injection