【Java入門】正規表現チェックの実装方法と7つのベストプラクティス 〜現場で使える実践ガイド〜

// メールアドレスの形式をチェックする例
String email = "user@example.com";
boolean isValid = email.matches("[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}");

// 郵便番号の形式をチェックする例（123-4567の形式）
String zipCode = "123-4567";
boolean isValidZip = zipCode.matches("\\d{3}-\\d{4}");

// Patternクラスの基本的な使用例
Pattern pattern = Pattern.compile("\\d{3}-\\d{4}"); // 郵便番号パターン
// パターンは再利用可能
Matcher matcher1 = pattern.matcher("123-4567");
Matcher matcher2 = pattern.matcher("234-5678");

// Matcherクラスの基本的な使用方法
Pattern pattern = Pattern.compile("(\\d{3})-(\\d{4})");
Matcher matcher = pattern.matcher("123-4567");

if (matcher.matches()) {
    String area = matcher.group(1);    // "123"
    String local = matcher.group(2);   // "4567"
    System.out.println("Area code: " + area);
    System.out.println("Local code: " + local);
}

// matches()とfind()の違いを示す例
Pattern pattern = Pattern.compile("\\d+");
String text = "ABC123DEF";

Matcher matcher = pattern.matcher(text);
System.out.println(matcher.matches());  // false（文字列全体が数字ではない）
System.out.println(matcher.find());     // true（文字列内に数字部分が存在する）

// 実践的な使用例
Pattern pattern2 = Pattern.compile("\\d+");
String text2 = "ID:12345 Name:John Age:30";
Matcher matcher2 = pattern2.matcher(text2);

while (matcher2.find()) {
    System.out.println("Found number: " + matcher2.group());
}

　● 部分一致での検索が必要な場合

import java.util.regex.Pattern;
import java.util.regex.Matcher;

public class PatternCompileExample {
    // パターンをクラス定数として定義（再利用性が高い）
    private static final Pattern EMAIL_PATTERN = 
        Pattern.compile("^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$");

    public boolean validateEmail(String email) {
        if (email == null) {
            return false;
        }
        // コンパイル済みパターンを使用してマッチング
        return EMAIL_PATTERN.matcher(email).matches();
    }

    // 複数の入力を検証する例
    public void validateMultipleEmails(List<String> emails) {
        for (String email : emails) {
            // 同じパターンを再利用して効率的に検証
            Matcher matcher = EMAIL_PATTERN.matcher(email);
            System.out.println(email + ": " + matcher.matches());
        }
    }
}

public class StringMatchesExample {
    public boolean quickEmailCheck(String email) {
        // 単純な検証の場合は直接matches()を使用
        return email != null && email.matches(
            "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$"
        );
    }

    // 実践的な使用例
    public void validateUserInput() {
        String phoneNumber = "090-1234-5678";
        String zipCode = "123-4567";

        // 電話番号の検証
        boolean isValidPhone = phoneNumber.matches("\\d{2,4}-\\d{2,4}-\\d{4}");

        // 郵便番号の検証
        boolean isValidZip = zipCode.matches("\\d{3}-\\d{4}");

        System.out.println("Phone: " + isValidPhone);
        System.out.println("Zip: " + isValidZip);
    }
}

public class AdvancedMatcherExample {
    private static final Pattern LOG_PATTERN = 
        Pattern.compile("(\\d{4}-\\d{2}-\\d{2}) (\\d{2}:\\d{2}:\\d{2}) \\[(.+?)\\] (.+)");

    public void analyzeLogEntry(String logLine) {
        Matcher matcher = LOG_PATTERN.matcher(logLine);

        if (matcher.find()) {
            // グループを使用して情報を抽出
            String date = matcher.group(1);
            String time = matcher.group(2);
            String level = matcher.group(3);
            String message = matcher.group(4);

            System.out.printf("Date: %s, Time: %s, Level: %s, Message: %s%n",
                            date, time, level, message);
        }
    }

    // 置換機能を使用する例
    public String maskSensitiveData(String text) {
        // クレジットカード番号をマスク
        Pattern cardPattern = Pattern.compile("\\d{4}-\\d{4}-\\d{4}-\\d{4}");
        Matcher cardMatcher = cardPattern.matcher(text);
        String masked = cardMatcher.replaceAll("XXXX-XXXX-XXXX-$4");

        // メールアドレスを部分的にマスク
        Pattern emailPattern = Pattern.compile("([^@\\s]+)@([^\\s]+)");
        Matcher emailMatcher = emailPattern.matcher(masked);
        return emailMatcher.replaceAll("$1@***");
    }

    // 複数のマッチを処理する例
    public void findAllUrls(String text) {
        Pattern urlPattern = Pattern.compile(
            "https?://[-a-zA-Z0-9+&@#/%?=~_|!:,.;]*[-a-zA-Z0-9+&@#/%=~_|]"
        );
        Matcher matcher = urlPattern.matcher(text);

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

public class EmailValidationPatterns {
    // 基本的な実装（シンプルな検証）
    private static final Pattern SIMPLE_EMAIL = 
        Pattern.compile("^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$");

    // より厳密な実装（RFC準拠により近い）
    private static final Pattern STRICT_EMAIL = Pattern.compile(
        "^[a-zA-Z0-9.!#$%&'*+/=?^_`{|}~-]+@[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}" +
        "[a-zA-Z0-9])?(?:\\.[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?)*$"
    );

    public boolean validateEmail(String email, boolean strict) {
        if (email == null) {
            return false;
        }
        // 長さチェック
        if (email.length() > 254) {
            return false;
        }
        return strict ? 
            STRICT_EMAIL.matcher(email).matches() :
            SIMPLE_EMAIL.matcher(email).matches();
    }

    // テストケース
    public void runEmailTests() {
        String[] validEmails = {
            "user@example.com",
            "user.name@example.co.jp",
            "user+label@example.com"
        };

        String[] invalidEmails = {
            "user@",
            "@example.com",
            "user@.com",
            "user@example",
            "user name@example.com"
        };

        // テスト実行
        for (String email : validEmails) {
            assert validateEmail(email, false) : "Valid email failed: " + email;
        }

        for (String email : invalidEmails) {
            assert !validateEmail(email, false) : "Invalid email passed: " + email;
        }
    }
}

public class PhoneNumberValidationPatterns {
    // 日本の電話番号パターン
    private static final Pattern JP_PHONE = Pattern.compile(
        "^(0\\d{1,4})-?(\\d{1,4})-?(\\d{4})$"
    );

    // 国際電話番号パターン（シンプルな実装）
    private static final Pattern INTERNATIONAL_PHONE = Pattern.compile(
        "^\\+(?:[0-9] ?){6,14}[0-9]$"
    );

    public static class PhoneValidationResult {
        public final boolean isValid;
        public final String formattedNumber;

        public PhoneValidationResult(boolean isValid, String formattedNumber) {
            this.isValid = isValid;
            this.formattedNumber = formattedNumber;
        }
    }

    public PhoneValidationResult validateJapanesePhone(String phone) {
        if (phone == null) {
            return new PhoneValidationResult(false, null);
        }

        // ハイフンと空白を除去
        String cleanPhone = phone.replaceAll("[- ]", "");
        Matcher matcher = JP_PHONE.matcher(cleanPhone);

        if (matcher.matches()) {
            // 正規化されたフォーマットに変換
            String formatted = String.format("%s-%s-%s",
                matcher.group(1),
                matcher.group(2),
                matcher.group(3)
            );
            return new PhoneValidationResult(true, formatted);
        }

        return new PhoneValidationResult(false, null);
    }

    // 実装例の使用方法
    public void demonstratePhoneValidation() {
        String[] testPhones = {
            "03-1234-5678",
            "090-1234-5678",
            "0123-12-3456",
            "090-123-45678",  // 不正なフォーマット
            "1234-567-890"    // 不正なフォーマット
        };

        for (String phone : testPhones) {
            PhoneValidationResult result = validateJapanesePhone(phone);
            System.out.printf("Number: %s, Valid: %b, Formatted: %s%n",
                phone, result.isValid, result.formattedNumber);
        }
    }
}

public class DateValidationPatterns {
    // 基本的な日付パターン（YYYY-MM-DD）
    private static final Pattern ISO_DATE = 
        Pattern.compile("^\\d{4}-(?:0[1-9]|1[0-2])-(?:0[1-9]|[12]\\d|3[01])$");

    // 日本形式の日付パターン（YYYY/MM/DD）
    private static final Pattern JP_DATE = 
        Pattern.compile("^\\d{4}/(?:0[1-9]|1[0-2])/(?:0[1-9]|[12]\\d|3[01])$");

    public class DateValidationResult {
        public final boolean isValid;
        public final LocalDate parsedDate;

        public DateValidationResult(boolean isValid, LocalDate parsedDate) {
            this.isValid = isValid;
            this.parsedDate = parsedDate;
        }
    }

    public DateValidationResult validateDate(String dateStr, String pattern) {
        // パターンによってバリデーションを切り替え
        Pattern datePattern = pattern.equals("ISO") ? ISO_DATE : JP_DATE;

        if (!datePattern.matcher(dateStr).matches()) {
            return new DateValidationResult(false, null);
        }

        try {
            // DateTimeFormatterを使用して日付の妥当性を検証
            DateTimeFormatter formatter = DateTimeFormatter.ofPattern(
                pattern.equals("ISO") ? "yyyy-MM-dd" : "yyyy/MM/dd"
            );
            LocalDate date = LocalDate.parse(dateStr, formatter);

            // 現在日付との比較などの追加チェック
            if (date.isAfter(LocalDate.now().plusYears(100))) {
                return new DateValidationResult(false, null);
            }

            return new DateValidationResult(true, date);
        } catch (DateTimeException e) {
            return new DateValidationResult(false, null);
        }
    }

    // 実装例の使用方法
    public void demonstrateDateValidation() {
        String[] testDates = {
            "2024-02-29",  // うるう年
            "2024-04-31",  // 無効な日付
            "2024/12/31",  // 日本形式
            "2024-13-01",  // 無効な月
            "2024-00-01"   // 無効な月
        };

        for (String date : testDates) {
            String pattern = date.contains("-") ? "ISO" : "JP";
            DateValidationResult result = validateDate(date, pattern);
            System.out.printf("Date: %s, Valid: %b, Parsed: %s%n",
                date, result.isValid, 
                result.parsedDate != null ? result.parsedDate : "N/A");
        }
    }
}

public class PatternCache {
    // パターンをキャッシュするためのThreadSafeな実装
    private static final class PatternCacheHolder {
        private static final Map<String, Pattern> PATTERN_CACHE = 
            new ConcurrentHashMap<>();

        private static final int MAX_CACHE_SIZE = 1000;  // キャッシュサイズの制限

        private PatternCacheHolder() {}

        public static Pattern getPattern(String regex, int flags) {
            // キャッシュキーの生成
            String cacheKey = flags == 0 ? regex : regex + "#" + flags;

            // キャッシュからパターンを取得、なければ新規作成
            return PATTERN_CACHE.computeIfAbsent(cacheKey, k -> {
                // キャッシュサイズをチェック
                if (PATTERN_CACHE.size() >= MAX_CACHE_SIZE) {
                    // キャッシュが一杯の場合は古いエントリを削除
                    PATTERN_CACHE.clear();
                }
                return Pattern.compile(regex, flags);
            });
        }
    }

    // キャッシュを使用したパターンマッチング
    public static boolean matches(String input, String regex) {
        Pattern pattern = PatternCacheHolder.getPattern(regex, 0);
        return pattern.matcher(input).matches();
    }

    // パフォーマンス比較デモ
    public void demonstratePerformance() {
        String regex = "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$";
        String testInput = "test@example.com";

        // キャッシュなしの場合
        long startTime = System.nanoTime();
        for (int i = 0; i < 10000; i++) {
            Pattern.compile(regex).matcher(testInput).matches();
        }
        long noCacheTime = System.nanoTime() - startTime;

        // キャッシュありの場合
        startTime = System.nanoTime();
        for (int i = 0; i < 10000; i++) {
            matches(testInput, regex);
        }
        long withCacheTime = System.nanoTime() - startTime;

        System.out.printf("No Cache: %d ns%nWith Cache: %d ns%n" +
                         "Performance improvement: %.2f%%%n",
            noCacheTime, withCacheTime,
            ((noCacheTime - withCacheTime) / (double)noCacheTime) * 100);
    }
}

public class ReDoSPrevention {
    // 脆弱なパターンの例と安全なパターンの比較
    public static class EmailValidator {
        // 脆弱な実装（バックトラッキングの問題あり）
        private static final Pattern VULNERABLE_EMAIL = Pattern.compile(
            "^([a-zA-Z0-9]+.*)+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$"
        );

        // 安全な実装
        private static final Pattern SAFE_EMAIL = Pattern.compile(
            "^[a-zA-Z0-9](?:[a-zA-Z0-9._%+-]{0,61}[a-zA-Z0-9])?@" +
            "[a-zA-Z0-9](?:[a-zA-Z0-9-]{0,61}[a-zA-Z0-9])?(?:\\.[a-zA-Z]{2,})+$"
        );

        // タイムアウト付きの検証実装
        public static boolean validateEmailWithTimeout(
            String email, Pattern pattern, long timeoutMillis) {

            FutureTask<Boolean> task = new FutureTask<>(() ->
                pattern.matcher(email).matches()
            );

            Thread thread = new Thread(task);
            thread.start();

            try {
                return task.get(timeoutMillis, TimeUnit.MILLISECONDS);
            } catch (TimeoutException e) {
                thread.interrupt();
                System.out.println("Pattern matching timed out - possible ReDoS attempt");
                return false;
            } catch (Exception e) {
                return false;
            }
        }

        // 実装の比較デモ
        public void demonstrateReDoS() {
            // 悪意のある入力の例
            String maliciousInput = "a".repeat(100) + "@example.com";

            // 脆弱なパターンと安全なパターンの実行時間を比較
            long startTime = System.currentTimeMillis();
            validateEmailWithTimeout(maliciousInput, VULNERABLE_EMAIL, 1000);
            long vulnerableTime = System.currentTimeMillis() - startTime;

            startTime = System.currentTimeMillis();
            validateEmailWithTimeout(maliciousInput, SAFE_EMAIL, 1000);
            long safeTime = System.currentTimeMillis() - startTime;

            System.out.printf("Vulnerable pattern: %d ms%nSafe pattern: %d ms%n",
                            vulnerableTime, safeTime);
        }
    }

    // ReDoS対策のベストプラクティス
    public static class RegexSafety {
        // 入力の長さを制限
        public static boolean safeMatch(String input, Pattern pattern, int maxLength) {
            if (input == null || input.length() > maxLength) {
                return false;
            }
            return pattern.matcher(input).matches();
        }

        // パターンの複雑さを制限
        public static Pattern createSafePattern(String regex, int maxGroups) {
            // グループの数をカウント
            long groupCount = regex.chars().filter(ch -> ch == '(').count();
            if (groupCount > maxGroups) {
                throw new IllegalArgumentException(
                    "Pattern contains too many groups: " + groupCount);
            }
            return Pattern.compile(regex);
        }
    }
}

public class MemoryOptimization {
    // メモリ効率の良い実装例
    public static class StreamProcessor {
        private static final Pattern WORD_PATTERN = Pattern.compile("\\w+");
        private static final int BUFFER_SIZE = 8192;

        // 大きなテキストを効率的に処理
        public void processLargeText(Reader input) throws IOException {
            BufferedReader reader = new BufferedReader(input);
            char[] buffer = new char[BUFFER_SIZE];
            StringBuilder remainder = new StringBuilder();
            int read;

            while ((read = reader.read(buffer)) != -1) {
                // バッファの内容を処理
                String chunk = remainder.toString() + new String(buffer, 0, read);
                Matcher matcher = WORD_PATTERN.matcher(chunk);

                int lastEnd = 0;
                while (matcher.find()) {
                    // 単語を処理
                    processWord(matcher.group());
                    lastEnd = matcher.end();
                }

                // 未処理の部分を保持
                remainder = new StringBuilder(chunk.substring(lastEnd));
            }
        }

        private void processWord(String word) {
            // 単語の処理ロジック
            System.out.println("Processing: " + word);
        }
    }

    // メモリ使用量のモニタリング
    public static class MemoryMonitor {
        public static void printMemoryUsage(String label) {
            Runtime runtime = Runtime.getRuntime();
            long totalMemory = runtime.totalMemory();
            long freeMemory = runtime.freeMemory();
            long usedMemory = totalMemory - freeMemory;

            System.out.printf("%s - Used Memory: %d MB%n",
                label, usedMemory / (1024 * 1024));
        }
    }

    // メモリ最適化のデモ
    public void demonstrateMemoryOptimization() {
        MemoryMonitor.printMemoryUsage("Before processing");

        try {
            // 大きなテキストファイルを処理
            String largeText = generateLargeText();
            StreamProcessor processor = new StreamProcessor();
            processor.processLargeText(new StringReader(largeText));

        } catch (IOException e) {
            e.printStackTrace();
        }

        MemoryMonitor.printMemoryUsage("After processing");
    }

    private String generateLargeText() {
        // テスト用の大きなテキストを生成
        StringBuilder sb = new StringBuilder();
        for (int i = 0; i < 100000; i++) {
            sb.append("word").append(i).append(" ");
        }
        return sb.toString();
    }
}

public class ValidationFramework {
    // バリデーション結果を表すクラス
    public static class ValidationResult {
        private final boolean valid;
        private final List<String> errors;

        public ValidationResult(boolean valid, List<String> errors) {
            this.valid = valid;
            this.errors = Collections.unmodifiableList(
                new ArrayList<>(errors));
        }

        public boolean isValid() { return valid; }
        public List<String> getErrors() { return errors; }
    }

    // バリデーションルールのインターフェース
    @FunctionalInterface
    public interface ValidationRule<T> {
        ValidationResult validate(T value);
    }

    // 汎用的なバリデータクラス
    public static class Validator<T> {
        private final List<ValidationRule<T>> rules = new ArrayList<>();
        private final Map<String, Pattern> patternCache = new ConcurrentHashMap<>();

        // ルールの追加
        public Validator<T> addRule(ValidationRule<T> rule) {
            rules.add(rule);
            return this;
        }

        // 正規表現パターンの追加
        public Validator<T> addPattern(String name, String regex) {
            patternCache.put(name, Pattern.compile(regex));
            return this;
        }

        // バリデーションの実行
        public ValidationResult validate(T value) {
            List<String> errors = new ArrayList<>();

            for (ValidationRule<T> rule : rules) {
                ValidationResult result = rule.validate(value);
                if (!result.isValid()) {
                    errors.addAll(result.getErrors());
                }
            }

            return new ValidationResult(errors.isEmpty(), errors);
        }

        // パターンによる文字列検証
        protected boolean matchesPattern(String value, String patternName) {
            Pattern pattern = patternCache.get(patternName);
            return pattern != null && pattern.matcher(value).matches();
        }
    }

    // ユーザーデータのバリデーション例
    public static class UserDataValidator extends Validator<UserData> {
        public UserDataValidator() {
            // メールアドレスパターン
            addPattern("email", 
                "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$");

            // 電話番号パターン
            addPattern("phone", "^\\d{2,4}-\\d{2,4}-\\d{4}$");

            // メールアドレスの検証ルール
            addRule(userData -> {
                if (userData.getEmail() == null || 
                    !matchesPattern(userData.getEmail(), "email")) {
                    return new ValidationResult(false, 
                        Collections.singletonList("Invalid email format"));
                }
                return new ValidationResult(true, Collections.emptyList());
            });

            // 電話番号の検証ルール
            addRule(userData -> {
                if (userData.getPhone() != null && 
                    !userData.getPhone().isEmpty() && 
                    !matchesPattern(userData.getPhone(), "phone")) {
                    return new ValidationResult(false, 
                        Collections.singletonList("Invalid phone format"));
                }
                return new ValidationResult(true, Collections.emptyList());
            });
        }
    }

    // 使用例
    public static void demonstrateValidation() {
        UserData userData = new UserData(
            "invalid-email",
            "invalid-phone"
        );

        UserDataValidator validator = new UserDataValidator();
        ValidationResult result = validator.validate(userData);

        if (!result.isValid()) {
            result.getErrors().forEach(System.out::println);
        }
    }
}

// バリデーションアノテーション
public class ValidationAnnotations {
    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.FIELD)
    public @interface Pattern {
        String regexp();
        String message() default "Invalid format";
    }

    @Retention(RetentionPolicy.RUNTIME)
    @Target(ElementType.FIELD)
    public @interface NotNull {
        String message() default "Value cannot be null";
    }

    // バリデーション対象のデータクラス
    public static class UserProfile {
        @NotNull(message = "Email is required")
        @Pattern(regexp = "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$",
                message = "Invalid email format")
        private String email;

        @Pattern(regexp = "^\\d{2,4}-\\d{2,4}-\\d{4}$",
                message = "Invalid phone number format")
        private String phoneNumber;

        // コンストラクタ、ゲッター、セッター
    }

    // バリデーション実行クラス
    public static class AnnotationValidator {
        public ValidationResult validate(Object object) {
            List<String> errors = new ArrayList<>();

            for (Field field : object.getClass().getDeclaredFields()) {
                field.setAccessible(true);

                try {
                    // NotNullバリデーション
                    if (field.isAnnotationPresent(NotNull.class)) {
                        Object value = field.get(object);
                        if (value == null) {
                            NotNull annotation = field.getAnnotation(NotNull.class);
                            errors.add(annotation.message());
                        }
                    }

                    // Patternバリデーション
                    if (field.isAnnotationPresent(Pattern.class)) {
                        Object value = field.get(object);
                        if (value != null) {
                            Pattern annotation = field.getAnnotation(Pattern.class);
                            if (!java.util.regex.Pattern.compile(
                                annotation.regexp())
                                .matcher(value.toString()).matches()) {
                                errors.add(annotation.message());
                            }
                        }
                    }
                } catch (IllegalAccessException e) {
                    errors.add("Validation failed: " + e.getMessage());
                }
            }

            return new ValidationResult(errors.isEmpty(), errors);
        }
    }

    // 使用例
    public static void demonstrateAnnotationValidation() {
        UserProfile profile = new UserProfile();
        profile.setEmail("invalid-email");
        profile.setPhoneNumber("invalid-phone");

        AnnotationValidator validator = new AnnotationValidator();
        ValidationResult result = validator.validate(profile);

        if (!result.isValid()) {
            result.getErrors().forEach(System.out::println);
        }
    }
}

@ExtendWith(MockitoExtension.class)
public class ValidationTests {
    private UserDataValidator validator;

    @BeforeEach
    void setUp() {
        validator = new UserDataValidator();
    }

    @Test
    @DisplayName("有効なメールアドレスの検証")
    void testValidEmail() {
        // 準備
        UserData userData = new UserData("test@example.com", "03-1234-5678");

        // 実行
        ValidationResult result = validator.validate(userData);

        // 検証
        assertTrue(result.isValid(), "Valid email should pass validation");
        assertTrue(result.getErrors().isEmpty(), 
            "No errors should be present for valid email");
    }

    @Test
    @DisplayName("無効なメールアドレスの検証")
    void testInvalidEmail() {
        // 準備
        UserData userData = new UserData("invalid-email", "03-1234-5678");

        // 実行
        ValidationResult result = validator.validate(userData);

        // 検証
        assertFalse(result.isValid(), 
            "Invalid email should fail validation");
        assertTrue(result.getErrors().stream()
            .anyMatch(error -> error.contains("Invalid email")),
            "Should contain email error message");
    }

    @Nested
    @DisplayName("電話番号バリデーションテスト")
    class PhoneValidationTests {
        @Test
        @DisplayName("有効な電話番号フォーマット")
        void testValidPhoneFormats() {
            // 有効な電話番号パターンのテスト
            List<String> validPhones = Arrays.asList(
                "03-1234-5678",
                "090-1234-5678",
                "0123-12-3456"
            );

            for (String phone : validPhones) {
                UserData userData = new UserData(
                    "test@example.com", phone);
                ValidationResult result = validator.validate(userData);
                assertTrue(result.isValid(), 
                    "Phone number " + phone + " should be valid");
            }
        }

        @Test
        @DisplayName("無効な電話番号フォーマット")
        void testInvalidPhoneFormats() {
            // 無効な電話番号パターンのテスト
            List<String> invalidPhones = Arrays.asList(
                "090-123-456",
                "090-1234-567",
                "090-12345-6789"
            );

            for (String phone : invalidPhones) {
                UserData userData = new UserData(
                    "test@example.com", phone);
                ValidationResult result = validator.validate(userData);
                assertFalse(result.isValid(), 
                    "Phone number " + phone + " should be invalid");
            }
        }
    }

    @Test
    @DisplayName("パフォーマンステスト")
    void testValidationPerformance() {
        // 準備
        UserData userData = new UserData(
            "test@example.com", "03-1234-5678");

        // 実行
        long startTime = System.nanoTime();
        for (int i = 0; i < 1000; i++) {
            validator.validate(userData);
        }
        long endTime = System.nanoTime();

        // 検証
        long durationMs = (endTime - startTime) / 1_000_000;
        assertTrue(durationMs < 1000, 
            "Validation should complete within 1 second");
    }
}

public class PatternCompilationTroubleshooting {
    // エラーハンドリングを含むパターンコンパイラ
    public static class SafePatternCompiler {
        public static Pattern compile(String regex) {
            try {
                return Pattern.compile(regex);
            } catch (PatternSyntaxException e) {
                throw new PatternCompilationException(
                    "Invalid regex pattern: " + regex,
                    e.getDescription(),
                    e.getIndex()
                );
            }
        }
    }

    // カスタム例外クラス
    public static class PatternCompilationException extends RuntimeException {
        private final String description;
        private final int errorIndex;

        public PatternCompilationException(
            String message, String description, int errorIndex) {
            super(message);
            this.description = description;
            this.errorIndex = errorIndex;
        }

        public String getDetailedMessage() {
            return String.format(
                "Error at index %d: %s%nDescription: %s",
                errorIndex, getMessage(), description);
        }
    }

    // よくあるエラーパターンと対処例
    public static class CommonErrorPatterns {
        public static void demonstrateCommonErrors() {
            // 1. 未エスケープの特殊文字
            try {
                SafePatternCompiler.compile("hello.world[");
            } catch (PatternCompilationException e) {
                System.out.println("Unclosed character class: " + 
                    e.getDetailedMessage());
            }

            // 2. 無効な量指定子
            try {
                SafePatternCompiler.compile("a{2,1}");
            } catch (PatternCompilationException e) {
                System.out.println("Invalid quantifier: " + 
                    e.getDetailedMessage());
            }

            // 3. 未閉じの括弧
            try {
                SafePatternCompiler.compile("(abc");
            } catch (PatternCompilationException e) {
                System.out.println("Unclosed group: " + 
                    e.getDetailedMessage());
            }
        }
    }
}

public class RuntimeExceptionHandling {
    // 安全なパターンマッチング実装
    public static class SafeMatcher {
        private static final int TIMEOUT_MS = 1000;

        public static boolean safeMatch(
            Pattern pattern, String input, int maxLength) {

            // 入力値の検証
            if (input == null) {
                throw new IllegalArgumentException("Input cannot be null");
            }

            if (input.length() > maxLength) {
                throw new IllegalArgumentException(
                    "Input exceeds maximum length of " + maxLength);
            }

            // タイムアウト付きマッチング
            return executeWithTimeout(() -> 
                pattern.matcher(input).matches(), TIMEOUT_MS);
        }

        // タイムアウト処理の実装
        private static boolean executeWithTimeout(
            Supplier<Boolean> task, long timeoutMs) {

            ExecutorService executor = 
                Executors.newSingleThreadExecutor();
            Future<Boolean> future = executor.submit(task::get);

            try {
                return future.get(timeoutMs, TimeUnit.MILLISECONDS);
            } catch (TimeoutException e) {
                future.cancel(true);
                throw new MatchingTimeoutException(
                    "Pattern matching timed out after " + timeoutMs + "ms");
            } catch (Exception e) {
                throw new MatchingException("Matching failed", e);
            } finally {
                executor.shutdownNow();
            }
        }
    }

    // カスタム例外クラス
    public static class MatchingTimeoutException extends RuntimeException {
        public MatchingTimeoutException(String message) {
            super(message);
        }
    }

    public static class MatchingException extends RuntimeException {
        public MatchingException(String message, Throwable cause) {
            super(message, cause);
        }
    }

    // 実行時エラーのデモ
    public static void demonstrateRuntimeErrors() {
        Pattern pattern = Pattern.compile("(a+)+b");
        String input = "a".repeat(100);

        try {
            SafeMatcher.safeMatch(pattern, input, 50);
        } catch (IllegalArgumentException e) {
            System.out.println("Input validation failed: " + e.getMessage());
        } catch (MatchingTimeoutException e) {
            System.out.println("Matching timed out: " + e.getMessage());
        } catch (MatchingException e) {
            System.out.println("Matching failed: " + e.getMessage());
        }
    }
}

public class RegexDebugger {
    private static final Logger logger = 
        LoggerFactory.getLogger(RegexDebugger.class);

    // デバッグ情報を含むマッチャー
    public static class DebugMatcher {
        private final Pattern pattern;
        private final String input;
        private final boolean debug;

        public DebugMatcher(String regex, String input, boolean debug) {
            this.pattern = Pattern.compile(regex);
            this.input = input;
            this.debug = debug;
        }

        public boolean matches() {
            if (debug) {
                return debugMatches();
            }
            return pattern.matcher(input).matches();
        }

        private boolean debugMatches() {
            Matcher matcher = pattern.matcher(input);
            boolean result = matcher.matches();

            logger.debug("Pattern: {}", pattern.pattern());
            logger.debug("Input: {}", input);
            logger.debug("Match result: {}", result);

            if (result) {
                // グループ情報のログ出力
                for (int i = 0; i <= matcher.groupCount(); i++) {
                    logger.debug("Group {}: {}", i, matcher.group(i));
                }
            }

            return result;
        }

        public List<MatchResult> findAll() {
            List<MatchResult> results = new ArrayList<>();
            Matcher matcher = pattern.matcher(input);

            while (matcher.find()) {
                if (debug) {
                    logger.debug("Found match at index {}-{}: {}",
                        matcher.start(), matcher.end(), 
                        matcher.group());
                }
                results.add(matcher.toMatchResult());
            }

            return results;
        }
    }

    // デバッグ用のユーティリティメソッド
    public static class RegexAnalyzer {
        public static void analyzePattern(String regex) {
            logger.info("Analyzing regex pattern: {}", regex);

            // パターンの構成要素を解析
            Map<String, Integer> components = new HashMap<>();
            components.put("Groups", countGroups(regex));
            components.put("Quantifiers", countQuantifiers(regex));
            components.put("Character Classes", countCharacterClasses(regex));

            components.forEach((key, value) -> 
                logger.info("{}: {}", key, value));
        }

        private static int countGroups(String regex) {
            return (int) regex.chars().filter(ch -> ch == '(').count();
        }

        private static int countQuantifiers(String regex) {
            Pattern quantifierPattern = 
                Pattern.compile("[*+?]|\\{\\d+,?\\d*\\}");
            Matcher matcher = quantifierPattern.matcher(regex);
            int count = 0;
            while (matcher.find()) count++;
            return count;
        }

        private static int countCharacterClasses(String regex) {
            return (int) regex.chars().filter(ch -> ch == '[').count();
        }
    }

    // 使用例
    public static void demonstrateDebugging() {
        String regex = "(\\w+)@(\\w+\\.\\w+)";
        String input = "test@example.com";

        // パターンの解析
        RegexAnalyzer.analyzePattern(regex);

        // デバッグモードでマッチング
        DebugMatcher debugMatcher = 
            new DebugMatcher(regex, input, true);
        boolean matches = debugMatcher.matches();

        logger.info("Final match result: {}", matches);
    }
}

public class RegexBestPractices {
    // パターン定数の命名例
    public static class PatternConstants {
        // 命名規則：[データ種別]_PATTERN
        private static final Pattern EMAIL_PATTERN = Pattern.compile(
            "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$"
        );

        // パターンの説明をJavadocで記述
        /**
         * 電話番号を検証するパターン.
         * 形式: XX-XXXX-XXXX（市外局番-市内局番-加入者番号）
         * 許容範囲:
         * - 市外局番: 2-4桁
         * - 市内局番: 2-4桁
         * - 加入者番号: 4桁
         */
        private static final Pattern PHONE_NUMBER_PATTERN = Pattern.compile(
            "^\\d{2,4}-\\d{2,4}-\\d{4}$"
        );

        // パターンの構成要素を分割して可読性を向上
        private static final class PostalCodePatternComponents {
            static final String PREFIX = "^";
            static final String THREE_DIGITS = "\\d{3}";
            static final String HYPHEN = "-";
            static final String FOUR_DIGITS = "\\d{4}";
            static final String SUFFIX = "$";

            static final Pattern POSTAL_CODE_PATTERN = Pattern.compile(
                PREFIX + THREE_DIGITS + HYPHEN + FOUR_DIGITS + SUFFIX
            );
        }
    }

    // バリデーションメソッドの命名例
    public static class ValidationMethods {
        // 動詞 + 対象 + 検証内容
        public boolean isValidEmail(String email) {
            return PatternConstants.EMAIL_PATTERN.matcher(email).matches();
        }

        // 検証結果を詳細に返す場合
        public ValidationResult validatePhoneNumber(String phoneNumber) {
            if (phoneNumber == null) {
                return ValidationResult.error("Phone number cannot be null");
            }

            boolean matches = PatternConstants.PHONE_NUMBER_PATTERN
                .matcher(phoneNumber).matches();
            return matches ? 
                ValidationResult.success() : 
                ValidationResult.error("Invalid phone number format");
        }
    }
}

public class RegexAntiPatterns {
    // アンチパターン1: パターンの都度コンパイル
    public class BadImplementation {
        // 悪い例
        public boolean validateEmail(String email) {
            return Pattern.compile("^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$")
                .matcher(email)
                .matches();
        }

        // 悪い例: 複雑すぎるパターン
        public static final Pattern COMPLEX_EMAIL = Pattern.compile(
            "^(?:[a-z0-9!#$%&'*+/=?^_`{|}~-]+(?:\\.[a-z0-9!#$%&'*+/=?^_`{|}~-]+)*"
            + "|\"(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f\\x21\\x23-\\x5b\\x5d-\\x7f]"
            + "|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])*\")@(?:(?:[a-z0-9](?:[a-z0-9-]*"
            + "[a-z0-9])?\\.)+[a-z0-9](?:[a-z0-9-]*[a-z0-9])?|\\[(?:(?:(2(5[0-5]|[0-4][0-9])"
            + "|1[0-9][0-9]|[1-9]?[0-9]))\\.){3}(?:(2(5[0-5]|[0-4][0-9])|1[0-9][0-9]"
            + "|[1-9]?[0-9])|[a-z0-9-]*[a-z0-9]:(?:[\\x01-\\x08\\x0b\\x0c\\x0e-\\x1f"
            + "\\x21-\\x5a\\x53-\\x7f]|\\\\[\\x01-\\x09\\x0b\\x0c\\x0e-\\x7f])+)\\])$"
        );
    }

    // 改善例
    public class GoodImplementation {
        // 良い例: パターンを再利用
        private static final Pattern EMAIL_PATTERN = Pattern.compile(
            "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$"
        );

        // 良い例: 適度な妥協と説明付きのパターン
        /**
         * メールアドレスの基本的な形式を検証するパターン.
         * RFC 5322の完全な実装ではなく、一般的なユースケースに
         * 特化した実用的な実装.
         */
        public boolean validateEmail(String email) {
            return email != null && EMAIL_PATTERN.matcher(email).matches();
        }
    }

    // アンチパターン2: エラー処理の欠如
    public class ErrorHandlingAntiPattern {
        // 悪い例: エラー処理なし
        public boolean badValidation(String input, String pattern) {
            return Pattern.compile(pattern).matcher(input).matches();
        }

        // 良い例: 適切なエラー処理
        public ValidationResult goodValidation(String input, String pattern) {
            try {
                if (input == null || pattern == null) {
                    return ValidationResult.error("Input and pattern cannot be null");
                }

                Pattern compiledPattern = Pattern.compile(pattern);
                boolean matches = compiledPattern.matcher(input).matches();

                return matches ?
                    ValidationResult.success() :
                    ValidationResult.error("Pattern matching failed");

            } catch (PatternSyntaxException e) {
                return ValidationResult.error("Invalid pattern syntax: " + e.getMessage());
            } catch (Exception e) {
                return ValidationResult.error("Validation failed: " + e.getMessage());
            }
        }
    }
}

public class RegexCodeReview {
    /**
     * 正規表現実装のレビューチェックリスト
     */
    public static class ReviewChecklist {
        // 1. パターンの妥当性チェック
        public static boolean validatePattern(Pattern pattern) {
            // パターンの基本チェック
            if (pattern == null) {
                return false;
            }

            // パターンの複雑さチェック
            String regex = pattern.pattern();
            int complexity = calculatePatternComplexity(regex);

            return complexity <= 10; // 複雑さの閾値
        }

        // パターンの複雑さを計算
        private static int calculatePatternComplexity(String regex) {
            int complexity = 0;
            complexity += regex.length() / 10;  // 長さによる複雑さ
            complexity += countGroups(regex);   // グループの数
            complexity += countQuantifiers(regex); // 量指定子の数
            return complexity;
        }

        // 2. パフォーマンスチェック
        public static PerformanceResult checkPerformance(
            Pattern pattern, String testInput) {

            long startTime = System.nanoTime();
            pattern.matcher(testInput).matches();
            long endTime = System.nanoTime();

            long duration = (endTime - startTime) / 1_000_000; // ミリ秒

            return new PerformanceResult(
                duration < 100,  // 100ms以内を許容
                duration
            );
        }

        // 3. セキュリティチェック
        public static SecurityResult checkSecurity(Pattern pattern) {
            String regex = pattern.pattern();
            List<String> warnings = new ArrayList<>();

            // 危険な構文のチェック
            if (regex.contains("(.*)*")) {
                warnings.add("Potentially vulnerable to ReDoS attacks");
            }

            if (regex.length() > 1000) {
                warnings.add("Pattern is too long and may cause performance issues");
            }

            return new SecurityResult(warnings.isEmpty(), warnings);
        }
    }

    // レビュー結果を記録するクラス
    public static class CodeReviewReport {
        private final List<String> findings = new ArrayList<>();

        public void addFinding(String category, String description) {
            findings.add(String.format("[%s] %s", category, description));
        }

        public void printReport() {
            System.out.println("=== Code Review Report ===");
            findings.forEach(System.out::println);
        }

        // レビュー実施例
        public static CodeReviewReport reviewImplementation(
            Pattern pattern, String testInput) {

            CodeReviewReport report = new CodeReviewReport();

            // 1. パターンの妥当性チェック
            if (!ReviewChecklist.validatePattern(pattern)) {
                report.addFinding("Pattern", 
                    "Pattern is too complex or invalid");
            }

            // 2. パフォーマンスチェック
            PerformanceResult perfResult = 
                ReviewChecklist.checkPerformance(pattern, testInput);
            if (!perfResult.isAcceptable()) {
                report.addFinding("Performance", 
                    "Pattern matching takes too long: " + 
                    perfResult.getDuration() + "ms");
            }

            // 3. セキュリティチェック
            SecurityResult secResult = 
                ReviewChecklist.checkSecurity(pattern);
            if (!secResult.isSecure()) {
                secResult.getWarnings().forEach(warning ->
                    report.addFinding("Security", warning));
            }

            return report;
        }
    }
}

　✅ 適切なテストとエラー処理の実装