Java 正则表达式手册
正则表达式作为处理字符串的核心工具,在Java开发中具有不可替代的地位。无论是数据校验、文本解析、日志提取,还是复杂模式匹配,Java 正则表达式都提供了强大而灵活的解决方案。本手册系统梳理了从基础语法到高级技巧的完整知识体系,结合大量真实可运行的示例代码,帮助开发者快速掌握、高效应用,避免常见误区,显著提升开发效率与代码质量。
在当今数据驱动的时代,字符串处理已成为日常开发中高频操作。尤其在Web应用、日志分析、配置解析、API接口校验等场景中,正则表达式几乎无处不在。例如,电商系统中对用户输入的手机号、邮箱进行格式校验;金融系统中对交易流水号、身份证号进行合法性校验;运维监控系统中从海量日志中提取关键指标等。这些场景的背后,都依赖于高效、准确的正则匹配能力。掌握Java 正则表达式,是每一位Java工程师必须具备的核心技能之一。
本手册以Java 17为基准,全面覆盖Pattern与Matcher类的API设计、元字符与量词的精确语义、分组与回溯机制、性能调优策略、常见陷阱及反模式等关键内容。不同于碎片化教程,我们通过系统化知识结构+可复用代码片段+深度原理剖析,构建完整认知闭环,确保读者不仅“会用”,更能“用好”、“用对”、“用精”。
• 核心语法体系
从基础字符、元字符到高级构造,逐层递进讲解Java 正则表达式语法结构,涵盖字符类、边界匹配、量词、分组、断言等核心概念,配合大量可视化示例,构建清晰认知框架。
• API深度解析
详细解读java.util.regex包中Pattern与Matcher类的完整API设计,包括编译选项、匹配模式、状态管理、分组提取等关键方法的使用场景与注意事项。
• 实战案例精讲
精选电商、金融、日志、配置四大典型场景,提供可直接复用的正则表达式方案,覆盖校验、提取、替换、分割等完整操作链,助您快速落地应用。
• 性能优化指南
深入剖析正则引擎的回溯机制与NFA特性,提供避免灾难性回溯、优化表达式结构、合理使用非捕获组等实用技巧,保障高并发下的匹配性能。
💡 为什么需要系统学习?
正则表达式看似简单,但因其高度紧凑的语法和复杂的引擎行为,极易写出低效甚至错误的表达式。例如,一个看似无害的“.*”在特定输入下可能触发灾难性回溯,导致服务阻塞;错误的边界断言可能遗漏关键匹配项;分组嵌套不当可能引发索引越界。只有通过系统学习与反复实践,才能真正驾驭这一强大工具。
正则表达式语法精要
掌握语法是使用正则的第一步,也是最关键的一步。本节将系统梳理Java正则表达式的语法体系。
1. 基础字符与元字符
正则表达式由普通字符(如字母、数字)与元字符(具有特殊含义的字符)构成。在Java中,元字符包括:.(任意单字符)、^(行首)、$(行尾)、*(0次或多次)、+(1次或多次)、?(0次或1次)、{n,m}(n到m次)、[ ](字符类)、( )(分组)、|(或)、\(转义)等。理解每个元字符的精确语义是编写正确表达式的基础。
特别注意:在Java字符串中使用反斜杠时需双重转义。例如,匹配一个数字字符应写为"\\d"而非"\d",因为Java编译器会先将\d解释为非法转义序列。这是初学者常犯的错误之一。
例:匹配IP地址片段(0-255)
// 匹配单个字节(0-255),用于IP地址校验
String pattern = "(25[0-5]|2[0-4]\\d|1\\d\\d|[1-9]?\\d)";
// 解释:
// 25[0-5] → 250-255
// 2[0-4]\d → 200-249
// 1\d\d → 100-199
// [1-9]?\d → 0-99([1-9]?表示0或1次1-9数字,\d表示0-9)
2. 字符类与取反
字符类[abc]匹配a、b或c中的任意一个字符;[^abc]匹配除a、b、c外的任意字符(取反);[a-z]表示范围;[a-zA-Z0-9]表示字母数字集合。Java还提供预定义字符类:\d(等价于[0-9])、\D(非数字)、\w(单词字符,等价于[a-zA-Z_0-9])、\W(非单词字符)、\s(空白字符,包括空格、制表符、换行等)、\S(非空白字符)。
注意:在字符类内部,大多数元字符失去特殊含义,如[.*+?]仅匹配字符.、*、+、?本身,而非其元义。但^在字符类开头才表示取反,如[^a-z];若在中间(如[a-z^])则仅表示字面量^。
例:提取HTML标签内容(简化版)
String html = "<div class='main'>Hello World</div>";
String regex = "<[a-zA-Z][a-zA-Z0-9]*\\b[^>]*>([^<]*)";
// 解释:
// <[a-zA-Z][a-zA-Z0-9]* → 匹配以字母开头、后跟字母或数字的标签名
// \\b → 单词边界,防止匹配到"divx"中的"div"
// [^>]* → 匹配任意非'>'字符(属性部分)
// > → 标签结束
// ([^<]*) → 捕获组:匹配任意非'<'字符(内容)
3. 量词与贪婪/非贪婪模式
量词控制匹配次数:*(≥0)、+(≥1)、?(0或1)、{n}(恰好n次)、{n,}(≥n次)、{n,m}(n到m次)。Java默认采用贪婪模式(greedy),尽可能多地匹配;添加?后转为非贪婪(reluctant)或懒惰模式(lazy),尽可能少匹配。
例如:.*贪婪,会匹配整行;.*?非贪婪,匹配到第一个满足条件的位置即停止。在解析嵌套结构(如HTML、JSON)时,错误选择模式可能导致匹配范围过大或过小,需结合具体场景调整。
例:提取JSON字段值(非贪婪匹配)
String json = "{\"name\":\"张三\",\"age\":25,\"city\":\"北京\"}";
// 错误(贪婪):匹配到第一个"到最后一个"
// String regex = "\"name\":\".*\"";
// 正确(非贪婪):匹配到第一个"即停止
String regex = "\"name\":\".*?\"";
// Matcher结果:name → 张三
4. 边界与断言
边界断言不消耗字符,仅检查位置:^(行首)、$(行尾)、\b(单词边界)、\B(非单词边界)。零宽断言(zero-width assertions)检查前后文条件:(?=exp)(正向先行断言)、(?!exp)(负向先行断言)、(?<=exp)(正向后行断言)、(?<!exp)(负向后行断言)。
后行断言在Java中要求固定长度,如(?<=abc)合法,但(?<=ab?)非法(长度不固定)。这是Java正则引擎的限制,其他语言(如PCRE)可能无此约束。
例:提取URL中的域名(不含协议与路径)
String url = "https://www.example.com/path/to/page?query=1";
String regex = "(?<=://)[a-zA-Z0-9.-]+(?=/)";
// (?<=://) → 正向后行断言:确保前面是"://"
// [a-zA-Z0-9.-]+ → 域名主体(含连字符和点)
// (?=/) → 正向先行断言:确保后面是"/"
5. 分组与引用
分组(exp)将子表达式视为整体,支持量词作用于整个分组(如(ab)+匹配"abab"),并捕获匹配内容供后续引用。Java支持两种引用方式:捕获组编号(从1开始)和命名组(Java 7+)。
命名组语法:(?<name>exp);引用方式:\k<name>或${name}(替换时)。例如匹配重复单词:\\b(\\w+)\\b.*?\\b\\1\\b(数字引用)或\\b(?<word>\\w+)\\b.*?\\b\\k<word>\\b(命名引用)。
例:匹配重复单词(含大小写差异)
String text = "Hello hello HELLO world";
String regex = "\\b(?i)(\\w+)\\b.*?\\b\\1\\b";
// (?i) → 内联标志:忽略大小写
// (\\w+) → 捕获单词到组1
// \\b\\1\\b → 引用组1,确保单词边界
Pattern与Matcher API详解
Java正则功能由java.util.regex包提供,核心类为Pattern(编译表达式)和Matcher(执行匹配)。本节深入解析其设计与使用。
1. Pattern类:表达式编译与配置
Pattern是正则表达式的编译表示,不可变且线程安全,建议复用。主要方法:compile(String regex, int flags)(编译表达式)、matcher(CharSequence input)(创建匹配器)、matches()(整个输入匹配)、find()(查找子串匹配)、lookingAt()(从开头匹配)、split(CharSequence input)(分割字符串)。
常用标志(flags):CASE_INSENSITIVE(忽略大小写)、MULTILINE(多行模式:^/$匹配行首/行尾而非整行)、DOTALL(.匹配换行符)、UNICODE_CASE(Unicode大小写)、COMMENTS(忽略空白与注释)、UNICODE_CHARACTER_CLASS(Unicode字符类)、UNIX_LINES(仅\n为换行)。
例:多行模式匹配邮箱列表
String input = "Alice: alice@example.com\nBob: bob@test.org";
String regex = "^\\w+@\\w+\\.\\w+$";
Pattern p = Pattern.compile(regex, Pattern.MULTILINE);
Matcher m = p.matcher(input);
while (m.find()) {
System.out.println(m.group()); // 输出:alice@example.com, bob@test.org
}
2. Matcher类:匹配执行与结果提取
Matcher是执行匹配操作的引擎,状态可变。核心方法:find()(查找下一个匹配)、group()(获取匹配文本)、start()/end()(匹配起止索引)、group(int i)(获取第i组)、replaceAll(String replacement)(替换所有匹配)、appendReplacement(StringBuffer sb, String replacement)(增量替换)。
分组索引从1开始,组0表示整个匹配。命名组可通过group(String name)获取。注意:每次调用find()后才可安全调用group()系列方法。
例:提取日志中的时间戳与级别
String log = "2023-08-15 14:30:22 [INFO] User login successful";
String regex = "(\\d{4}-\\d{2}-\\d{2})\\s+(\\d{2}:\\d{2}:\\d{2})\\s+\\[(\\w+)\\]";
Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(log);
if (m.find()) {
System.out.println("日期: " + m.group(1)); // 2023-08-15
System.out.println("时间: " + m.group(2)); // 14:30:22
System.out.println("级别: " + m.group(3)); // INFO
}
3. 增量替换:高效处理大文本
replaceAll()简单高效,但对超大文本可能消耗过多内存。此时可使用appendReplacement+appendTail实现流式处理,逐块替换并写入缓冲区,显著降低内存占用。
例:替换文本中的敏感词(流式处理)
String text = "用户密码:123456,请勿泄露。";
String regex = "(密码)"; // 匹配"密码"
Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(text);
StringBuffer sb = new StringBuffer();
while (m.find()) {
m.appendReplacement(sb, "***"); // 替换为***
}
m.appendTail(sb); // 添加剩余部分
System.out.println(sb.toString()); // "用户***:123456,请勿泄露。"
4. 表达式复用与预编译
Pattern对象编译开销较大,应避免重复编译相同表达式。推荐做法:static final Pattern常量,或使用ThreadLocal管理Matcher实例(非线程安全)。切勿在循环内反复调用Pattern.compile()。
在Spring等容器中,可将Pattern定义为Bean,利用依赖注入复用。若表达式动态变化(如用户输入),需做好异常处理与超时保护。
⚠️ 性能陷阱
以下代码在循环中重复编译,性能极差:
for (String s : inputs) {
Pattern.compile(regex).matcher(s).matches();
}
正确做法:
Pattern p = Pattern.compile(regex);
for (String s : inputs) {
p.matcher(s).matches();
}
实战场景与代码示例
理论结合实践,本节提供四大高频场景的完整解决方案,所有代码均经测试验证。
1. 电商系统:用户输入校验
电商系统需严格校验用户输入,防止恶意数据注入。常见校验项:手机号(11位,1开头)、邮箱(标准格式)、密码强度(字母+数字+特殊字符)、身份证号(18位,含校验码)。
手机号规则:11位数字,以13-19开头,第2位限定特定号段(如13x、14x、15x、16x、17x、18x、19x)。Java正则:"^1[3-9]\\d{9}$"
public static boolean isValidPhone(String phone) {
return phone != null && phone.matches("^1[3-9]\\d{9}$");
}
// 测试
System.out.println(isValidPhone("13812345678")); // true
System.out.println(isValidPhone("12812345678")); // false(2位非13-19)
邮箱格式:本地部分(字母数字.+_-)、@符号、域名部分(字母数字.-)、顶级域(2-6位字母)。简化正则:"^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$"
public static boolean isValidEmail(String email) {
String regex = "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,}$";
return email != null && email.matches(regex);
}
// 测试
System.out.println(isValidEmail("user+tag@example.com")); // true
System.out.println(isValidEmail("user@ex@ample.com")); // false(两个@)
密码强度要求:8-16位,包含大写字母、小写字母、数字、特殊字符(!@#$%^&*)中的至少3类。需组合多个正则或逻辑判断。
public static boolean isValidPassword(String pwd) {
if (pwd == null || pwd.length() < 8 || pwd.length() > 16) return false;
int count = 0;
if (pwd.matches(".*[A-Z].*")) count++;
if (pwd.matches(".*[a-z].*")) count++;
if (pwd.matches(".*\\d.*")) count++;
if (pwd.matches(".*[!@#$%^&*].*")) count++;
return count >= 3;
}
// 测试
System.out.println(isValidPassword("Abc123!@")); // true(4类)
System.out.println(isValidPassword("abc123!@")); // false(仅3类,缺大写)
18位身份证:前6位地址码、8位出生日期(YYYYMMDD)、3位顺序码(奇男偶女)、1位校验码(0-9或X)。校验码计算复杂,此处仅校验格式:"^[1-9]\\d{5}(18|19|20)\\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\\d|3[01])\\d{3}[\\dXx]$"
public static boolean isValidIdCard(String id) {
String regex = "^[1-9]\\d{5}(18|19|20)\\d{2}(0[1-9]|1[0-2])(0[1-9]|[12]\\d|3[01])\\d{3}[\\dXx]$";
return id != null && id.matches(regex);
}
// 测试
System.out.println(isValidIdCard("110101199003072316")); // true
System.out.println(isValidIdCard("110101199002302316")); // false(2月无30日)
2. 日志分析:关键信息提取
日志系统需从海量文本中提取结构化信息,如时间戳、IP地址、请求方法、URL、状态码、响应时间等。以Nginx访问日志为例:
192.168.1.100 - - [15/Aug/2023:14:30:22 +0800] "GET /api/users HTTP/1.1" 200 1234 "-" "Mozilla/5.0"
匹配正则:"(\\d+\\.\\d+\\.\\d+\\.\\d+) - - \\[([^\\]]+)\\] \"(\\w+) ([^\"]+) HTTP/[^\"]+\" (\\d+) (\\d+)"
String log = "192.168.1.100 - - [15/Aug/2023:14:30:22 +0800] \"GET /api/users HTTP/1.1\" 200 1234 \"-\" \"Mozilla/5.0\"";
String regex = "(\\d+\\.\\d+\\.\\d+\\.\\d+) - - \\[([^\\]]+)\\] \"(\\w+) ([^\"]+) HTTP/[^\"]+\" (\\d+) (\\d+)";
Pattern p = Pattern.compile(regex);
Matcher m = p.matcher(log);
if (m.find()) {
System.out.println("IP: " + m.group(1)); // 192.168.1.100
System.out.println("时间: " + m.group(2)); // 15/Aug/2023:14:30:22 +0800
System.out.println("方法: " + m.group(3)); // GET
System.out.println("URL: " + m.group(4)); // /api/users
System.out.println("状态码: " + m.group(5)); // 200
System.out.println("大小: " + m.group(6)); // 1234
}
3. 配置解析:YAML/Properties简化版
处理简单配置文件时,可使用正则提取键值对。以Properties格式为例:key = value(支持空格、注释#)。
String config = "# Database config\nhost = localhost\nport = 3306\nuser = admin";
String regex = "^(?!#)(\\w+)\\s*=\\s*(.+)$";
Pattern p = Pattern.compile(regex, Pattern.MULTILINE);
Matcher m = p.matcher(config);
Map map = new HashMap<>();
while (m.find()) {
map.put(m.group(1), m.group(2).trim());
}
// 结果:{host=localhost, port=3306, user=admin}
4. 文本处理:批量替换与格式化
正则广泛用于文本清洗:替换换行符、去除多余空格、统一日期格式、提取特定字段等。
// 统一日期格式:将"2023/08/15"→"2023-08-15"
String date = "2023/08/15";
String cleaned = date.replaceAll("/", "-");
// 去除多余空格(连续空格→单空格)
String text = "Hello world !";
text = text.replaceAll("\\s+", " ").trim(); // "Hello world !"
// 提取URL中的域名
String url = "https://sub.example.com/path";
String domain = url.replaceAll(".*?://([^/]+).*", "$1"); // "sub.example.com"
性能优化与最佳实践
正则表达式性能差异巨大,合理优化可避免99%的性能问题。本节提供实战经验总结。
1. 回溯机制与灾难性回溯
Java正则引擎基于NFA(非确定性有限自动机),通过回溯处理分支与量词。当表达式存在嵌套量词(如(a+)+)或模糊匹配(如.*)时,可能指数级增长匹配路径,导致性能崩溃。典型灾难性回溯示例:(a+)+$匹配"aaaaaaaaaaaaaaaaaaaaaaaaaaaaaaaab"时,引擎需尝试所有可能的分割方式。
• 问题重现
以下代码在输入字符串较长时可能卡死:
String regex = "(a+)+$";
Pattern.compile(regex).matcher("a".repeat(10000) + "b").matches();
• 根本原因
嵌套量词(a+)+导致双重回溯:外层量词尝试不同分割点,内层量词在每种分割下尝试不同长度,组合爆炸。
• 解决方案
1. 避免嵌套量词:(a+)+→a+
2. 使用占有量词(Java 9+):(a++)+$
3. 限制匹配长度:(a{1,100})+$
2. 优化技巧与工具
以下策略可显著提升性能:
① 避免模糊匹配:用[^ ]+替代.*?匹配非空字符;
② 使用占有量词(Java 9+):++、*+、?+禁止回溯;
③ 优先匹配短路径:将常见模式置于|左侧;
④ 限制范围:用^、$或\b限定匹配边界;
⑤ 预编译复用:避免重复编译Pattern。
例:优化IP地址匹配
// 低效(模糊匹配)
String regex1 = ".*?(\\d+\\.\\d+\\.\\d+\\.\\d+).*";
// 高效(精确边界)
String regex2 = "\\b(\\d{1,3}\\.\\d{1,3}\\.\\d{1,3}\\.\\d{1,3})\\b";
// 性能对比:regex2在长文本中快10倍以上
3. 替代方案对比
并非所有场景都适合正则:
✓ 正则适用:复杂模式匹配、格式校验、文本提取;
✗ 应避免:简单字符串查找(用String.contains())、固定分隔符分割(用String.split())、嵌套结构解析(用专用解析器如JSON库)。
例如:email.split("@")[0]比正则"^(.*?)@"更高效;json.contains("\"name\"")比正则"\"name\""更快且无副作用。
💡 性能测试建议
使用JMH(Java Microbenchmark Harness)进行基准测试,避免JIT预热影响。典型流程:
1. 编写正则匹配逻辑;
2. 准备典型输入数据;
3. 运行JMH测试(10+迭代,预热5+);
4. 比较吞吐量(ops/sec)与平均耗时。
常见陷阱与反模式
避开这些坑,可避免90%的正则Bug。本节总结高频错误与正确解法。
1. 转义与双重转义
在Java字符串中,反斜杠需双重转义:
"\\d" → 正则\d → 匹配数字
"\\\\." → 正则\. → 匹配字面量.
错误示例:Pattern.compile("\.") → 编译错误(Java字符串中\.非法)
正确写法:Pattern.compile("\\.")
例:匹配Windows路径(C:\path\to\file)
// 错误:未转义反斜杠
String regex1 = "C:\path\to\file"; // 实际为"C: ath to ile"
// 正确:双重转义
String regex2 = "C:\\\\path\\\\to\\\\file"; // 正则"C:\path\to\file"
2. 边界断言误用
\b仅匹配单词边界(字母/数字/下划线与非单词字符交界处),对中文、标点无效。
例如:"你好\b"无法匹配"你好,世界",因为好与,之间无单词边界。
解决方法:用\B(非单词边界)或自定义边界规则,如[^\\p{L}\\p{N}](非字母数字)。
3. 贪婪/非贪婪误判
错误使用.*导致匹配范围过大是常见问题。例如:
String text = "<tag>A</tag><tag>B</tag>";
text.replaceAll("<tag>.*</tag>", "X"); // 结果:"X"
正确解法:text.replaceAll("<tag>.*?</tag>", "X"); // "X X"
4. 分组索引错乱
嵌套分组时索引顺序易错:
"(a(b(c)))"中:
组0:整个匹配
组1:最外层(a(b(c)))
组2:第二层(b(c))
组3:最内层(c)
建议:避免深层嵌套,用命名组(?<level1>...)提升可读性。
5. 正则注入风险
用户输入直接拼接到正则表达式中可能导致安全问题:
String userInput = "[a-z]";
Pattern.compile(".*" + userInput + ".*"); // 实际匹配任意内容
解决方法:
1. 对用户输入转义:Pattern.quote(userInput);
2. 限制输入字符集;
3. 使用白名单校验。
⚠️ 安全警告
永远不要将未经验证的用户输入直接用于Pattern.compile()!
正确做法:
String safeInput = Pattern.quote(userInput);
Pattern.compile(".*" + safeInput + ".*");