Java 正则表达式的使用指南

目录

• 一、正则表达式语法详解
• 1. 基础字符匹配
• 2. 字符类（[]定义）
• 3. 量词（控制匹配次数）
• 4. 边界匹配
• 5. 分组与引用
• 6. 零宽断言（预查）
• 二、Pattern 类详解
• 1. 编译方法与标志
• 2. 常用方法
• 三、Matcher 类详解
• 1. 匹配状态方法
• 2. 替换与修改方法
• 3. 重置与重新配置
• 四、实战案例
• 1. 验证手机号（中国大陆）
• 2. 提取 URL 中的域名
• 3. 清除 html 标签
• 4. 格式化数字（每 3 位加逗号）
• 五、性能与避坑指南

下面是 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"、&quoectXrMut;aaa"http://www.devze.com;）
• 非贪婪模式：在量词后加 ?，尽可能少匹配：
  • 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. 贪婪与非贪婪选择：根据需求选择模式（如提取标签用&nbs编程p;.*? 而非 .*）。
5. 分组索引：group(0) 是全匹配，分组从 1 开始计数。

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

到此这篇关于Java 正则表达式的使用指南的文章就介绍到这了,更多相关java正则表达式使用内容请搜索编程客栈(www.devze.com)以前的文章或继续浏览下面的相关文章希望大家以后多多支持编程客栈(www.devze.com)！