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();
}