Java正则表达式使用教程

学习知识要善于思考，思考，再思考！今天golang学习网小编就给大家带来《Java正则表达式匹配字符串教程》，以下内容主要包含等知识点，如果你正在学习或准备学习文章，就都不要错过本文啦~让我们一起来看看吧，能帮助到你就更好了！

在Java中使用正则表达式需先通过Pattern.compile()编译正则字符串生成Pattern对象，再调用其matcher()方法结合目标字符串创建Matcher对象；2. Matcher对象通过find()查找子串匹配、matches()判断全串匹配、group()获取匹配内容、start()/end()获取匹配位置；3. 常用元字符包括.（任意单字符）、*（零或多次）、+（一次或多次）、?（零或一次）、[]（字符集）、()（捕获组）、|（或）、\d（数字）、\s（空白符）、\b（单词边界）、^/$（行首/尾）等；4. 字符串替换可通过String.replaceAll()/replaceFirst()或Matcher的同名方法实现，复杂替换可结合appendReplacement()和appendTail()动态处理；5. 实际应用包括数据校验（如邮箱、手机号）、数据提取（如日志解析）、文本格式化、搜索高亮和URL路由匹配，但应避免用于解析复杂嵌套结构。

在Java中，要使用正则表达式匹配字符串，核心在于运用java.util.regex包中的Pattern和Matcher这两个类。Pattern负责编译你的正则表达式，把它变成一个可以被计算机理解和高效执行的“模板”；而Matcher则是真正拿着这个模板，去目标字符串里“比对”和“查找”的工具。简单来说，就是“先定义规则，再用规则去检查”。

解决方案

说实话，Java里处理正则表达式，我个人觉得设计得还是挺清晰的。你不会像在某些脚本语言里那样，直接一个方法搞定所有，而是分成了编译模式和执行匹配两个步骤。这虽然初看有点啰嗦，但对于复杂的模式复用和性能优化来说，其实是很有意义的。

首先，你需要用Pattern.compile()方法来编译你的正则表达式字符串。这个步骤很重要，因为它会把你的文本模式转换成一个内部的、高效的表示形式。

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

public class RegexExample {
    public static void main(String[] args) {
        // 步骤1：定义你的正则表达式
        String regex = "\\bJava\\b"; // 匹配独立的单词"Java"

        // 步骤2：编译正则表达式，生成Pattern对象
        Pattern pattern = Pattern.compile(regex);

        // 步骤3：创建Matcher对象，将Pattern应用到目标字符串上
        String text1 = "Hello Java World";
        String text2 = "JavaScript is not Java";
        String text3 = "I love programming in Java.";

        Matcher matcher1 = pattern.matcher(text1);
        Matcher matcher2 = pattern.matcher(text2);
        Matcher matcher3 = pattern.matcher(text3);

        // 步骤4：使用Matcher对象进行匹配操作

        // 示例1：查找是否存在匹配项
        System.out.println("Text 1 contains 'Java': " + matcher1.find()); // true

        // 示例2：判断整个字符串是否完全匹配
        // 注意：matcher.matches() 尝试匹配整个区域，而不仅仅是找到子序列
        Pattern digitPattern = Pattern.compile("\\d+");
        Matcher digitMatcher = digitPattern.matcher("12345");
        System.out.println("String '12345' is all digits: " + digitMatcher.matches()); // true

        Matcher partialDigitMatcher = digitPattern.matcher("abc123def");
        System.out.println("String 'abc123def' is all digits: " + partialDigitMatcher.matches()); // false (因为'abc'和'def'不匹配)

        // 示例3：迭代查找所有匹配项
        System.out.println("\nFinding all 'Java' instances:");
        while (matcher3.find()) {
            System.out.println("Found at index " + matcher3.start() + " to " + matcher3.end() + ": " + matcher3.group());
        }
        // Output: Found at index 23 to 27: Java
    }
}

这里面有几个关键点：

• Pattern.compile(regex)：这是你所有正则操作的起点。它返回一个Pattern对象，这个对象是线程安全的，所以你可以把它缓存起来，重复使用。
• pattern.matcher(text)：每次你想在新的字符串上应用同一个模式时，就创建一个新的Matcher对象。Matcher不是线程安全的，因为它的内部状态会随着匹配操作而改变。
• matcher.find()：这是最常用的方法之一，它尝试在目标字符串中查找下一个匹配的子序列。如果找到了，它返回true，并且Matcher的内部指针会移动到匹配的末尾之后。
• matcher.matches()：这个方法会尝试匹配整个输入序列。如果整个字符串都符合正则表达式的规则，它才返回true。这和find()有很大区别，find()只需要找到一个符合的子串即可。
• matcher.group()：在find()或matches()成功后，你可以用group()方法来获取实际匹配到的文本。如果你在正则表达式中使用了捕获组（用括号()定义），你还可以用group(int group)来获取特定组的内容。
• matcher.start()和matcher.end()：分别返回当前匹配子序列的起始索引和结束索引（不包含）。

Java中常用的正则表达式元字符有哪些？

要写好正则表达式，理解这些“魔法符号”是基础。它们是构建复杂匹配模式的基石，就像字母表一样。有时候，我发现很多人对这些符号的理解不够深入，导致写出来的正则要么过于宽泛，要么匹配不到预期的内容。

这里列举一些你几乎每天都会用到的元字符：

• . (点)：匹配除换行符\n、回车符\r之外的任何单个字符。
• * (星号)：匹配前面的子表达式零次或多次。比如a*可以匹配"", a, aa, aaa。
• + (加号)：匹配前面的子表达式一次或多次。比如a+可以匹配a, aa, aaa，但不能匹配""。
• ? (问号)：匹配前面的子表达式零次或一次。比如colou?r可以匹配color或colour。它也用于使量词变得“非贪婪”。
• [] (方括号)：字符集合。匹配方括号中任意一个字符。例如[abc]匹配a、b或c。
  • [a-z]：匹配任意小写字母。
  • [0-9]：匹配任意数字。
  • [^abc]：匹配除了a、b、c之外的任何字符。
• () (圆括号)：捕获组。将多个字符组合成一个子表达式，可以对这个组应用量词，也可以在匹配后提取这个组的内容。
• | (竖线)：逻辑或。匹配|符号前或后的表达式。例如cat|dog匹配cat或dog。
• \ (反斜杠)：转义字符。如果你想匹配元字符本身，比如想匹配一个点.，你就需要用\.来转义。它也用于定义特殊字符序列。
  • \d：匹配任意数字（等同于[0-9]）。
  • \D：匹配任意非数字字符（等同于[^0-9]）。
  • \w：匹配任意字母、数字或下划线（等同于[a-zA-Z0-9_]）。
  • \W：匹配任意非字母、数字、下划线字符。
  • \s：匹配任意空白字符（空格、制表符、换行符等）。
  • \S：匹配任意非空白字符。
  • \b：单词边界。匹配一个单词的开始或结束。
  • \B：非单词边界。
• ^ (脱字号)：行的开头。匹配输入字符串的开始位置。在[]内表示否定。
• $ (美元符号)：行的结尾。匹配输入字符串的结束位置。

理解这些元字符的含义和用法，是掌握正则表达式的关键。有时候一个简单的转义符漏掉，就能让你调试半天。

如何在Java中进行字符串的查找与替换？

正则表达式的强大之处不仅仅在于查找，更在于它能以极其灵活的方式进行字符串的替换。在Java中，你可以通过String类的一些便捷方法来完成简单的替换，但如果需要更高级、更复杂的替换逻辑，Matcher类就显得不可或缺了。我个人在处理日志文件或者格式化输出时，经常会用到这些替换功能。

1. 使用String.replaceAll()和String.replaceFirst()

这是最直接、最方便的方式。String类提供了这两个方法，它们内部其实也是利用了正则表达式。

• replaceAll(String regex, String replacement)：用指定的替换字符串替换所有匹配正则表达式的子字符串。
• replaceFirst(String regex, String replacement)：只替换第一个匹配正则表达式的子字符串。

String originalText = "Java is great. I love Java programming.";
String replacedText1 = originalText.replaceAll("Java", "Python");
System.out.println("Replaced all: " + replacedText1); // Output: Python is great. I love Python programming.

String replacedText2 = originalText.replaceFirst("Java", "C++");
System.out.println("Replaced first: " + replacedText2); // Output: C++ is great. I love Java programming.

// 结合元字符
String numbers = "Order_123_Item_456_Price_789";
String cleanedNumbers = numbers.replaceAll("_\\d+", ""); // 移除所有 "_数字"
System.out.println("Cleaned numbers: " + cleanedNumbers); // Output: OrderItemPrice

需要注意的是，replaceAll和replaceFirst的第一个参数是正则表达式，所以如果你想替换的字符串本身包含正则表达式的元字符，你需要对它们进行转义。例如，要替换所有的点.，你需要写"\\."。

2. 使用Matcher.replaceAll()和Matcher.replaceFirst()

Matcher类也提供了同名的方法，但它们与String类的方法在底层处理上有所不同，并且可以与Pattern对象结合，实现更灵活的替换。

Pattern p = Pattern.compile("Java");
Matcher m = p.matcher("Java is great. I love Java programming.");

String result = m.replaceAll("Go");
System.out.println("Matcher replace all: " + result); // Output: Go is great. I love Go programming.

m.reset(); // 重置Matcher状态，以便再次使用
String result2 = m.replaceFirst("Kotlin");
System.out.println("Matcher replace first: " + result2); // Output: Kotlin is great. I love Java programming.

3. 使用Matcher.appendReplacement()和Matcher.appendTail()进行复杂替换

这组方法提供了最精细的控制，允许你在替换过程中加入复杂的逻辑。这对于需要根据匹配到的内容动态生成替换字符串的场景非常有用。我遇到过需要根据匹配到的日期格式进行转换，或者根据某个ID去数据库查名字再替换回来，这时候appendReplacement就派上用场了。

Pattern p2 = Pattern.compile("(\\d{4})-(\\d{2})-(\\d{2})"); // 匹配 YYYY-MM-DD 格式
String textWithDates = "Meeting on 2023-10-26, project deadline 2024-01-15.";
Matcher m2 = p2.matcher(textWithDates);
StringBuffer sb = new StringBuffer();

while (m2.find()) {
    String year = m2.group(1);
    String month = m2.group(2);
    String day = m2.group(3);
    // 动态生成新的日期格式：DD/MM/YYYY
    String replacement = day + "/" + month + "/" + year;
    // appendReplacement 将匹配到的内容之前的字符串以及替换后的内容追加到StringBuffer中
    m2.appendReplacement(sb, replacement);
}
// appendTail 将最后一次匹配之后到字符串末尾的内容追加到StringBuffer中
m2.appendTail(sb);

System.out.println("Transformed dates: " + sb.toString());
// Output: Transformed dates: Meeting on 26/10/2023, project deadline 15/01/2024.

这种方式虽然代码量稍大，但它提供了无与伦比的灵活性，让你能够完全控制替换的逻辑。

Java正则表达式在实际开发中有什么应用场景？

正则表达式不仅仅是字符串匹配的工具，它更像是一把“瑞士军刀”，在各种文本处理场景中都能发挥巨大作用。在我的日常开发中，从简单的输入校验到复杂的数据解析，几乎总能找到它的身影。

• 数据校验（Validation） 这是最常见也是最基础的应用。比如，验证用户输入的邮箱地址格式、电话号码、身份证号、邮政编码，或者确保密码的复杂性（包含大小写字母、数字、特殊字符等）。

  // 邮箱格式校验 (简化版)
  String emailRegex = "^[a-zA-Z0-9._%+-]+@[a-zA-Z0-9.-]+\\.[a-zA-Z]{2,6}$";
  System.out.println("is valid email 'test@example.com': " + "test@example.com".matches(emailRegex)); // true
  System.out.println("is valid email 'invalid-email': " + "invalid-email".matches(emailRegex)); // false
  
  // 手机号码校验 (中国大陆，简化版)
  String phoneRegex = "^1[3-9]\\d{9}$";
  System.out.println("is valid phone '13812345678': " + "13812345678".matches(phoneRegex)); // true
  System.out.println("is valid phone '12345678901': " + "12345678901".matches(phoneRegex)); // false

  这类校验通常直接用String.matches()方法就足够了，因为它要求整个字符串都匹配。

• 数据提取（Data Extraction） 从非结构化或半结构化的文本中提取特定信息。这在处理日志文件、网页内容（简单的HTML解析，虽然不推荐用正则解析复杂HTML）、配置文件或者文本报告时非常有用。 想象一下，你需要从一大堆日志行中找出所有错误代码和对应的错误信息： [ERROR] 2023-10-26 10:30:15 - Code: E001, Message: Database connection failed.[INFO] 2023-10-26 10:31:00 - User login successful.[WARN] 2023-10-26 10:32:05 - Code: W102, Message: Low disk space.

  你可以用正则来捕获Code: XXX, Message: YYY这样的模式。

  Pattern logPattern = Pattern.compile("Code: (\\w+), Message: (.+)");
  String logLine = "[ERROR] 2023-10-26 10:30:15 - Code: E001, Message: Database connection failed.";
  Matcher logMatcher = logPattern.matcher(logLine);
  if (logMatcher.find()) {
      System.out.println("Error Code: " + logMatcher.group(1)); // E001
      System.out.println("Error Message: " + logMatcher.group(2)); // Database connection failed.
  }

• 文本替换与格式化（Text Replacement & Formatting） 前面已经详细介绍了替换功能，它的应用场景非常广泛。比如统一文本中的日期格式、清除文本中的HTML标签、或者对敏感信息进行脱敏处理（用星号替换部分字符）。

• 搜索与高亮（Search & Highlight） 在文本编辑器或搜索功能中，正则表达式可以用来查找所有匹配项，并对它们进行高亮显示。通过Matcher.start()和Matcher.end()获取匹配位置，然后进行UI渲染。

• URL路由匹配（URL Routing） 在一些Web框架中，虽然现代框架有更高级的路由机制，但底层或早期的简单路由可能会使用正则表达式来匹配请求的URL路径，从而分发到不同的处理逻辑。

正则表达式虽然强大，但也并非万能。对于复杂的嵌套结构（比如HTML或XML），过度依赖正则可能会导致难以维护和调试的“正则地狱”。但对于扁平化或规则性强的文本处理，它无疑是提升效率的一大利器。学好它，绝对是值得的。

今天关于《Java正则表达式使用教程》的内容介绍就到此结束，如果有什么疑问或者建议，可以在golang学习网公众号下多多回复交流；文中若有不正之处，也希望回复留言以告知！