Java中正则表达式Pattern和Matcher的使用终极指南

// 正则表达式本身应该是：\\
// 但在 Java 字符串中，\ 需要转义，所以每个 \ 都要变成 \\
// 结果：String regex = "\\\\";

String regex = "\\\\";  // 匹配一个反斜杠字符
String text = "\\";     // 字符串内容是一个反斜杠
System.out.println(text.matches(regex));  // true

import java.util.regex.*;

String text = "我的手机号是 13812345678，请保存。";
Pattern p = Pattern.compile("\\d{11}");

// ❌ matches()：要求整个字符串都是 11 位数字，返回 false
System.out.println(p.matcher(text).matches());  // false

// ✅ find()：查找子串，找到 13812345678，返回 true
Matcher m = p.matcher(text);
System.out.println(m.find());  // true
System.out.println(m.group()); // 13812345678

import java.util.regex.*;

String text = "姓名：张三，年龄：25，姓名：李四，年龄：30";
Pattern p = Pattern.compile("姓名：([\\u4e00-\\u9fa5]+)，年龄：(\\d+)");
Matcher m = p.matcher(text);

while (m.find()) {
    String name = m.group(1);   // 第1个括号捕获的内容
    String age = m.group(2);    // 第2个括号捕获的内容
    System.out.println("姓名：" + name + "，年龄：" + age);
}
// 输出：
// 姓名：张三，年龄：25
// 姓名：李四，年龄：30

Pattern p = Pattern.compile("(\\d{4})-(\\d{2})-(\\d{2})");
Matcher m = p.matcher("2026-08-18");
if (m.matches()) {
    System.out.println(m.group(0));  // 2026-08-18（整个匹配）
    System.out.println(m.group(1));  // 2026
    System.out.println(m.group(2));  // 08
    System.out.println(m.group(3));  // 18
}

Pattern p = Pattern.compile("(?<year>\\d{4})-(?<month>\\d{2})-(?<day>\\d{2})");
Matcher m = p.matcher("2026-08-18");
if (m.matches()) {
    System.out.println(m.group("year"));   // 2026
    System.out.println(m.group("month"));  // 08
    System.out.println(m.group("day"));    // 18
}

String text = "我的电话是 13812345678，备用电话 13987654321";
String result = text.replaceAll("\\d{11}", "****");
System.out.println(result);  // 我的电话是 ****，备用电话 ****

// 将日期格式从 yyyy-MM-dd 转为 dd/MM/yyyy
String text = "今天是 2026-08-18，明天是 2026-08-19";
String result = text.replaceAll("(\\d{4})-(\\d{2})-(\\d{2})", "$3/$2/$1");
System.out.println(result);
// 今天是 18/08/2026，明天是 19/08/2026

Pattern p = Pattern.compile("\\d{11}");
Matcher m = p.matcher("我的电话是 13812345678，备用电话 13987654321");
StringBuffer sb = new StringBuffer();

while (m.find()) {
    // 对每个匹配到的手机号，用脱敏后的内容替换
    String masked = m.group().substring(0, 3) + "****" + m.group().substring(7);
    m.appendReplacement(sb, masked);
}
m.appendTail(sb);  // 追加剩余未匹配的尾部

System.out.println(sb.toString());  // 我的电话是 138****5678，备用电话 139****4321

// ❌ 错误：每次调用都重新编译（性能极差）
public boolean isValidPhone(String phone) {
    return phone.matches("\\d{11}");  // 内部调用 Pattern.compile()
}

// ✅ 正确：预先编译，复用 Pattern
public class PhoneValidator {
    private static final Pattern PHONE_PATTERN = Pattern.compile("\\d{11}");
    
    public static boolean isValidPhone(String phone) {
        return PHONE_PATTERN.matcher(phone).matches();
    }
}

// ❌ 不需要捕获却用了捕获分组（有性能开销）
Pattern.compile("(\\d{3})-(\\d{4})-(\\d{4})");

// ✅ 非捕获分组（性能更好）
Pattern.compile("\\d{3}-\\d{4}-\\d{4}");  // 如果不需要提取
// 或部分需要捕获
Pattern.compile("(\\d{3})-(?:\\d{4})-(\\d{4})");  // 只捕获第1段和第3段

// ❌ 效率低（复杂选择）
Pattern.compile("(a|b|c|d|e)");

// ✅ 效率高（字符类）
Pattern.compile("[a-e]");

// ❌ 高危正则：当输入为 "aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab" 时，回溯爆炸
Pattern.compile("(a+)+b");

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

public final class RegexUtils {
    private static final Pattern PHONE_PATTERN = Pattern.compile("^1[3-9]\\d{9}$");
    private static final Pattern EMAIL_PATTERN = 
        Pattern.compile("^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$");
    
    private RegexUtils() {}
    
    // ===== 校验 =====
    public static boolean isPhone(String str) {
        return str != null && PHONE_PATTERN.matcher(str).matches();
    }
    
    public static boolean isEmail(String str) {
        return str != null && EMAIL_PATTERN.matcher(str).matches();
    }
    
    public static boolean match(String str, String regex) {
        if (str == null || regex == null) return false;
        return Pattern.compile(regex).matcher(str).matches();
    }
    
    // ===== 提取 =====
    public static String extractFirst(String str, String regex) {
        if (str == null || regex == null) return null;
        Matcher m = Pattern.compile(regex).matcher(str);
        return m.find() ? m.group(1) : null;
    }
    
    public static List<String> extractAll(String str, String regex) {
        List<String> result = new ArrayList<>();
        if (str == null || regex == null) return result;
        Matcher m = Pattern.compile(regex).matcher(str);
        while (m.find()) {
            result.add(m.group(1));
        }
        return result;
    }
    
    // ===== 替换 =====
    public static String replaceAll(String str, String regex, String replacement) {
        if (str == null || regex == null) return str;
        return Pattern.compile(regex).matcher(str).replaceAll(replacement);
    }
    
    // ===== 分割 =====
    public static String[] split(String str, String regex) {
        if (str == null || regex == null) return new String[0];
        return Pattern.compile(regex).split(str);
    }
}

// 问题1：下面代码输出什么？为什么？
String text = "123";
System.out.println(text.matches("\\d"));    // A
System.out.println(text.matches("\\d+"));   // B
System.out.println(text.matches("\\d{3}")); // C

// 问题2：如何用正则从 "订单号：ORD-20260818-001" 中提取出 "20260818"？
String str = "订单号：ORD-20260818-001";
// 请写出代码

// 问题3：下面两段代码，哪一段性能更好？为什么？
// 方法 A
for (String s : list) {
    s.matches("\\d{11}");
}
// 方法 B
Pattern p = Pattern.compile("\\d{11}");
for (String s : list) {
    p.matcher(s).matches();
}