<think>
我们需要讲解Java正则表达式中的
懒惰匹配（也称为非贪婪匹配、最小匹配）。
在正则表达式中，默认的量词（*, +, ?, {m,n}）是贪婪的，它们会匹配尽可能多的字符。而
懒惰匹配则相反，会匹配尽可能少的字符。
在Java中，可以通过在量词后面添加一个问号（?）来启用
懒惰匹配模式。
例如：
贪婪匹配： "a.*b" 会匹配从第一个a开始到最后一个b之间的所有字符。
懒惰匹配： "a.*?b" 会匹配从第一个a开始到第一个b之间的字符（最短匹配）。
以下是一个详细的Java代码示例，展示如何使用
懒惰匹配：
</think>
### Java正则表达式中的
懒惰匹配（非贪婪匹配）
在正则表达式中，**
懒惰匹配**（也称非贪婪匹配）是指匹配尽可能少的字符，与默认的贪婪匹配（匹配尽可能多的字符）相反。在Java中，通过在量词后添加 `?` 来实现
懒惰匹配。
#### 常用
懒惰量词：
- `*?`：匹配0次或多次（尽可能少）
- `+?`：匹配1次或多次（尽可能少）
- `??`：匹配0次或1次（尽可能少）
- `{n}?`：匹配n次
- `{n,}?`：匹配至少n次（尽可能少）
- `{n,m}?`：匹配n到m次（尽可能少）
### 示例代码与对比
```java
import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class LazyMatchingDemo {
public static void main(String[] args) {
String text = "<div>Header</div><div>Content</div><div>Footer</div>";
// 1. 贪婪匹配（默认） - 匹配整个字符串
greedyMatch(text);
// 2.
懒惰匹配 - 逐个匹配div元素
lazyMatch(text);
// 3. 实际应用：提取JSON值
extractJsonValues();
}
// 贪婪匹配示例
private static void greedyMatch(String text) {
System.out.println("=== 贪婪匹配结果 ===");
Pattern pattern = Pattern.compile("<div>.*</div>");
Matcher matcher = pattern.matcher(text);
while (matcher.find()) {
System.out.println("匹配整个字符串: " + matcher.group());
}
}
//
懒惰匹配示例
private static void lazyMatch(String text) {
System.out.println("\n===
懒惰匹配结果 ===");
Pattern pattern = Pattern.compile("<div>.*?</div>");
Matcher matcher = pattern.matcher(text);
int count = 0;
while (matcher.find()) {
System.out.println("元素 " + (++count) + ": " + matcher.group());
}
}
// 实际应用：提取JSON值
private static void extractJsonValues() {
System.out.println("\n=== JSON值提取 ===");
String json = "{\"name\": \"John\", \"age\": 30, \"city\": \"New York\"}";
//
懒惰匹配提取键值对
Pattern pattern = Pattern.compile("\"([^\"]*?)\":\\s*\"([^\"]*?)\"");
Matcher matcher = pattern.matcher(json);
while (matcher.find()) {
System.out.println("键: " + matcher.group(1) +
", 值: " + matcher.group(2));
}
}
}
```
### 代码输出：
```
=== 贪婪匹配结果 ===
匹配整个字符串: <div>Header</div><div>Content</div><div>Footer</div>
===
懒惰匹配结果 ===
元素 1: <div>Header</div>
元素 2: <div>Content</div>
元素 3: <div>Footer</div>
=== JSON值提取 ===
键: name, 值: John
键: age, 值: 30
键: city, 值: New York
```
### 关键解释：
1. **贪婪匹配问题**：
- 表达式 `<div>.*</div>` 会匹配第一个 `<div>` 到最后一个 `</div>` 之间的所有内容
- 结果：整个字符串被当作单个元素匹配
2. **
懒惰匹配解决方案**：
- 表达式 `<div>.*?</div>` 中的 `?` 使 `*` 变得"
懒惰"
- 它在遇到第一个 `</div>` 时就结束匹配
- 结果：正确匹配到三个独立的 `<div>` 元素
3. **JSON提取技巧**：
- `\"([^\"]*?)\"` 匹配双引号内的内容（`[^\"]` 避免匹配转义引号）
-
懒惰匹配确保只捕获单个键或值，而不是整个JSON
### 实际应用场景：
1. **HTML/XML解析**：
```java
// 提取所有HTML标签内容
Pattern.compile("<([a-z][a-z0-9]*)[^>]*?>(.*?)</\\1>");
```
2. **日志分析**：
```java
// 提取日志中的时间戳和消息
String log = "[ERROR 2023-10-15 08:30] Connection timeout";
Pattern.compile("\\[(.*?)\\](.*?)$");
```
3. **CSV数据处理**：
```java
// 处理带逗号的字段（使用
懒惰匹配避免跨字段匹配）
String csv = "1,\"Apple, Inc\",500";
Pattern.compile("\"(.*?)\"|([^,]+)");
```
4. **模板引擎**：
```java
// 提取模板变量 {{variable}}
String template = "Hello {{name}}, your balance is {{amount}}";
Pattern.compile("\\{\\{(.*?)\\}\\}");
```
### 性能注意事项：
1. **回溯问题**：
-
懒惰匹配可能导致更多回溯操作
- 复杂表达式在长文本中可能性能较差
2. **优化建议**：
```java
// 使用更精确的字符类减少回溯
Pattern.compile("<div>[^<]*?</div>"); // 优于<div>.*?</div>
```
3. **独占量词**：
- Java 13+ 支持独占量词 `*+`, `++`, `?+`, `{n,m}+`
- 减少回溯但不会回退，匹配失败时更快失败
---
扫一扫
540
被折叠的 条评论
为什么被折叠?
到【灌水乐园】发言
