Java 正则表达式的使用方法

十分想念顺店杂可。。。

下面是 Java 正则表达式详细的使用指南，涵盖语法细节、核心类方法、高级特性及实战案例：

一、正则表达式语法详解

1. 基础字符匹配

• 普通字符：直接匹配自身（如 a 匹配 "a"，3 匹配 "3"）。
• 转义字符：用 \\ 表示特殊含义（Java 中需双重转义）：
  • \\. 匹配 .（避免被解读为任意字符）
  • \\* 匹配 *（避免被解读为量词）
  • \\n 匹配换行符，\\t 匹配制表符

2. 字符类（[] 定义）

• 枚举匹配：[abc] 匹配 a/b/c；[0-9] 匹配任意数字（等价于 \\d）。
• 排除匹配：[^abc] 匹配非 a/b/c 的字符。
• 范围组合：[a-zA-Z0-9] 匹配字母或数字（等价于 \\w）。
• 预定义字符类：
  • \\d = [0-9]（数字）
  • \\D = [^0-9]（非数字）
  • \\s = [ \t\n\x0B\f\r]（空白符）
  • \\S = [^ \t\n\x0B\f\r]（非空白符）
  • \\w = [a-zA-Z_0-9]（单词字符）
  • \\W = [^a-zA-Z_0-9]（非单词字符）

3. 量词（控制匹配次数）

• 贪婪模式（默认）：尽可能多匹配：
  • *：0 次或多次（a* 匹配 ""、"a"、"aa"...）
  • +：1 次或多次（a+ 匹配 "a"、"aa"...）
  • ?：0 次或 1 次（a? 匹配 "" 或 "a"）
  • {n}：恰好 n 次（a{3} 匹配 "aaa"）
  • {n,}：至少 n 次（a{2,} 匹配 "aa"、"aaa"...）
  • {n,m}：n 到 m 次（a{1,3} 匹配 "a"、"aa"、"aaa"）
• 非贪婪模式：在量词后加 ?，尽可能少匹配：
  • a*?：匹配 0 次或多次，但优先最短（如 "aaaa" 中匹配 ""）
  • a+?：匹配 1 次即可（如 "aaaa" 中匹配 "a"）

4. 边界匹配

• ^：行的开头（^abc 匹配以 "abc" 开头的字符串）。
• $：行的结尾（abc$ 匹配以 "abc" 结尾的字符串）。
• \\b：单词边界（\\bcat\\b 匹配独立单词 "cat"，不匹配 "category" 中的 "cat"）。
• \\B：非单词边界（\\Bcat\\B 匹配 "category" 中的 "cat"）。

5. 分组与引用

• 捕获分组：用 () 定义，可通过 group(n) 提取：

  Pattern p = Pattern.compile("(\\d{4})-(\\d{2})-(\\d{2})"); // 年-月-日分组
  Matcher m = p.matcher("2023-10-05");
  if (m.matches()) {
      String year = m.group(1); // "2023"
      String month = m.group(2); // "10"
  }
  

• 非捕获分组：用 (?:pattern) 定义，仅用于分组不捕获（节省性能）：

  Pattern p = Pattern.compile("(?:https?):\\/\\/"); // 匹配http://或https://，不捕获
  

• 反向引用：用 \\n 引用第 n 个分组的内容（替换时用 $n）：

  // 交换两个数字（如"12-34" → "34-12"）
  String result = "12-34".replaceAll("(\\d+)-(\\d+)", "$2-$1"); 
  

6. 零宽断言（预查）

• 正向肯定预查：(?=pattern) 匹配后面紧跟 pattern 的位置：

  Pattern p = Pattern.compile("\\d+(?=元)"); // 匹配后面是"元"的数字（如"100元"中的"100"）
  

• 正向否定预查：(?!pattern) 匹配后面不紧跟 pattern 的位置：

  Pattern p = Pattern.compile("\\d+(?!元)"); // 匹配后面不是"元"的数字（如"100个"中的"100"）
  

• 反向肯定预查：(?<=pattern) 匹配前面是 pattern 的位置：

  Pattern p = Pattern.compile("(?<=￥)\\d+"); // 匹配前面是"￥"的数字（如"￥100"中的"100"）
  

• 反向否定预查：(?<!pattern) 匹配前面不是 pattern 的位置：

  Pattern p = Pattern.compile("(?<!￥)\\d+"); // 匹配前面不是"￥"的数字（如"$100"中的"100"）
  

二、Pattern 类详解

1. 编译方法与标志

// 基本编译
Pattern pattern = Pattern.compile(regex);

// 带标志编译（多标志用 | 分隔）
Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE | Pattern.MULTILINE);

常用标志：

• CASE_INSENSITIVE：忽略大小写（如 a 匹配 A）。
• MULTILINE：多行模式（^ 匹配每行开头，$ 匹配每行结尾）。
• DOTALL：s 模式，. 匹配包括换行符 \n 在内的所有字符。
• UNICODE_CASE：结合 CASE_INSENSITIVE，支持 Unicode 字符大小写匹配。
• COMMENTS：忽略正则中的空格和 # 注释（需用 (?x) 开启内联注释）。

2. 常用方法

• matcher(CharSequence input)：创建 Matcher 对象。
• split(CharSequence input)：按匹配规则分割字符串（返回数组）：

  String[] parts = Pattern.compile("\\|").split("a|b|c"); // ["a", "b", "c"]
  

• matches(String regex, CharSequence input)：静态方法，直接判断全匹配。

三、Matcher 类详解

1. 匹配状态方法

• matches()：全字符串匹配（整个字符串必须符合正则）。
• lookingAt()：从字符串开头匹配（不必匹配全部）：

  Matcher m = Pattern.compile("\\d+").matcher("123abc");
  m.lookingAt(); // true（匹配"123"）
  

• find()：查找下一个匹配子串（可循环调用）：

  Matcher m = Pattern.compile("\\d+").matcher("a123b456");
  while (m.find()) {
      System.out.println(m.group()); // 依次输出"123"、"456"
  }
  

• start()/end()：返回当前匹配的起始 / 结束索引（end() 是匹配后一位）：

  m.find(); // 匹配"123"
  m.start(); // 1（"123"在字符串中的起始索引）
  m.end(); // 4（"123"结束索引的下一位）
  

2. 替换与修改方法

• replaceAll(String replacement)：替换所有匹配。
• replaceFirst(String replacement)：替换第一个匹配。
• appendReplacement(StringBuffer sb, String replacement)：逐步替换并追加到缓冲区（灵活控制替换过程）：

  StringBuffer sb = new StringBuffer();
  Matcher m = Pattern.compile("\\d+").matcher("a123b456");
  while (m.find()) {
      m.appendReplacement(sb, "*" + m.group() + "*"); // 包裹数字
  }
  m.appendTail(sb); // 追加剩余部分
  System.out.println(sb.toString()); // "a*123*b*456*"
  

3. 重置与重新配置

• reset()：重置匹配器状态，可重新输入字符串：

  matcher.reset("new string"); // 重新匹配新字符串
  

• usePattern(Pattern newPattern)：更换正则模式（复用 Matcher 对象）。

四、实战案例

1. 验证手机号（中国大陆）

String regex = "^1[3-9]\\d{9}$"; // 1开头，第二位3-9，共11位
boolean isValid = Pattern.matches(regex, "13800138000"); // true

2. 提取 URL 中的域名

String url = "https://www.example.com/path?query=1";
Pattern p = Pattern.compile("(?<=https?://)(\\w+\\.)+\\w+");
Matcher m = p.matcher(url);
if (m.find()) {
    String domain = m.group(); // "www.example.com"
}

3. 清除 HTML 标签

String html = "<div><p>Hello</p></div>";
String text = html.replaceAll("<[^>]+>", ""); // 替换所有标签为空白 → "Hello"

4. 格式化数字（每 3 位加逗号）

String number = "123456789";
String formatted = number.replaceAll("(\\d)(?=(\\d{3})+$)", "$1,"); // "123,456,789"

五、性能与避坑指南

1. 避免灾难性回溯：复杂正则（如 (a+)+b 匹配 aaaaa）可能导致性能爆炸，建议简化或拆分。
2. 预编译复用：频繁使用的正则用 Pattern 预编译，避免重复编译开销。
3. 转义陷阱：注意特殊字符转义（如 .、*、( 需加 \\）。
4. 贪婪与非贪婪选择：根据需求选择模式（如提取标签用 .*? 而非 .*）。
5. 分组索引：group(0) 是全匹配，分组从 1 开始计数。

通过掌握上述细节，可应对 Java 中绝大多数正则表达式场景，包括字符串验证、提取、格式化等复杂需求。正则表达式的核心在于多练习，结合具体场景调试模式。