Java正则表达式高级用法详细解析教程

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

public class RegexAdvancedDemo {

    public static void main(String[] args) {
        // 编译正则表达式
        String regex = "(\d{4})-(\d{2})-(\d{2})"; // 匹配日期格式 YYYY-MM-DD
        Pattern datePattern = Pattern.compile(regex);

        String text = "今天是2023-10-26，明天是2023-10-27。";

        // 创建Matcher对象
        Matcher matcher = datePattern.matcher(text);

        System.out.println("--- 基础匹配与捕获组 ---");
        // 使用find()查找所有匹配项
        while (matcher.find()) {
            System.out.println("找到匹配: " + matcher.group(0)); // 整个匹配项
            System.out.println("  年份: " + matcher.group(1)); // 第一个捕获组
            System.out.println("  月份: " + matcher.group(2)); // 第二个捕获组
            System.out.println("  日期: " + matcher.group(3)); // 第三个捕获组
        }

        // --- 高级特性：命名捕获组 ---
        // 命名捕获组让代码更易读，尤其是正则表达式复杂时
        String namedRegex = "(?<year>\d{4})-(?<month>\d{2})-(?<day>\d{2})";
        Pattern namedDatePattern = Pattern.compile(namedRegex);
        Matcher namedMatcher = namedDatePattern.matcher(text);

        System.out.println("
--- 命名捕获组 ---");
        while (namedMatcher.find()) {
            System.out.println("找到匹配: " + namedMatcher.group("year") + "-" +
                                 namedMatcher.group("month") + "-" +
                                 namedMatcher.group("day"));
        }

        // --- 高级特性：非捕获组 ---
        // 有时我们只想分组，但又不想捕获内容，比如 (?:...)
        String nonCapturingRegex = "(?:http|https)://(?:www\.)?([a-zA-Z0-9.-]+)\.([a-zA-Z]{2,6})(?:/.*)?";
        Pattern urlPattern = Pattern.compile(nonCapturingRegex);
        Matcher urlMatcher = urlPattern.matcher("访问我的网站 https://www.example.com/path/to/page 或 http://blog.test.org");

        System.out.println("
--- 非捕获组与URL解析 ---");
        while(urlMatcher.find()) {
            System.out.println("域名: " + urlMatcher.group(1) + "." + urlMatcher.group(2)); // 只捕获了域名部分
        }

        // --- 高级特性：零宽断言 (Lookarounds) ---
        // 零宽断言不消耗字符，只用于判断匹配位置的前后条件
        // 正向先行断言 (?=...)：匹配后面跟着特定模式的文本
        String lookaheadRegex = "\bJava\b(?=\s*工程师)"; // 匹配后面跟着" 工程师"的"Java"
        Pattern lookaheadPattern = Pattern.compile(lookaheadRegex);
        Matcher lookaheadMatcher = lookaheadPattern.matcher("Java是一种编程语言。Java 工程师很受欢迎。");

        System.out.println("
--- 正向先行断言 (?=...) ---");
        while(lookaheadMatcher.find()) {
            System.out.println("找到匹配: " + lookaheadMatcher.group(0)); // 只匹配到"Java"
        }

        // 负向先行断言 (?!...)：匹配后面不跟着特定模式的文本
        String negativeLookaheadRegex = "\bJava\b(?!Script)"; // 匹配后面不跟着"Script"的"Java"
        Pattern negativeLookaheadPattern = Pattern.compile(negativeLookaheadRegex);
        Matcher negativeLookaheadMatcher = negativeLookaheadPattern.matcher("Java语言和JavaScript是不同的。");

        System.out.println("
--- 负向先行断言 (?!...) ---");
        while(negativeLookaheadMatcher.find()) {
            System.out.println("找到匹配: " + negativeLookaheadMatcher.group(0));
        }

        // 正向后行断言 (?<=...)：匹配前面是特定模式的文本
        String lookbehindRegex = "(?<=版本号: )\d+\.\d+"; // 匹配前面是"版本号: "的数字版本
        Pattern lookbehindPattern = Pattern.compile(lookbehindRegex);
        Matcher lookbehindMatcher = lookbehindPattern.matcher("软件版本号: 1.2.3，新版本号: 2.0");

        System.out.println("
--- 正向后行断言 (?<=...) ---");
        while(lookbehindMatcher.find()) {
            System.out.println("找到版本号: " + lookbehindMatcher.group(0));
        }

        // 负向后行断言 (?<!...)：匹配前面不是特定模式的文本
        String negativeLookbehindRegex = "(?<!旧)版本"; // 匹配前面不是"旧"的"版本"
        Pattern negativeLookbehindPattern = Pattern.compile(negativeLookbehindRegex);
        Matcher negativeLookbehindMatcher = negativeLookbehindPattern.matcher("这是新版本，不是旧版本。");

        System.out.println("
--- 负向后行断言 (?<!...) ---");
        while(negativeLookbehindMatcher.find()) {
            System.out.println("找到匹配: " + negativeLookbehindMatcher.group(0));
        }

        // --- 高级特性：贪婪、勉强与独占量词 ---
        // 默认是贪婪匹配，尽可能多地匹配
        String greedyRegex = "<.*>"; // 匹配从第一个<到最后一个>
        Pattern greedyPattern = Pattern.compile(greedyRegex);
        Matcher greedyMatcher = greedyPattern.matcher("<div><span>Hello</span></div>");
        System.out.println("
--- 贪婪量词 (.*) ---");
        if(greedyMatcher.find()) {
            System.out.println("贪婪匹配: " + greedyMatcher.group(0));
        }

        // 勉强匹配 (Reluctant Quantifiers)：在量词后加?，尽可能少地匹配
        String reluctantRegex = "<.*?>"; // 匹配从第一个<到最近的>
        Pattern reluctantPattern = Pattern.compile(reluctantRegex);
        Matcher reluctantMatcher = reluctantPattern.matcher("<div><span>Hello</span></div>");
        System.out.println("
--- 勉强量词 (.*?) ---");
        while(reluctantMatcher.find()) {
            System.out.println("勉强匹配: " + reluctantMatcher.group(0));
        }

        // 独占量词 (Possessive Quantifiers)：在量词后加+，一旦匹配就不回溯，用于避免灾难性回溯
        // 比如 .*+
        // 这是一个更高级的性能优化，通常用于防止正则表达式在特定模式下陷入无限回溯的陷阱。
        // 在这里就不直接展示代码了，因为它的效果需要特定构造才能体现，而且更多是性能考量。
    }
}

// 示例：从日志行中提取特定信息
String logEntry = "2023-10-26 14:30:15 [ERROR] (OrderService) - User 12345 failed to process order XYZ.";
String logRegex = "(?<timestamp>\d{4}-\d{2}-\d{2} \d{2}:\d{2}:\d{2})\s+\[(?<level>\w+)\]\s+\((?<source>[^)]+)\)\s+-\s+(?<message>.*)";
Pattern logPattern = Pattern.compile(logRegex);
Matcher logMatcher = logPattern.matcher(logEntry);

if (logMatcher.matches()) { // matches()尝试匹配整个字符串
    System.out.println("日志时间: " + logMatcher.group("timestamp"));
    System.out.println("日志级别: " + logMatcher.group("level"));
    System.out.println("来源服务: " + logMatcher.group("source"));
    System.out.println("错误信息: " + logMatcher.group("message"));
}

// 示例：复杂密码验证（验证规则：至少8位，包含大小写字母、数字和特殊字符）
String password = "MySecureP@ss1";
String passwordRegex = "^(?=.*[a-z])(?=.*[A-Z])(?=.*\d)(?=.*[@$!%*?&])[A-Za-z\d@$!%*?&]{8,}$";
Pattern passwordPattern = Pattern.compile(passwordRegex);
Matcher passwordMatcher = passwordPattern.matcher(password);

System.out.println("
密码验证结果: " + passwordMatcher.matches());

// 解释一下密码验证的正则表达式：
// ^                          - 字符串开始
// (?=.*[a-z])                - 零宽先行断言：确保字符串中至少有一个小写字母
// (?=.*[A-Z])                - 零宽先行断言：确保字符串中至少有一个大写字母
// (?=.*\d)                  - 零宽先行断言：确保字符串中至少有一个数字
// (?=.*[@$!%*?&])            - 零宽先行断言：确保字符串中至少有一个特殊字符
// [A-Za-z\d@$!%*?&]{8,}    - 匹配大小写字母、数字和特殊字符，长度至少8位
// $                          - 字符串结束