一般来说，贪婪量词是最常用的，勉强量词用于需要最小匹配的情况（如解析HTML/XML标签），而独占量词则在确定不需要回溯且追求性能时使用。

2.4. 位置匹配 (锚点)

位置匹配符（或称锚点）不匹配具体的字符，而是匹配一个位置。

• ^: 匹配输入字符串的开头。如果启用 MULTILINE 标志（或称 m 模式），则匹配每行的开头。
  • 示例：^abc 只匹配以 “abc” 开头的字符串，如 “abcdef”。
• $: 匹配输入字符串的结尾。如果启用 MULTILINE 标志，则匹配每行的结尾。
  • 示例：xyz$ 只匹配以 “xyz” 结尾的字符串，如 “uvwxyz”。
• \b: 匹配一个词的边界。词边界是指一个单词字符 (\w) 和一个非单词字符 (\W) 之间的位置，或者是字符串的开头/结尾与一个单词字符之间的位置。
  • 示例：\bcat\b 可以匹配字符串 “the cat sat” 中的 “cat”，但不能匹配 “catalog” 或 “concatenate” 中的 “cat”。
• \B: 匹配一个非词边界的位置。
  • 示例：\Bcat\B 可以匹配 “conccatenate” 中的 “cat”，但不能匹配 “the cat sat”。

2.5. 分组与捕获

圆括号 () 用于将多个字符组合成一个单元，可以对其应用量词，或者将其作为一个捕获组来提取匹配的子字符串。

• (): 创建一个捕获组。匹配的内容会被”捕获”供后续使用。捕获组从 1 开始编号（组 0 始终代表整个匹配的文本）。
  • 示例：(\d{3})-(\d{4}) 可以匹配 “123-4567″。第一个捕获组 ((\d{3})) 捕获 “123”，第二个捕获组 ((\d{4})) 捕获 “4567”。
• (?:...): 创建一个非捕获组。它用于分组以便应用量词或进行逻辑分组，但匹配的内容不会被捕获。这有助于提高性能，特别是当您只需要分组而不需要提取匹配内容时。
  • 示例：(?:abc)+ 匹配一个或多个连续的 “abc” 序列，如 “abc”, “abcabc” 等，但不捕获 “abc” 子串。

2.6. 选择 (或)

管道符 | 用于表示“或”的关系，匹配其左边或右边的模式。

• cat|dog: 匹配 “cat” 或 “dog”。
• (cat|dog) food: 匹配 “cat food” 或 “dog food”。注意分组的使用，以确保 | 只应用于 “cat” 和 “dog”。

2.7. 反向引用

反向引用 (\n，其中 n 是一个数字) 引用前面第 n 个捕获组匹配到的内容。

• 示例：(\w)\1 匹配任意两个连续相同的单词字符，如 “aa”, “bb”, “cc” 等。(\w+)\s+\1 匹配一个单词，后跟一个或多个空白字符，再后跟与第一个单词完全相同的单词，如 “java java”。

3. Java 中 Pattern 和 Matcher 的使用

了解了基本语法后，我们来看看如何在 Java 代码中使用它们。

3.1. 编译正则表达式

首先，您需要使用 Pattern.compile() 方法编译正则表达式字符串，生成一个 Pattern 对象。

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

// 要匹配的正则表达式
String regex = “a.*b”;

// 编译正则表达式
Pattern pattern = Pattern.compile(regex);
“`

编译过程会检查正则表达式的语法是否正确。如果语法错误，会抛出 PatternSyntaxException。

3.2. 创建匹配器

接下来，使用 Pattern 对象的 matcher() 方法，传入要进行匹配的输入字符串，生成一个 Matcher 对象。

“`java
// 要进行匹配的输入字符串
String input = “acccb”;

// 创建匹配器对象
Matcher matcher = pattern.matcher(input);
“`

Matcher 对象包含了匹配操作所需的所有信息：编译后的模式、输入字符串以及匹配状态。

3.3. 执行匹配操作

Matcher 类提供了多种方法来执行不同类型的匹配操作：

• boolean matches(): 尝试将整个输入序列与模式进行匹配。只有当整个输入字符串都符合正则表达式时才返回 true。
  “`java
  String input1 = “acccb”;
  String input2 = “acccbx”;
  String input3 = “xacccb”;

  Pattern p = Pattern.compile(“a.*b”);
  Matcher m1 = p.matcher(input1);
  Matcher m2 = p.matcher(input2);
  Matcher m3 = p.matcher(input3);

  System.out.println(input1 + ” matches: ” + m1.matches()); // true
  System.out.println(input2 + ” matches: ” + m2.matches()); // false (因为后面多了一个x)
  System.out.println(input3 + ” matches: ” + m3.matches()); // false (因为前面多了一个x)
  * `boolean find()`: 尝试查找输入序列中与模式匹配的**下一个**子序列。这个方法可以重复调用，每次调用都会从上次匹配结束的位置继续查找。java
  String input = “This is a test. The first match is test, the second is Test.”;
  Pattern p = Pattern.compile(“[Tt]est”); // 匹配 test 或 Test
  Matcher m = p.matcher(input);

  System.out.println(“Finding matches:”);
  while (m.find()) {
  // 打印找到的匹配项和它的起始/结束位置
  System.out.println(“Found \”” + m.group() + “\” at positions ” +
  m.start() + “-” + m.end());
  }
  // Output:
  // Finding matches:
  // Found “test” at positions 10-14
  // Found “Test” at positions 40-44
  * `boolean lookingAt()`: 尝试将输入序列从**开头**与模式进行匹配。与 `matches()` 不同，`lookingAt()` 即使模式只匹配了输入字符串的一部分开头也返回 `true`。java
  String input1 = “HelloWorld”;
  String input2 = “Hello Java”;
  String input3 = “Java World”;

  Pattern p = Pattern.compile(“Hello”);
  Matcher m1 = p.matcher(input1);
  Matcher m2 = p.matcher(input2);
  Matcher m3 = p.matcher(input3);

  System.out.println(input1 + ” lookingAt: ” + m1.lookingAt()); // true
  System.out.println(input2 + ” lookingAt: ” + m2.lookingAt()); // true
  System.out.println(input3 + ” lookingAt: ” + m3.lookingAt()); // false
  “`

3.4. 获取匹配结果

当 find()、matches() 或 lookingAt() 返回 true 时，表示找到了匹配项。您可以使用 Matcher 的方法来获取匹配到的子字符串或子组的信息：

• String group() 或 String group(0): 返回最近一次匹配到的整个子字符串。
• String group(int group): 返回最近一次匹配中指定捕获组捕获的子字符串。组号从 1 开始。
• int groupCount(): 返回此模式中的捕获组数量（不包括组 0）。
• int start(): 返回最近一次匹配到的整个子字符串的起始索引（包含）。
• int start(int group): 返回最近一次匹配中指定捕获组的起始索引。
• int end(): 返回最近一次匹配到的整个子字符串的结束索引（不包含）。
• int end(int group): 返回最近一次匹配中指定捕获组的结束索引。

“`java
String input = “Order number is 12345, customer ID is 67890.”;
// 匹配 “number is ” 后面跟着5个数字，并捕获这5个数字
Pattern p = Pattern.compile(“number is (\d{5})”);
Matcher m = p.matcher(input);

if (m.find()) {
System.out.println(“Entire match: ” + m.group(0)); // Order number is 12345
System.out.println(“Order number: ” + m.group(1)); // 12345
System.out.println(“Start index of match: ” + m.start()); // 13
System.out.println(“End index of match: ” + m.end()); // 29
System.out.println(“Number of groups: ” + m.groupCount()); // 1
System.out.println(“Start index of group 1: ” + m.start(1)); // 24
System.out.println(“End index of group 1: ” + m.end(1)); // 29
}
“`

3.5. 替换文本

Matcher 类提供了方便的替换方法：

• String replaceAll(String replacement): 将输入字符串中所有匹配到的子字符串替换为指定的替换字符串。替换字符串可以使用 $n 来引用捕获组的内容（$1 引用第一个捕获组，$2 引用第二个，等等）。
• String replaceFirst(String replacement): 将输入字符串中第一个匹配到的子字符串替换为指定的替换字符串。

“`java
String input = “Hello World, Hello Java!”;
Pattern p = Pattern.compile(“Hello”);

String output1 = p.matcher(input).replaceAll(“Hi”);
System.out.println(output1); // Hi World, Hi Java!

String output2 = p.matcher(input).replaceFirst(“Greetings”);
System.out.println(output2); // Greetings World, Hello Java!

// 使用捕获组进行替换
String input3 = “Name: John Doe, Phone: 123-456-7890”;
// 找到电话号码，并将其格式化为 (XXX) XXX-XXXX
Pattern p3 = Pattern.compile(“(\d{3})-(\d{3})-(\d{4})”);
String output3 = p3.matcher(input3).replaceAll(“($1) $2-$3”);
System.out.println(output3); // Name: John Doe, Phone: (123) 456-7890
“`

对于更复杂的替换逻辑（例如，替换内容依赖于匹配到的具体文本，或者需要对匹配到的文本进行一些计算后再替换），可以使用 appendReplacement() 和 appendTail() 方法：

“`java
String input = “Price: $10, Discount: $2”;
Pattern p = Pattern.compile(“\$(\d+)”); // 匹配 $ 后面的数字并捕获
Matcher m = p.matcher(input);
StringBuffer sb = new StringBuffer(); // 用于构建新的字符串

while (m.find()) {
int price = Integer.parseInt(m.group(1)); // 获取捕获的数字并转换为整数
int discountedPrice = price – 1; // 简单的计算
// 将匹配之前的内容和计算后的新内容添加到 sb
// m.appendReplacement(sb, “¥” + discountedPrice); // 替换为 ¥ + 折扣价
// 注意：替换字符串中的 $ 或 \ 需要进行转义，使用 Matcher.quoteReplacement() 是一种安全的方法
m.appendReplacement(sb, Matcher.quoteReplacement(“¥” + discountedPrice)); // 安全替换
}
// 将输入字符串中最后一次匹配之后的部分添加到 sb
m.appendTail(sb);

System.out.println(sb.toString()); // Price: ¥9, Discount: ¥1
``appendReplacement(StringBuffer sb, String replacement)方法的作用是：
1. 将当前匹配之前（即从上次appendTail或appendReplacement结束位置到当前匹配开始位置）的输入字符串追加到StringBuffer中。
2. 将replacement字符串（其中可以使用$n引用捕获组）追加到StringBuffer` 中。
3. 更新匹配器内部的索引，指向当前匹配结束之后的位置。

appendTail(StringBuffer sb) 方法的作用是：将输入字符串中最后一次匹配结束之后的所有剩余部分追加到 StringBuffer 中。

这组方法通常在 while(m.find()) 循环中使用，提供了对替换过程更精细的控制。

3.6. 分割字符串

Java 的 String 类有一个方便的 split() 方法，它可以使用正则表达式作为分隔符。

“`java
String input = “apple,banana;orange:grape”;
// 使用逗号、分号或冒号作为分隔符
String[] fruits = input.split(“[,;:]”);

for (String fruit : fruits) {
System.out.println(fruit);
}
// Output:
// apple
// banana
// orange
// grape
“`

4. 正则表达式标志 (Flags)

在编译正则表达式时，可以指定一个或多个标志来改变匹配的行为。这些标志是 Pattern 类中的静态常量。您可以使用按位或 (|) 操作符来组合多个标志。

Pattern.compile(regex, flags)

常用标志：

• Pattern.CASE_INSENSITIVE (或 Pattern.I): 启用不区分大小写的匹配。
• Pattern.MULTILINE (或 Pattern.M): 在多行模式下，^ 和 $ 不仅匹配整个输入字符串的开始和结束，还匹配每一行的开始和结束（紧跟或紧前于换行符 \n 或回车符 \r 的位置）。
• Pattern.DOTALL (或 Pattern.S): 在 dotall 模式下，点号 . 匹配包括行终止符（换行符 \n）在内的任意字符。默认情况下，. 不匹配行终止符。
• Pattern.UNICODE_CHARACTER_CLASS (或 Pattern.U): 启用 Unicode 版本的预定义字符类（\d, \w, \s 等）和 POSIX 字符类（\p{Lower}, \p{Upper} 等）。这在处理非 ASCII 字符时非常有用。
• Pattern.COMMENTS (或 Pattern.X): 在模式中忽略空白和 # 后面的注释，直到行尾。这有助于编写更易读的复杂正则表达式。

“`java
String input = “Hello\nworld”;
// 默认模式，. 不匹配 \n
Pattern p1 = Pattern.compile(“.“);
Matcher m1 = p1.matcher(input);
if (m1.find()) System.out.println(“Default .: ” + m1.group()); // Hello

// Dotall 模式，. 匹配 \n
Pattern p2 = Pattern.compile(“.“, Pattern.DOTALL);
Matcher m2 = p2.matcher(input);
if (m2.find()) System.out.println(“DOTALL .: ” + m2.group()); // Hello\nworld

String input3 = “Line 1\nLine 2”;
// 多行模式，^ 匹配每行的开头
Pattern p3 = Pattern.compile(“^Line”, Pattern.MULTILINE);
Matcher m3 = p3.matcher(input3);
while (m3.find()) System.out.println(“MULTILINE ^Line: ” + m3.group());
// Output:
// MULTILINE ^Line: Line
// MULTILINE ^Line: Line
“`

标志也可以嵌入到正则表达式字符串的开头，使用 (?imsx) 这样的语法。例如，(?i)hello 表示不区分大小写匹配 “hello”。(?s).*(?-s).* 表示前半部分启用 dotall 模式，后半部分禁用。

5. Java 字符串中的反斜杠问题

这是 Java 中使用正则表达式最常见的困惑点之一。正则表达式本身使用反斜杠 \ 作为转义字符（例如，\. 匹配字面上的点，\d 匹配数字）。然而，Java 字符串字面量也使用反斜杠 \ 作为转义字符（例如，"\n" 表示换行，"\\" 表示字面上的反斜杠）。

因此，当您在 Java 字符串中表示一个正则表达式时，任何需要在正则表达式中转义的特殊字符，如果它是通过 \ 进行转义的，那么这个 \ 本身在 Java 字符串中也需要被转义。也就是说，Java 字符串中的 \\ 在正则表达式引擎看来才是一个字面意义上的 \。

• 要匹配字面上的点 .，正则表达式是 \.。在 Java 字符串中表示为 "\\."。
• 要匹配字面上的反斜杠 \，正则表达式是 \\。在 Java 字符串中表示为 "\\\\"。
• 要匹配一个数字 \d，正则表达式是 \d。在 Java 字符串中表示为 "\\d"。

示例:

“`java
// 匹配格式为 xxx.xxx.xxx.xxx 的 IP 地址 (简化版，不验证数字范围)
String ipRegex = “\d{1,3}\.\d{1,3}\.\d{1,3}\.\d{1,3}”;
// 在 Java 字符串中，. 变成了 \.，\d 变成了 \d

String input = “My IP is 192.168.1.100.”;
Pattern ipPattern = Pattern.compile(ipRegex);
Matcher ipMatcher = ipPattern.matcher(input);

if (ipMatcher.find()) {
System.out.println(“Found IP: ” + ipMatcher.group()); // Found IP: 192.168.1.100
}
“`

记住这个“双倍反斜杠”规则是使用 Java 正则表达式的关键。

6. 实际应用示例

示例 1：验证邮箱格式 (简化版)