java如何使用正则表达式匹配字符串 java正则应用的实用技巧教程-java教程-PHP中文网

Java中正则匹配需使用Pattern和Matcher类，先通过Pattern.compile()编译正则表达式，再用Matcher进行匹配操作。

java如何使用正则表达式匹配字符串 java正则应用的实用技巧教程

在Java里使用正则表达式匹配字符串，核心在于运用

java.util.regex

登录后复制

包里的

Pattern

登录后复制

和

Matcher

登录后复制

这两个类。

Pattern

登录后复制

负责把你的正则表达式编译成一个模式，而

Matcher

登录后复制

则用这个模式去对你给定的字符串进行匹配操作。简单来说，就是“先定义规则，再拿规则去检查”。

解决方案

说起Java里的正则表达式，我首先想到的就是

Pattern.compile()

登录后复制

和

Matcher

登录后复制

对象的各种方法。这套机制，在我看来，设计得挺巧妙的，把正则规则的编译和实际的匹配过程分开了，这样如果你的正则模式需要反复使用，就不用每次都重新编译，效率自然就上去了。

具体怎么用呢？

你得先定义你的正则表达式字符串。比如，你想找字符串里的数字：

"\d+"

登录后复制

。注意，Java字符串里反斜杠

登录后复制

本身是转义字符，所以如果你想表示正则里的

登录后复制

，就得写成

登录后复制

。这地方，我刚开始学的时候也踩过不少坑。

立即学习“Java免费学习笔记（深入）”；

接着，用

Pattern.compile()

登录后复制

方法把这个正则字符串编译成一个

Pattern

登录后复制

对象。

String regex = "\d+"; // 匹配一个或多个数字
Pattern pattern = Pattern.compile(regex);

登录后复制

然后，你需要一个

Matcher

登录后复制

对象，它会把你的

Pattern

登录后复制

和你要匹配的输入字符串关联起来。

String text = "我有123个苹果和45个香蕉。";
Matcher matcher = pattern.matcher(text);

登录后复制

现在，有了

Matcher

登录后复制

，你就可以开始匹配了。

Matcher

登录后复制

提供了几种常用的匹配方法：

```
matches()
```
登录后复制
：尝试将整个区域与模式进行匹配。如果整个输入字符串都符合你的正则表达式，它才返回
```
true
```
登录后复制
。
```
find()
```
登录后复制
：尝试查找与模式匹配的输入序列的下一个子序列。这个方法是循环查找的利器，每调用一次，它就尝试找到下一个匹配项。
```
group()
```
登录后复制
：返回由前一次匹配操作发现的匹配子序列。如果你用
```
find()
```
登录后复制
找到了一个匹配，就可以用
```
group()
```
登录后复制
把它取出来。

一个简单的例子，看看

find()

登录后复制

怎么用：

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class RegexDemo {
    public static void main(String[] args) {
        String text = "我有123个苹果和45个香蕉。";
        String regex = "\d+"; // 匹配一个或多个数字

        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(text);

        System.out.println("在文本中查找数字：");
        while (matcher.find()) {
            System.out.println("找到匹配: " + matcher.group() +
                               " (起始位置: " + matcher.start() +
                               ", 结束位置: " + matcher.end() + ")");
        }

        // 另一个例子：使用matches()
        String fullMatchText = "12345";
        String partialMatchText = "abc123def";
        Pattern digitPattern = Pattern.compile("\d+");

        System.out.println("
使用matches()方法：");
        System.out.println("'" + fullMatchText + "' 匹配 '\d+'? " + digitPattern.matcher(fullMatchText).matches()); // true
        System.out.println("'" + partialMatchText + "' 匹配 '\d+'? " + digitPattern.matcher(partialMatchText).matches()); // false (因为整个字符串不全是数字)
    }
}

登录后复制

可以看到，

find()

登录后复制

更适合从一段文本中“挖”出所有符合条件的片段，而

matches()

登录后复制

则更像是一种“全盘验证”。选择哪个，取决于你的具体需求。

掌握核心：Java正则匹配的起点与常用方法？

在Java里玩转正则，首先得明白

Pattern

登录后复制

和

Matcher

登录后复制

的生命周期和它们各自的职责。

Pattern

登录后复制

对象是线程安全的，因为它代表的是编译后的正则表达式规则，一旦编译完成就不会变。所以，一个

Pattern

登录后复制

实例可以被多个线程共享，或者被反复用来创建不同的

Matcher

登录后复制

对象。这对于性能来说非常重要，尤其是当你需要在循环里或者高并发场景下重复使用同一个正则模式时。

而

Matcher

登录后复制

对象则不是线程安全的，它维护着当前匹配的状态（比如上一次匹配到的位置、捕获组的内容等）。每次用

Pattern.matcher(CharSequence input)

登录后复制

创建一个新的

Matcher

登录后复制

实例时，它都是独立的，不会互相影响。

除了前面提到的

matches()

登录后复制

和

find()

登录后复制

，

Matcher

登录后复制

还有几个非常实用的方法，值得深入了解：

lookingAt()
登录后复制
: 这个方法有点意思，它尝试从输入序列的开头开始匹配。和
```
matches()
```
登录后复制
不同的是，
```
lookingAt()
```
登录后复制
不需要整个输入序列都匹配成功，只要输入序列的开头部分与模式匹配，它就返回
```
true
```
登录后复制
。这在处理特定格式的日志文件或协议头时可能很有用。
group(int group)
登录后复制
: 如果你的正则表达式里使用了括号
```
()
```
登录后复制
来创建捕获组（capturing group），那么
```
group(int)
```
登录后复制
就能让你获取到特定捕获组匹配到的内容。
```
group(0)
```
登录后复制
或者不带参数的
```
group()
```
登录后复制
返回的是整个匹配到的字符串。
groupCount()
登录后复制
: 返回此模式中的捕获组数量。
start()
登录后复制
/
end()
登录后复制
: 返回上一次匹配的起始索引和结束索引（不包含）。这对于定位匹配内容在原字符串中的位置非常有用。

举个例子，从一段文本中提取日期：

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class DateExtractor {
    public static void main(String[] args) {
        String logEntry = "INFO: User logged in on 2023-10-26 at 10:30:00. Another event on 2024-01-15.";
        // 匹配 YYYY-MM-DD 格式的日期，并捕获年、月、日
        String dateRegex = "(\d{4})-(\d{2})-(\d{2})";
        Pattern pattern = Pattern.compile(dateRegex);
        Matcher matcher = pattern.matcher(logEntry);

        while (matcher.find()) {
            System.out.println("找到日期: " + matcher.group(0)); // 整个匹配
            System.out.println("  年份: " + matcher.group(1));
            System.out.println("  月份: " + matcher.group(2));
            System.out.println("  日期: " + matcher.group(3));
            System.out.println("  匹配起始位置: " + matcher.start());
            System.out.println("  匹配结束位置: " + matcher.end());
            System.out.println("--------------------");
        }

        // lookingAt() 示例
        String sentence = "Hello World!";
        Pattern helloPattern = Pattern.compile("Hello");
        System.out.println("
使用lookingAt(): " + helloPattern.matcher(sentence).lookingAt()); // true
        Pattern worldPattern = Pattern.compile("World");
        System.out.println("使用lookingAt(): " + worldPattern.matcher(sentence).lookingAt()); // false (因为World不在开头)
    }
}

登录后复制

通过捕获组，我们能更精细地从匹配结果中提取出想要的数据片段，这在数据解析和处理中非常常见。

提升效率：Java正则表达式性能优化与常见陷阱？

正则虽然强大，但用不好也容易变成性能瓶颈。我个人在实践中总结了一些经验，希望能帮你避开一些坑。

性能优化策略：

预编译

Pattern

登录后复制

对象： 这是最最重要的一点。前面提到了，

Pattern.compile()

登录后复制

是一个相对耗时的操作。如果你在一个循环里或者一个方法中频繁地使用同一个正则表达式，请务必把

Pattern

登录后复制

对象定义在循环外部，或者作为类的静态常量。

// 推荐做法：预编译
private static final Pattern EMAIL_PATTERN = Pattern.compile("^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,6}$");

public boolean isValidEmail(String email) {
    return EMAIL_PATTERN.matcher(email).matches();
}

// 不推荐做法：每次都编译
public boolean isValidEmailBad(String email) {
    return Pattern.compile("^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,6}$").matcher(email).matches();
}

登录后复制

后者在大量调用时会造成显著的性能下降。

避免“灾难性回溯”（Catastrophic Backtracking）： 这是正则性能杀手。当一个正则表达式中包含嵌套的重复组，并且这些组可以匹配空字符串或者重叠匹配时，就可能发生。比如
```
"(a+)+"b
```
登录后复制
去匹配
```
"aaaaaaaaaaaaaaaaaaaaaaaaac"
```
登录后复制
。当
```
b
```
登录后复制
不匹配时，正则引擎会尝试各种组合来回溯，导致指数级的计算量。避免这种模式，或者使用原子组（atomic group，
```
?>
```
登录后复制
）来阻止回溯。
```
// 避免灾难性回溯的例子
// 比如匹配HTML标签，简单写成 <.*> 可能遇到问题
// <a href="http://example.com">Link</a> 这种没问题
// 但如果是 <a href="http://example.com" title="some <tag> content">Link</a> 就会有问题
// 贪婪匹配 .* 会一直匹配到最后一个 >
// 更好的做法是使用非贪婪匹配或排除特定字符
String badRegex = "<.*>"; // 贪婪匹配，可能导致回溯问题
String betterRegex = "<[^>]+>"; // 匹配 < 后跟一个或多个非 > 字符，再跟 >
String nonGreedyRegex = "<.*?>"; // 非贪婪匹配
```
登录后复制
通常，用
```
[^...]
```
登录后复制
来排除不希望匹配的字符，比用
```
.*
```
登录后复制
然后指望非贪婪模式要更高效。

Grammarly
Grammarly是一款在线语法纠正和校对工具，伟大的AI辅助写作工具

253

查看详情

使用

Matcher.reset()

登录后复制

重用
Matcher
登录后复制
对象：如果你需要在不同的输入字符串上应用同一个

Pattern

登录后复制

，可以重用

Matcher

登录后复制

对象。

Pattern p = Pattern.compile("\d+");
Matcher m = p.matcher(""); // 初始化一个空的Matcher

String[] texts = {"abc123def", "xyz456uvw"};
for (String text : texts) {
    m.reset(text); // 重置Matcher的输入字符串
    while (m.find()) {
        System.out.println("找到: " + m.group());
    }
}

登录后复制

这比每次循环都创建一个新的

Matcher

登录后复制

要快一点点。

常见陷阱：

Java字符串中的反斜杠转义： 前面提过了，
登录后复制
在Java字符串里是个特殊字符。所以，如果你想在正则表达式里匹配一个字面量反斜杠，你需要写成
```
"\\"
```
登录后复制
。匹配点号
```
.
```
登录后复制
要写成
```
"\."
```
登录后复制
，匹配括号
```
(
```
登录后复制
要写成
```
"\("
```
登录后复制
。这个错误非常常见。
```
matches()
```
登录后复制
与
find()
登录后复制
的区别：再次强调，
```
matches()
```
登录后复制
要求整个输入字符串都匹配模式，而
```
find()
```
登录后复制
是查找字符串中是否存在匹配模式的子序列。很多人初学时会混淆，导致匹配结果不如预期。

贪婪（Greedy）与非贪婪（Reluctant）模式： 默认情况下，量词（

登录后复制

{n,m}

登录后复制

）是贪婪的，它们会尽可能多地匹配字符。如果你想让它们尽可能少地匹配，需要在量词后面加上

登录后复制

，变成非贪婪模式（如

*?

登录后复制

+?

登录后复制

）。

String html = "<div><span>Hello</span><span>World</span></div>";
Pattern greedyPattern = Pattern.compile("<span>.*</span>");
Matcher greedyMatcher = greedyPattern.matcher(html);
if (greedyMatcher.find()) {
    System.out.println("贪婪匹配: " + greedyMatcher.group()); // 匹配到整个 "<span>Hello</span><span>World</span>"
}

Pattern reluctantPattern = Pattern.compile("<span>.*?</span>");
Matcher reluctantMatcher = reluctantPattern.matcher(html);
while (reluctantMatcher.find()) {
    System.out.println("非贪婪匹配: " + reluctantMatcher.group()); // 分别匹配 "<span>Hello</span>" 和 "<span>World</span>"
}

登录后复制

理解这个差异对正确提取数据至关重要。

进阶应用：Java正则在数据清洗与提取中的实战？

正则表达式在数据清洗、日志分析、文本解析等领域简直是利器。它能帮你快速地从一堆混乱的数据中抓取出你想要的信息，或者替换掉不规范的内容。

数据提取：

最常见的莫过于从日志、HTML/XML片段、或者其他非结构化文本中提取特定数据。结合

find()

登录后复制

循环和

group()

登录后复制

方法，可以非常灵活地实现。

例如，从一个多行文本中提取所有URL：

import java.util.regex.Matcher;
import java.util.regex.Pattern;
import java.util.ArrayList;
import java.util.List;

public class URLExtractor {
    public static void main(String[] args) {
        String multiLineText = """
                Visit our website at https://www.example.com for more info.
                You can also check out our blog: http://blog.example.org/latest.
                Or our old site: ftp://old.example.net/files.txt
                """;

        // 一个相对通用的URL匹配模式
        String urlRegex = "(https?|ftp)://[^\s/$.?#].[^\s]*";
        Pattern pattern = Pattern.compile(urlRegex);
        Matcher matcher = pattern.matcher(multiLineText);

        List<String> urls = new ArrayList<>();
        while (matcher.find()) {
            urls.add(matcher.group());
        }

        System.out.println("提取到的URLs:");
        urls.forEach(System.out::println);
    }
}

登录后复制

这个URL正则只是一个简化版，实际应用中可能需要更复杂的模式来覆盖各种URL格式。

数据替换：

Matcher

登录后复制

类提供了

replaceAll()

登录后复制

和

replaceFirst()

登录后复制

方法，可以将匹配到的子序列替换为指定的内容。这在清洗数据、格式化文本时非常方便。

例如，把文本中的所有手机号码替换成星号：

import java.util.regex.Matcher;
import java.util.regex.Pattern;

public class PhoneMasker {
    public static void main(String[] args) {
        String originalText = "联系我：13812345678 或 13987654321，座机010-88889999。";
        // 匹配中国大陆手机号码（简化版）
        String phoneRegex = "(1[3-9]\d{9})";
        Pattern pattern = Pattern.compile(phoneRegex);
        Matcher matcher = pattern.matcher(originalText);

        // 将匹配到的手机号替换为星号
        String maskedText = matcher.replaceAll("***********");
        System.out.println("替换后的文本:
" + maskedText);

        // 另一个例子：替换第一个匹配
        String textWithEmails = "My email is user@example.com, and my secondary is test@domain.org.";
        Pattern emailPattern = Pattern.compile("[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\.[a-zA-Z]{2,6}");
        Matcher emailMatcher = emailPattern.matcher(textWithEmails);
        String firstEmailMasked = emailMatcher.replaceFirst("[MASKED_EMAIL]");
        System.out.println("替换第一个邮件后的文本:
" + firstEmailMasked);
    }
}

登录后复制

字符串分割：

Pattern

登录后复制

类还有一个

split()

登录后复制

方法，可以根据正则表达式来分割字符串，这在处理分隔符不固定或者需要更复杂分割逻辑的场景下非常有用。

import java.util.regex.Pattern;

public class RegexSplitter {
    public static void main(String[] args) {
        String data = "apple, banana; orange	grape";
        // 以逗号、分号或制表符作为分隔符
        Pattern pattern = Pattern.compile("[,;\t]");
        String[] parts = pattern.split(data);

        System.out.println("分割后的部分:");
        for (String part : parts) {
            System.out.println("- " + part.trim()); // trim() 去除可能存在的空格
        }

        // 限制分割次数
        String limitedSplitData = "one:two:three:four";
        Pattern colonPattern = Pattern.compile(":");
        String[] limitedParts = colonPattern.split(limitedSplitData, 3); // 最多分割成3部分

        System.out.println("
限制分割次数后的部分:");
        for (String part : limitedParts) {
            System.out.println("- " + part);
        }
    }
}

登录后复制