Slight Insight

Introduction

Regular Expressions (Regex) are a powerful tool in Java for pattern matching and string manipulation. This tutorial is designed to guide you through the basics of Java Regex with simple explanations and practical examples.

What is Regex?

A Regular Expression (regex) is a sequence of characters that forms a search pattern. This pattern can be used to search, edit, or manipulate text. In Java, the java.util.regex package provides the classes required for regex operations.

Key Components of Java Regex

1. Pattern: Defines the regex pattern.
2. Matcher: Applies the pattern to a string and checks for matches.
3. PatternSyntaxException: Thrown if the syntax of the regex pattern is invalid.

Why Learn Regex?

Before diving into the syntax, let’s understand when you might use regex in real life:

Basic Syntax

Here are some commonly used symbols in regex:

How to Use Regex in Java

Here’s the basic structure for working with regex in Java:

import java.util.regex.*;

public class RegexExample {
    public static void main(String[] args) {
        // Define the regex pattern
        String pattern = "\\d+"; // Matches one or more digits
        String text = "The order number is 12345.";

        // Create a Pattern object
        Pattern compiledPattern = Pattern.compile(pattern);

        // Create a Matcher object
        Matcher matcher = compiledPattern.matcher(text);

        // Find matches
        while (matcher.find()) {
            System.out.println("Found: " + matcher.group());
        }
    }
}

Output:

Found: 12345

Using Named Groups

To store a matching word in a variable, you can use the group() method of the Matcher class:

import java.util.regex.*;

public class StoreMatchExample {
    public static void main(String[] args) {
        String text = "Your code is ABC123.";
        String pattern = "(?<code>[A-Z]{3}\\d{3})"; // Matches three letters followed by three digits and stores it in a named group 'code'

        Pattern compiledPattern = Pattern.compile(pattern);
        Matcher matcher = compiledPattern.matcher(text);

        if (matcher.find()) {
            String matchedWord = matcher.group("code"); // Store the match in a variable using the named group
            System.out.println("Matched Word: " + matchedWord);
        } else {
            System.out.println("No match found.");
        }
    }
}

Output:

Matched Word: ABC123

Common Patterns

String emailPattern = "^[A-Za-z0-9+_.-]+@(.+)$";
String email = "user@example.com";
boolean isValid = email.matches(emailPattern);

String phonePattern = "^\\(?(\\d{3})\\)?[-.\\s]?(\\d{3})[-.\\s]?(\\d{4})$"; 

String phone = "(123) 456-7890"; 
boolean isValid = phone.matches(phonePattern);

String text = "Account number: 123456";
String replaced = text.replaceAll("\\d", "#");
System.out.println(replaced);

String sensitiveData = "Credit Card: 1234-5678-9012-3456";

String maskedData = sensitiveData.replaceAll("\\d{4}-(\\d{4})-(\\d{4})-(\\d{4})", "****-****-****-$4");

System.out.println("Masked Data: " + maskedData);

Special Characters and Their Meanings

Quantifiers

Character Classes

Boundary Matchers

Real-World Examples

Password Validation

public class PasswordValidator {
    public static boolean isValidPassword(String password) {
        // Regex for password that requires:
        // - At least 8 characters
        // - At least one uppercase letter
        // - At least one lowercase letter
        // - At least one number
        // - At least one special character
        String pattern = "^(?=.*[0-9])(?=.*[a-z])(?=.*[A-Z])(?=.*[@#$%^&+=])(?=\\S+$).{8,}$";
        return password.matches(pattern);
    }

    public static void main(String[] args) {
        String password = "Test@123";
        System.out.println("Is password valid? " + isValidPassword(password));
    }
}

Log File Parser

public class LogParser {
    public static void parseLogLine(String logLine) {
        // Pattern to match log format: [DATE] [LEVEL] Message
        String pattern = "\\[(\\d{4}-\\d{2}-\\d{2})\\]\\s*\\[(INFO|ERROR|WARN)\\]\\s*(.*)";

        Pattern p = Pattern.compile(pattern);
        Matcher m = p.matcher(logLine);

        if (m.find()) {
            String date = m.group(1);
            String level = m.group(2);
            String message = m.group(3);

            System.out.println("Date: " + date);
            System.out.println("Level: " + level);
            System.out.println("Message: " + message);
        }
    }

    public static void main(String[] args) {
        String log = "[2024-01-18] [ERROR] Database connection failed";
        parseLogLine(log);
    }
}

Data Masking Examples (Credit Card Masking)

public class DataMasker {
    public static String maskCreditCard(String creditCard) {
        // Keep first 6 and last 4 digits, mask the rest
        String pattern = "(\\d{6})\\d+(\\d{4})";
        return creditCard.replaceAll(pattern, "$1********$2");
    }

    public static String maskEmail(String email) {
        // Show first 2 chars and domain, mask the rest
        String pattern = "([^@]{2})[^@]*(@.+)";
        return email.replaceAll(pattern, "$1***$2");
    }

    public static String maskPhoneNumber(String phone) {
        // Keep last 4 digits, mask the rest
        String pattern = "\\d(?=\\d{4})";
        return phone.replaceAll(pattern, "*");
    }

    public static void main(String[] args) {
        // Credit Card masking
        String creditCard = "4532015112830366";
        System.out.println("Masked CC: " + maskCreditCard(creditCard));
        // Output: 453201********0366

        // Email masking
        String email = "john.doe@example.com";
        System.out.println("Masked Email: " + maskEmail(email));
        // Output: jo***@example.com

        // Phone number masking
        String phone = "1234567890";
        System.out.println("Masked Phone: " + maskPhoneNumber(phone));
        // Output: ******7890
    }
}

Log Data Masking

public class LogMasker {
    public static String maskSensitiveData(String logMessage) {
        // Mask various sensitive data patterns
        String maskedMessage = logMessage
            // Mask SSN
            .replaceAll("\\d{3}-\\d{2}-\\d{4}", "XXX-XX-XXXX")
            // Mask Credit Cards (various formats)
            .replaceAll("\\b(?:\\d[ -]*?){13,16}\\b", "XXXX-XXXX-XXXX-XXXX")
            // Mask API Keys (example format)
            .replaceAll("api_key\\s*[:=]\\s*['\"](\\w+)['\"]", "api_key=\'***MASKED***\'")
            // Mask Passwords
            .replaceAll("password\\s*[:=]\\s*['\"](\\w+)['\"]", "password=\'***MASKED***\'");

        return maskedMessage;
    }

    public static void main(String[] args) {
        String log = "User data: SSN=123-45-6789, CC=4532015112830366, " +
                    "api_key='abc123xyz', password='secretpass123'";

        System.out.println("Original log: " + log);
        System.out.println("Masked log: " + maskSensitiveData(log));
        // Output: User data: SSN=XXX-XX-XXXX, CC=XXXX-XXXX-XXXX-XXXX, 
        // api_key='***MASKED***', password='***MASKED***'
    }
}

Conclusion

Regular expressions are incredibly powerful once you understand them. Start with simple patterns and gradually build up to more complex ones. Remember to:

• Test thoroughly
• Comment your regex patterns
• Break complex patterns into smaller, manageable pieces
• Use built-in pattern flags when needed (case insensitive, multiline, etc.)
• Be cautious with sensitive data and always verify your masking patterns

Practice is key to mastering regex. Start with simple patterns and gradually work your way up to more complex ones as you become comfortable with the syntax and concepts.

Frequently Asked Questions