Java 正则表达式

什么是正则表达式？

正则表达式（Regular Expression，简称 Regex）是一种强大的文本模式匹配工具，就像是文本世界的"搜索引擎"。

🔍 生活中的类比

想象你在图书馆寻找书籍：

• 普通搜索： "找到书名是《Java编程思想》的书" - 精确匹配
• 正则搜索： "找到所有以'Java'开头，包含'编程'的书" - 模式匹配

正则表达式的核心能力

• 🎯 模式匹配：检查文本是否符合特定模式
• 🔍 文本搜索：在大量文本中快速找到目标
• ✂️ 文本替换：批量替换符合模式的文本
• 📝 数据验证：验证邮箱、电话号码等格式

🔧 什么是有限状态自动机？

有限状态自动机是一个数学模型，由以下组成：

• 状态集合：有限个状态，包括初始状态和接受状态
• 字母表：输入符号的集合
• 转移函数：定义状态间的转移规则
• 初始状态：自动机开始的状态
• 接受状态：表示匹配成功的状态

🎯 正则表达式如何工作

示例：匹配 "ab*c" 的状态机

示例：匹配字符串 "ab*c" 的状态机

S1 --a--> S2 --b--> S2(自循环) --c--> S3(接受状态)

工作过程：

1. 从初始状态 S1 开始
2. 读取字符 'a'，转移到状态 S2
3. 读取任意数量的 'b'（可以为 0 个），保持在状态 S2
4. 读取字符 'c'，转移到接受状态 S3
5. 到达接受状态，匹配成功！

String类的文本处理方法

在学习正则表达式之前，让我们先了解String类中常用的文本处理方法：

String text = "Hello World, Hello Java";

// replace() - 替换所有匹配的字符序列
String result1 = text.replace("Hello", "Hi");
// 结果: "Hi World, Hi Java"

// replaceAll() - 支持正则表达式的替换
String result2 = text.replaceAll("Hello", "Hi");
// 结果: "Hi World, Hi Java"

// replaceAll() 的正则表达式威力
String phoneText = "电话: 123-456-7890, 手机: 987-654-3210";
String masked = phoneText.replaceAll("\\d{3}-\\d{3}-\\d{4}", "***-***-****");
// 结果: "电话: ***-***-****, 手机: ***-***-****"

String data = "apple,banana,orange";

// 简单分割
String[] fruits = data.split(",");
// 结果: ["apple", "banana", "orange"]

// 使用正则表达式分割
String complexData = "apple,banana;orange:grape";
String[] allFruits = complexData.split("[,;:]");
// 结果: ["apple", "banana", "orange", "grape"]

// 处理多个空格
String sentence = "Hello    world   Java";
String[] words = sentence.split("\\s+");
// 结果: ["Hello", "world", "Java"]

String方法的局限性

// 使用String方法很难实现
String email = "user@example.com";
// 如何验证这是一个有效的邮箱？

// String方法无法轻松实现
String text = "价格：￥199.99，折扣：8.5折";
// 如何提取所有数字？

正则表达式基础语法

正则表达式由普通字符和特殊字符（元字符）组成，就像编程语言的语法一样。

1. 基础字符介绍

注意：某些符号在正则中具有特殊意义（如 .、*、+），若要匹配它们本身，可放入字符类或使用转义（如 \.）。

2. 特殊含义字符

3. 边界规则

4. 高级字符

5. 量词规则

6. 实际应用示例

• 十六进制颜色： #[0-9a-fA-F]{6} - CSS颜色代码
• 日期（YYYY-MM-DD）： ^\d{4}-\d{2}-\d{2}$ - 整行必须是日期格式

Pattern和Matcher类：Java正则表达式的核心

学习了正则表达式语法后，让我们掌握Java中专门用于正则表达式操作的两个核心类。

// 编译正则表达式
Pattern pattern = Pattern.compile("\\d{3}-\\d{2}-\\d{4}");

// 带标志的编译
Pattern pattern = Pattern.compile("hello", Pattern.CASE_INSENSITIVE);

// 创建Matcher对象
String text = "电话：123-45-6789";
Matcher matcher = pattern.matcher(text);

// 执行匹配操作
if (matcher.find()) {
    System.out.println("找到匹配：" + matcher.group());
}

贪婪与非贪婪匹配

理解正则表达式的两种匹配策略，掌握精确控制匹配行为的技巧。

🔍 匹配机制原理

• 贪婪匹配 (Greedy)：尽可能多地匹配字符，先匹配最长可能的字符串，然后回溯
• 非贪婪匹配 (Non-Greedy/Lazy)：尽可能少地匹配字符，先匹配最短可能的字符串，必要时扩展

📊 量词对比表

🎭 实战演示

案例1：HTML标签提取

文本："<div>Hello</div><span>World</span>"

• 贪婪模式 <.*>：匹配整个字符串 ❌
• 非贪婪模式 <.*?>：分别匹配每个标签 ✅

案例2：引号内容提取

文本："name=\"John\" age=\"25\""

• 贪婪模式 ".*"：匹配 "John\" age=\"25" ❌
• 非贪婪模式 ".*?"：分别匹配 "John" 和 "25" ✅

💻 Java代码示例

import java.util.regex.*;

public class GreedyDemo {
    public static void main(String[] args) {
        String text = "<div>Hello</div><span>World</span>";
        
        // 贪婪匹配
        Pattern greedyPattern = Pattern.compile("<.*>");
        Matcher greedyMatcher = greedyPattern.matcher(text);
        System.out.println("贪婪匹配结果:");
        while (greedyMatcher.find()) {
            System.out.println("  " + greedyMatcher.group());
        }
        
        // 非贪婪匹配
        Pattern lazyPattern = Pattern.compile("<.*?>");
        Matcher lazyMatcher = lazyPattern.matcher(text);
        System.out.println("非贪婪匹配结果:");
        while (lazyMatcher.find()) {
            System.out.println("  " + lazyMatcher.group());
        }
    }
}

完整验证示例

实战示例

import java.util.regex.Pattern;

public class EmailValidator {
    private static final String EMAIL_PATTERN = 
        "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$";
    
    private static final Pattern pattern = Pattern.compile(EMAIL_PATTERN);
    
    public static boolean isValidEmail(String email) {
        return pattern.matcher(email).matches();
    }
    
    public static void main(String[] args) {
        System.out.println(isValidEmail("user@example.com"));    // true
        System.out.println(isValidEmail("invalid.email"));      // false
        System.out.println(isValidEmail("test@domain.co.uk"));  // true
    }
}

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

public class PhoneExtractor {
    public static List<String> extractPhones(String text) {
        String phonePattern = "1[3-9]\\d{9}";
        Pattern pattern = Pattern.compile(phonePattern);
        Matcher matcher = pattern.matcher(text);
        
        List<String> phones = new ArrayList<>();
        while (matcher.find()) {
            phones.add(matcher.group());
        }
        return phones;
    }
    
    public static void main(String[] args) {
        String text = "联系方式：13812345678，备用号码：15987654321";
        List<String> phones = extractPhones(text);
        phones.forEach(System.out::println);
        // 输出：13812345678, 15987654321
    }
}

分组和捕获

分组是正则表达式的强大功能，允许我们提取匹配的子字符串并进行复杂的模式匹配。

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

public class GroupExample {
    public static void main(String[] args) {
        String text = "生日：1990-05-15";
        String pattern = "(\\d{4})-(\\d{2})-(\\d{2})";
        
        Pattern p = Pattern.compile(pattern);
        Matcher m = p.matcher(text);
        
        if (m.find()) {
            System.out.println("完整日期：" + m.group(0));  // 1990-05-15
            System.out.println("年份：" + m.group(1));      // 1990
            System.out.println("月份：" + m.group(2));      // 05
            System.out.println("日期：" + m.group(3));      // 15
        }
    }
}

// 捕获分组
Pattern.compile("(https?)://(.+)");

// 非捕获分组
Pattern.compile("(?:https?)://(.+)");

String pattern = "(?<year>\\d{4})-(?<month>\\d{2})-(?<day>\\d{2})";
Pattern p = Pattern.compile(pattern);
Matcher m = p.matcher("2024-01-15");

if (m.find()) {
    System.out.println("年：" + m.group("year"));
    System.out.println("月：" + m.group("month"));
    System.out.println("日：" + m.group("day"));
}

// 匹配重复的单词（不使用边界符）
String pattern = "(\\w+)\\s+\\1";
String text = "hello hello world world";
// 匹配到 "hello hello" 和 "world world"

文本替换和匹配标志

正则表达式不仅能匹配文本，还能进行智能替换和使用各种标志控制匹配行为。

public class TextReplacer {
    public static void main(String[] args) {
        String text = "今天是2024年1月15日，明天是2024年1月16日";
        
        // 将所有日期格式从 YYYY年MM月DD日 改为 YYYY-MM-DD
        String pattern = "(\\d{4})年(\\d{1,2})月(\\d{1,2})日";
        String replacement = "$1-$2-$3";
        
        String result = text.replaceAll(pattern, replacement);
        System.out.println(result);
        // 输出：今天是2024-1-15，明天是2024-1-16
    }
}

public class AdvancedReplacement {
    public static void main(String[] args) {
        // 使用Matcher进行复杂替换
        String text = "价格：$100, $200, $300, 快来买！";
        Pattern pattern = Pattern.compile("\\$(\\d+)");
        Matcher matcher = pattern.matcher(text);
        
        // 创建可变的字符串缓冲区，用于逐步构建替换后的结果
        StringBuffer result = new StringBuffer();
        
        // 循环查找所有匹配的价格数字
        while (matcher.find()) {
            // 提取捕获组中的价格字符串并转为整数
            int price = Integer.parseInt(matcher.group(1));
            // 计算8折后的新价格
            int discountPrice = (int)(price * 0.8); // 8折
            // 将匹配到的部分替换为带人民币符号的折扣价
            matcher.appendReplacement(result, "¥" + discountPrice);
        }
        
        // 将剩余未匹配的文本追加到结果末尾
        matcher.appendTail(result);
        
        // 输出最终完成替换的字符串
        System.out.println(result.toString());
        // 输出：价格：¥80, ¥160, ¥240, 快来买！
    }
}

// 组合多个标志
Pattern pattern = Pattern.compile(
    "hello.*world", 
    Pattern.CASE_INSENSITIVE | Pattern.DOTALL
);

回溯爆炸

1. 定义

回溯爆炸是指正则引擎在尝试匹配失败后，为寻找其他可能的匹配路径而不断回退并重试多种分支与分组拆分，导致尝试次数随输入长度呈指数级增长（常见为 O(2^n)），从而引发性能问题甚至程序卡死。

2. 实例演示

示例（n=4 的分割枚举）
[4]       -> aaaa | b (失败)
[3,1]     -> aaa + a | b (失败)
[2,2]     -> aa + aa | b (失败)
[2,1,1]   -> aa + a + a | b (失败)
[1,3]     -> a + aaa | b (失败)
[1,2,1]   -> a + aa + a | b (失败)
[1,1,2]   -> a + a + aa | b (失败)
[1,1,1,1] -> a + a + a + a | b (失败)

// 简单耗时对比（Java）
String text1 = "aaaaaaaaaaaaaaaaaaaaaaaaaaab";
String text2 = "aaaaaaaaaaaaaaaaaaaaaaaaaaa";
String bad = "(a+)+b";
String good = "a+b"; // 去除嵌套量词

long t1 = System.nanoTime();
Pattern.compile(bad).matcher(text2).find();
long t2 = System.nanoTime();
System.out.println("危险模式耗时(ms): " + (t2 - t1) / 1_000_000);

long t3 = System.nanoTime();
Pattern.compile(good).matcher(text2 + "b").find();
long t4 = System.nanoTime();
System.out.println("修复后耗时(ms): " + (t4 - t3) / 1_000_000);

3. 解决方案（针对上述示例）

4. 最佳实践

• 避免“同一字符上的嵌套量词”（如 (.*)+、(a+)+）。
• 优先使用“更具体的字符类与有界量词”（如 [a-zA-Z0-9]{1,20} 替代 .*）。
• 在不需要回退时使用占有量词（*+、++、?+）。
• 通过边界（^、$、\b）或上下文限制（前后查找）缩小匹配范围。
• 减少重叠的交替分支（将 (ab|a) 改写为 a(b)?）。
• 为最坏情况做测试与基准，避免在不可信输入上使用过于宽泛的模式。

常见陷阱与性能优化

// 错误：编译时报错
Pattern.compile("\d+");

// 正确：双重转义
Pattern.compile("\\d+");

// 或使用字符类
Pattern.compile("[0-9]+");

// 危险：可能导致性能问题
Pattern.compile("(a+)+b");

// 安全：更好的选择
Pattern.compile("a+b");

// 使用原子分组避免回溯
Pattern.compile("(?>a+)b");

String text = "hello world";

// 字符串边界
Pattern.compile("^hello").matcher(text).find();  // true

// 单词边界
Pattern.compile("\\bhello\\b").matcher(text).find();  // true
Pattern.compile("\\bworld\\b").matcher(text).find();  // true

// 更快的数字匹配
Pattern.compile("[0-9]+");
// 而不是
Pattern.compile("\\d+");

// 非捕获分组，性能更好
Pattern.compile("(?:abc|def)+");
// 而不是
Pattern.compile("(abc|def)+");

// 精确匹配，避免不必要的搜索
Pattern.compile("^\\d{3}-\\d{2}-\\d{4}$");
// 而不是
Pattern.compile("\\d{3}-\\d{2}-\\d{4}");

// 使用静态常量
private static final Pattern PATTERN = 
    Pattern.compile("regex");

// 或使用缓存
private static final Map<String, Pattern> 
    PATTERN_CACHE = new ConcurrentHashMap<>();