Java路径-18-Java正则表达式

大家好，欢迎来到IT知识分享网。

1 基本概念

1. 正则表达式是什么？

正则表达式（Regular Expression），又称正规表示法，常简称为正则表达式、正则式或规则（Reading），其实是一种字符串匹配的工具，它可以用来描述字符序列的模式。

2. 正则表达式的作用

在 Java 中，正则表达式主要用于以下两个方面：

• 文本内容匹配：根据规则匹配指定的字符串。
• 文本内容替换：根据规则将指定字符串中符合条件的部分替换为新的内容。

3. 正则表达式的组成

正则表达式由两种基本字符类型组成：

• 原始字符（Literal Character）：包含在正则表达式中的普通字符，例如 a、1、$ 等。
• 元字符（Metacharacter）：用于描述原始字符的特殊字符，例如^、*、?等。

2 语法规则

2.1 原子表达式

原子指单个的、不可再分的匹配单元，原子表达式就是由原子组成的正则表达式。常见的原子有：

• 普通字符：包括字母、数字、汉字和一些符号等。
• 转义字符：用来表示正则表达式中的特殊字符，例如 \n 表示换行符。
• 字符类：匹配一组字符中的任意一个字符，用 [] 表示，例如 [abc] 匹配a、b 或c中的任意一个字符。
• 按位字符：与字符类类似，但是可以匹配多个字符，用[^abc]表示，表示除了a、b 和 c 以外的其他字符。
• 元字符：描述原子的性质和它在正则表达式中的作用。

2.2 元字符

元字符是正则表达式中最为重要和常用的部分，用于匹配单个字符或一组字符。其中常见的元字符如下：

（1）基本元字符

对应单个字符。

• .：匹配任意一个字符，除了换行符\n。
• \d：匹配一个数字，等价于 [0-9]。
• \D：匹配一个非数字，等价于[^0-9]。
• \w：匹配一个单词字符，即字母、数字或下划线，等价于 [a-zA-Z_0-9]。
• \W：匹配一个非单词字符，等价于[^a-zA-Z_0-9]。
• \s：匹配一个空白字符，包括空格、制表符、换行符等。
• \S：匹配一个非空白字符。

（2）量词元字符

用于描述字符的数量。

• *：匹配前面的字符出现 0 次或多次。
• +：匹配前面的字符至少出现一次。
• ?：匹配前面的字符出现 0 次或 1 次。
• {n}：匹配前面的字符恰好出现 n 次，其中 n 为一个非负整数。
• {n,}：匹配前面的字符至少出现 n 次。
• {n,m}：匹配前面的字符出现 n 到 m 次。

注意：使用*和+ 时，表达式会尽可能地去匹配所有符合条件的字符串。因此，可能会导致效率低下和执行时间过长的问题。如果确定匹配的字符串不会太长，可以使用贪婪模式（Greedy）来提高正则表达式的性能。例如，a._b 会匹配从a开始到b结束之间的所有内容，包括中间的换行符等；而a._?b 只会匹配第一个a 和第一个b之间的部分。

（3）分组元字符

用于将表达式中若干个子项组成一个整体。常用的分组元字符有：

• ()：将其中的内容作为一个整体，例如(ab)+ 表示ab出现一次或多次。
• (?:)：只匹配其中的内容，不保留在分组中，例如(?:ab)+表示匹配ab出现一次或多次，但是只保留ab这个字符串。

（4）限定符

用于限制某个元字符在正则表达式中出现的次数。常见的限定符有：

• ^：表示匹配输入字符串的开始位置，可以与 $ 一起使用来表示精确匹配。
• $：表示匹配输入字符串的结束位置，可以与 ^ 一起使用来表示精确匹配。
• \b：表示单词边界，例如 \bhello\b 匹配整个单词 hello，而不会匹配到包含该单词的其他单词。
• \B：表示非单词边界，例如 \Bhello\B 匹配包含该单词的其他单词，而不会匹配整个单词 hello

2.3 正则表达式语法

3 Matcher 和 Pattern类

3.1 Matcher 类

Matcher 类是一个抽象类，可以通过调用 Pattern 类的 matcher() 方法来获取 Matcher 对象。

常用方法如下：

• matches()：尝试将整个字符序列与正则表达式进行匹配，返回 true 或 false。
• find()：在字符串中查找下一个匹配的子串，找到返回 true，没找到返回 false。
• group()：返回匹配成功的子串。
• start()：返回匹配成功的子串的起始坐标。
• end()：返回匹配成功的子串的结束坐标。
• replaceAll()：将匹配成功的子串替换为新的字符串

import java.util.regex.Matcher; import java.util.regex.Pattern; public class MatcherDemo { public static void main(String[] args) { String str = "This is a test string"; // 创建 Pattern 对象 Pattern pattern = Pattern.compile("\\w+"); // 创建 Matcher 对象 Matcher matcher = pattern.matcher(str); int count = 0; while (matcher.find()) { System.out.println("Match " + (++count) + ": " + matcher.group()); System.out.println("Starting index: " + matcher.start()); System.out.println("Ending index: " + matcher.end()); } } }

上面的代码使用 Pattern 类和 Matcher 类来对字符串进行匹配，输出结果如下：

Match 1: This Starting index: 0 Ending index: 4 Match 2: is Starting index: 5 Ending index: 7 Match 3: a Starting index: 8 Ending index: 8 Match 4: test Starting index: 10 Ending index: 13 Match 5: string Starting index: 15 Ending index: 20

3.2 Pattern 类

Pattern 类提供了一些常见的正则表达式。

常用方法如下：

• compile()：将正则表达式编译为匹配器。
• matcher()：返回由Pattern.compile() 方法编译的 Matcher 对象。
• matches()：尝试将整个字符序列与正则表达式进行匹配，返回 true 或 false。
• split()：根据正则表达式匹配的位置分割字符串。
• replaceAll()：将匹配成功的子串替换为新的字符串。

代码示例：

import java.util.Arrays; import java.util.regex.Pattern; public class PatternDemo { public static void main(String[] args) { String str = "1,2;3,4,5"; // 使用逗号或分号分割字符串 Pattern pattern = Pattern.compile("[,;]"); String[] parts = pattern.split(str); System.out.println(Arrays.toString(parts)); // 将数字替换为 X String result = pattern.matcher(str).replaceAll("X"); System.out.println(result); } }

上面的代码使用 Pattern 类的 split() 和 replaceAll() 方法来对字符串进行操作，输出结果如下：

[1, 2, 3, 4, 5] X X X X X

3.3 常用方法

（1）public static Pattern compile(String regex)

说明：Pattern类的一个静态方法，用于将给定的正则表达式字符串编译为一个Pattern对象。这个方法通常用于将一个常见的正则表达式字符串编译成一个Pattern对象，以便后续的重复使用

Pattern pattern = Pattern.compile("a*b");

（2）public static Pattern compile(String regex, int flags)

说明：Pattern.compile(String regex, int flags)是Pattern类的一个静态方法，用于根据给定的正则表达式字符串和标志位来编译成一个Pattern对象。这个方法允许你在编译正则表达式时指定一些标志，以控制匹配的行为。

参数regex是要编译的正则表达式字符串，flags是一个整数，表示匹配的标志位。常用的标志位包括：

• Pattern.CASE_INSENSITIVE：忽略大小写进行匹配。
• Pattern.MULTILINE：多行模式，即^和$匹配每一行的开始和结束，而不是整个输入的开始和结束。
• Pattern.DOTALL：.可以匹配任意字符，包括换行符。
• Pattern.UNICODE_CASE：启用Unicode感知的大小写折叠。
• Pattern.UNIX_LINES：启用Unix换行模式，即只识别\n作为换行符。

使用这个重载的compile方法，可以更灵活地控制正则表达式的匹配行为。

//正则表达式"a*b"编译成一个Pattern对象，并指定了忽略大小写和多行模式的标志位。这样就可以在后续的匹配操作中，按照指定的标志位规则进行匹配 Pattern pattern = Pattern.compile("a*b", Pattern.CASE_INSENSITIVE | Pattern.MULTILINE);

（3）public static boolean matches(String regex, CharSequence input)

说明：Pattern.matches(String regex, CharSequence input) 是Pattern类的一个静态方法，用于判断给定的输入字符串是否完全匹配指定的正则表达式。

参数regex是要用来进行匹配的正则表达式字符串，参数 input 是要进行匹配的输入字符序列。

这个方法会尝试将整个输入序列与正则表达式进行匹配，如果整个输入字符串与正则表达式完全匹配，则返回 true；否则返回false。

boolean isMatch = Pattern.matches("a*b", "aaaab"); //运行结果： isMatch = true //上面的代码将会用正则表达式 "ab" 对字符串 "aaaab" 进行匹配，因为 "aaaab" 符合 "a" 的模式，所以 isMatch 会被赋值为 true

（4）public static String quote(String s)

说明：Pattern.quote(String s) 是 Pattern 类的一个静态方法，用于返回指定字符串的字面量模式字符串。这个方法可以将输入的字符串转换为字面量模式，以便在正则表达式中进行精确匹配。于正则表达式中可能包含特殊字符，如果需要在正则表达式中精确匹配一个字符串，就需要对字符串进行转义处理，这时可以使用quote方法来实现。

//我们希望匹配字符串 "(.)"，但是这个字符串包含了正则表达式中的特殊字符 "()" 和 "."，为了确保在正则表达式中能够精确匹配这个字符串，我们可以使用 quote 方法来转义这个字符串，得到的 regex 就是 \(\.\*\)，它可以在正则表达式中精确匹配原始的字符串 "(.*)"。 String input = "(.*)"; String regex = Pattern.quote(input);

（5）public String pattern()

说明：pattern() 方法是在 Pattern 类中的一个公共方法，它返回该正则表达式对象所表示的模式，你可以使用这个 Pattern 对象调用 pattern() 方法，以获取该正则表达式的字符串表示形式。

String regex = "ab+c"; Pattern pattern = Pattern.compile(regex); String patternString = pattern.pattern(); System.out.println(patternString); // 输出："ab+c"

（6）public Matcher matcher(CharSequence input)

说明：matcher(CharSequence input) 方法是在Pattern 类中的一个公共方法，它用于创建一个匹配器对象，并将指定的输入序列与正则表达式进行匹配。

在 Java 中，可以使用Pattern类的 matcher(CharSequence input) 方法来创建一个 Matcher 对象，该对象可以用于执行匹配操作。CharSequence 表示一个字符序列，可以是字符串或其他类型的字符序列。

String regex = "\\d+"; String input = "12345"; Pattern pattern = Pattern.compile(regex); Matcher matcher = pattern.matcher(input); boolean isMatch = matcher.matches(); System.out.println(isMatch); // 输出：true

我们首先定义了一个正则表达式字符串\\d+，表示匹配一个或多个数字。然后，我们定义了一个输入字符串 input，其值为“12345”。

接下来，我们使用Pattern.compile()方法编译正则表达式，并将返回的 Pattern 对象赋值给 pattern 变量。然后，我们使用pattern.matcher(input)方法创建一个Matcher对象，该对象用于对输入序列进行匹配。

最后，我们调用matcher.matches()方法来检查输入序列是否完全匹配正则表达式。如果匹配成功，则返回 true，否则返回false。在上述示例中，由于输入字符串“12345”完全匹配正则表达式 \\d+，所以输出结果为true。

因此，matcher(CharSequence input) 方法的作用是创建一个匹配器对象，并将指定的输入序列与正则表达式进行匹配。

（7）public Predicate<String> asPredicate()

说明：asPredicate() 方法是在 Pattern 类中的一个公共方法，它返回一个 Predicate<String> 对象，用于将正则表达式作为谓词进行匹配。

在 Java 中，Predicate 是一个函数接口，它接受一个输入参数并返回一个布尔值结果。Predicate<String> 表示该谓词接受一个字符串类型的输入参数。

String regex = "\\d+"; Pattern pattern = Pattern.compile(regex); Predicate<String> predicate = pattern.asPredicate(); System.out.println(predicate.test("123")); // 输出：true System.out.println(predicate.test("abc")); // 输出：false 

我们首先定义了一个正则表达式字符串\\d+，表示匹配一个或多个数字。然后，我们使用 Pattern.compile() 方法编译正则表达式，并将返回的Pattern对象赋给pattern变量。

接下来，我们调用pattern.asPredicate()方法，将正则表达式转换为一个Predicate<String>对象，并将其赋值给 predicate 变量。

最后，我们可以使用predicate.test(String input)方法来测试输入字符串是否与正则表达式匹配。如果匹配成功，则返回true，否则返回false。在上述示例中，由于输入字符串“123”符合正则表达式\\d+的模式，所以第一次输出结果为true；而输入字符串“abc”不符合该模式，所以第二次输出结果为false。

因此，asPredicate() 方法的作用是将正则表达式转换为一个Predicate<String>对象，用于对输入字符串进行匹配。

（8）public int flags()

说明：flags() 方法是在 Pattern 类中的一个公共方法，用于返回当前正则表达式模式的标志位（flags）。

在 Java 中，Pattern 类的正则表达式模式可以使用一些标志来修改其行为。这些标志可以通过在正则表达式字符串中添加特殊的标记来指定。

以下是一些常用的标志：

• CASE_INSENSITIVE：忽略大小写匹配。
• MULTILINE：启用多行模式，更改 ^ 和 $ 的行为。
• DOTALL：启用 dotall 模式，使 . 可以匹配任何字符，包括换行符。
• UNICODE_CASE：根据 Unicode 字符属性进行匹配和转换。
• CANON_EQ：启用规范等价匹配。

flags() 方法将返回一个整数值，表示当前正则表达式模式的标志位。该整数值是由上述标志的按位或组合而成。

String regex = "abc"; Pattern pattern = Pattern.compile(regex, Pattern.CASE_INSENSITIVE | Pattern.MULTILINE); int flags = pattern.flags(); System.out.println(flags); // 输出：2

我们首先定义了一个正则表达式字符串 “abc”，然后使用 Pattern.compile() 方法编译该正则表达式，并将 Pattern.CASE_INSENSITIVE | Pattern.MULTILINE 作为第二个参数传递给方法，这样我们同时启用了 CASE_INSENSITIVE 和 MULTILINE 两个标志。

接下来，我们调用 pattern.flags() 方法，返回一个整数值，表示当前正则表达式模式的标志位。

最后，我们打印出 flags 的值，它将输出 2，表示 CASE_INSENSITIVE 和 MULTILINE 两个标志被启用。

因此，flags() 方法的作用是返回当前正则表达式模式的标志位的整数值。

（9）public String[] split(CharSequence input)

说明：split(CharSequence input) 方法是在 Pattern 类中的一个公共方法，用于将输入序列根据正则表达式进行拆分，并返回拆分后的字符串数组

在 Java 中，可以使用 Pattern 类的 split(CharSequence input) 方法来将一个字符序列按照正则表达式进行拆分。CharSequence 表示一个字符序列，可以是字符串或其他类型的字符序列。

String regex = "\\s+"; String input = "Hello World Java"; Pattern pattern = Pattern.compile(regex); String[] parts = pattern.split(input); for (String part : parts) { System.out.println(part); } /* 运行结果： Hello World Java */

我们首先定义了一个正则表达式字符串\\s+，表示匹配一个或多个空格。然后，我们定义了一个输入字符串 input，其值为 “Hello World Java”，包含多个连续空格。

接下来，我们使用 Pattern.compile() 方法编译正则表达式，并将返回的 Pattern 对象赋给 pattern 变量。然后，我们调用 pattern.split(input) 方法，将输入字符串按照正则表达式进行拆分。拆分后的结果将存储在一个字符串数组 parts 中。

最后，我们使用一个循环遍历输出 parts 数组中的每个元素，以显示拆分后的结果

（10）public String[] split(CharSequence input, int limit)

说明：可以使用 Pattern 类的 split(CharSequence input, int limit) 方法来将一个字符序列按照正则表达式进行拆分，并限制拆分的数量。CharSequence 表示一个字符序列，可以是字符串或其他类型的字符序列，而 limit 参数表示拆分的最大数量

String regex = "\\s+"; String input = "Hello World Java"; Pattern pattern = Pattern.compile(regex); String[] parts = pattern.split(input, 2); for (String part : parts) { System.out.println(part); } /* 运行结果： Hello World Java */

我们首先定义了一个正则表达式字符串 \s+，表示匹配一个或多个空格。然后，我们定义了一个输入字符串 input，其值为 “Hello World Java”，包含多个连续空格。

接下来，我们使用 Pattern.compile() 方法编译正则表达式，并将返回的 Pattern 对象赋给 pattern 变量。然后，我们调用 pattern.split(input, 2) 方法，将输入字符串按照正则表达式进行拆分，并限制拆分的最大数量为 2。拆分后的结果将存储在一个字符串数组 parts 中。

最后，我们使用一个循环遍历输出 parts 数组中的每个元素，以显示拆分后的结果。

（11）public String[] split(CharSequence input, int limit)

说明：splitAsStream(final CharSequence input) 方法是在 Pattern 类中的一个公共方法，用于将输入序列根据正则表达式进行拆分，并返回一个 Stream<String> 流，在流中包含了拆分后的字符串元素。

可以使用 Pattern 类的 splitAsStream(final CharSequence input) 方法来将一个字符序列按照正则表达式进行拆分，并生成一个流对象，该流中包含了拆分后的字符串元素。

import java.util.regex.Pattern; import java.util.stream.Stream; public class Main { public static void main(String[] args) { String regex = "\\s+"; String input = "Hello World Java"; Pattern pattern = Pattern.compile(regex); Stream<String> stream = pattern.splitAsStream(input); stream.forEach(System.out::println); } } /* 运行结果： Hello World Java */

我们首先定义了一个正则表达式字符串\\s+，表示匹配一个或多个空格。然后，我们定义了一个输入字符串 input，其值为 “Hello World Java”，包含多个连续空格。

接下来，我们使用 Pattern.compile() 方法编译正则表达式，并将返回的 Pattern 对象赋给 pattern 变量。然后，我们调用 pattern.splitAsStream(input) 方法，将输入字符串按照正则表达式进行拆分，并生成一个Stream<String> 流对象，其中包含了拆分后的字符串元素。

最后，我们使用 forEach() 方法遍历流中的每个字符串元素，并打印输出。

（12）public static String quoteReplacement(String s)

说明：quoteReplacement(String s) 方法是在 Matcher 类中的一个静态方法，用于将输入字符串转义，以便在替换操作中使用。

在 Java 中，正则表达式的替换操作通常使用 Matcher 类的 replaceAll(String replacement) 或 replaceFirst(String replacement) 方法。当替换字符串中包含一些特殊字符（如 $、\ 等）时，为了正确处理这些字符，需要对替换字符串进行转义。

quoteReplacement(String s) 方法接受一个字符串参数 s，并返回一个转义后的字符串，该字符串可以安全地用作替换操作的替换字符串。

public class RegTest { public static void main(String[] args) { String input = "Hello $ World"; String replacement = Matcher.quoteReplacement("$1"); String result = input.replaceAll("\\#34;, replacement); System.out.println(replacement); //输出：\$1 System.out.println(result); // 输出：Hello $1 World } } /* 运行结果： \$1 Hello $1 World */

代码判断输入字符串 s 中是否包含\和 $ 字符，即(s.indexOf(‘\\’) == -1) && (s.indexOf(‘#39;) == -1)。如果不包含任何特殊字符，则直接返回原始字符串s。

如果输入字符串中包含了\或$字符，则进入循环处理。代码使用一个 StringBuilder 对象 sb 来构建转义后的字符串。通过遍历输入字符串的每个字符，将特殊字符\或$进行转义处理，并添加到 sb 中。

具体地，当遇到特殊字符时，代码使用 sb.append(‘\\’); 将一个反斜杠字符添加到 sb 中，以进行转义。然后，将当前字符 c 添加到 sb 中。

最后，循环结束后，代码通过 sb.toString() 方法将 StringBuilder 转换为字符串，并返回转义后的结果。

（13）public boolean find()

说明：find() 方法是在 Matcher 类中的一个公共方法，用于在输入字符串中查找与正则表达式模式匹配的下一个子序列

在 Java 中，Matcher 对象表示了对某个输入字符串进行正则表达式匹配的状态。find() 方法通过在输入字符串中寻找与模式匹配的下一个子序列，来进行匹配操作。

该方法返回一个布尔值，如果在输入字符串中找到了匹配的子序列，则返回 true，否则返回 false。

import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main { public static void main(String[] args) { String regex = "\\d+"; String input = "12345"; Pattern pattern = Pattern.compile(regex); Matcher matcher = pattern.matcher(input); if (matcher.find()) { System.out.println("Match found: " + matcher.group()); } else { System.out.println("No match found."); } } } /* 运行结果： Match found: 12345 */

我们使用之前提到的方式创建了一个 Matcher 对象，并调用 find() 方法进行匹配操作。

如果匹配成功（即在输入字符串中找到了匹配的子序列），则通过 matcher.group() 方法获取匹配的结果，并打印输出。否则，输出未找到匹配。

（14）public boolean find(int start)

说明：find(int start) 方法是在 Matcher 类中的一个公共方法，用于在输入字符串中从指定位置开始查找与正则表达式模式匹配的下一个子序列。

该方法接受一个整数参数 start，表示开始查找的位置索引。它会从指定位置开始在输入字符串中查找与正则表达式模式匹配的下一个子序列。

find(int start) 方法返回一个布尔值，如果在指定位置之后的输入字符串中找到了匹配的子序列，则返回 true，否则返回 false。

import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main { public static void main(String[] args) { String regex = "\\d+"; String input = "12345"; Pattern pattern = Pattern.compile(regex); Matcher matcher = pattern.matcher(input); int start = 2; // 从索引 2 开始查找 if (matcher.find(start)) { System.out.println("Match found: " + matcher.group()); } else { System.out.println("No match found."); } } } /* 运行结果： Match found: 345 */

我们使用之前提到的方式创建了一个 Matcher 对象，并定义了一个开始查找的位置索引 start。

然后，我们调用 find(int start) 方法并传入 start 参数来执行匹配操作。如果在指定位置之后的输入字符串中找到了匹配的子序列，则通过 matcher.group() 方法获取匹配的结果，并打印输出。否则，输出未找到匹配。

（15）public String group()

说明：group() 方法是在 Matcher 类中的一个公共方法，用于返回与最后一次匹配操作相匹配的字符串。

在执行匹配操作后，如果 find() 方法返回 true，则表示找到了匹配的子序列。此时，可以使用 group() 方法获取最后一次匹配操作所匹配的字符串。

group() 方法返回一个字符串，即最后一次匹配操作所匹配的子序列。

public class RegTest { public static void main(String[] args) { String regex = "\\d"; String input = "12345"; Pattern pattern = Pattern.compile(regex); Matcher matcher = pattern.matcher(input); while(matcher.find()){ System.out.println("Match found: " + matcher.group()); } } } /* 运行结果： Match found: 1 Match found: 2 Match found: 3 Match found: 4 Match found: 5 */

（16）public String group(int group)

说明：group(int group) 方法是在 Matcher 类中的一个公共方法，用于返回与最后一次匹配操作中指定组号相匹配的字符串。

在正则表达式中，使用圆括号 () 可以创建捕获组（Capture Group）。当进行匹配操作时，每个捕获组都有一个对应的组号，从 1 开始递增。group(int group) 方法接受一个整数参数 group，表示要获取的捕获组的组号。

group(int group) 方法返回一个字符串，即最后一次匹配操作中指定组号所匹配的子序列。

import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main { public static void main(String[] args) { String regex = "(\\d+)-(\\w+)"; String input = "12345-abcd"; Pattern pattern = Pattern.compile(regex); Matcher matcher = pattern.matcher(input); if (matcher.find()) { System.out.println("First group: " + matcher.group(1)); System.out.println("Second group: " + matcher.group(2)); } else { System.out.println("No match found."); } } } /* 运行结果： First group: 12345 Second group: abcd */

我们使用之前提到的方式创建了一个 Matcher 对象，并调用 find() 方法进行匹配操作。

如果匹配成功（即在输入字符串中找到了匹配的子序列），则通过 matcher.group(int group) 方法获取指定组号的匹配结果，并打印输出。这里分别获取了第一个捕获组和第二个捕获组的结果。不指定捕获组名称，默认捕获组从1开始递增编号

group(int group) 方法的作用是返回与最后一次匹配操作中指定组号相匹配的字符串。它可以用于获取指定组号的匹配结果并进行后续处理。注意，组号必须大于等于 1，且不能超过实际捕获组的数量，否则会抛出 IndexOutOfBoundsException 异常.

（17）public String group(String name)

说明：group(String name) 方法是在 Matcher 类中的一个公共方法，用于返回与最后一次匹配操作中指定命名组名相匹配的字符串。

在正则表达式中，可以使用命名捕获组（Named Capture Group）来标识和引用特定的子表达式。每个命名捕获组都有一个唯一的名称，可以通过该名称来引用对应的匹配结果。

group(String name) 方法接受一个字符串参数 name，表示要获取的命名捕获组的名称。

group(String name) 方法返回一个字符串，即最后一次匹配操作中指定命名组名所匹配的子序列。

import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main { public static void main(String[] args) { String regex = "(?<number>\\d+)-(?<word>\\w+)"; String input = "12345-abcd"; Pattern pattern = Pattern.compile(regex); Matcher matcher = pattern.matcher(input); if (matcher.find()) { System.out.println("Number group: " + matcher.group("number")); System.out.println("Word group: " + matcher.group("word")); } else { System.out.println("No match found."); } } } /* 运行结果: Number group: 12345 Word group: abcd */

我们使用之前提到的方式创建了一个 Matcher 对象，并调用 find() 方法进行匹配操作。

如果匹配成功（即在输入字符串中找到了匹配的子序列），则通过 matcher.group(String name) 方法获取指定命名组名的匹配结果，并打印输出。这里分别获取了名为 “number” 的命名捕获组和名为 “word” 的命名捕获组的结果。

group(String name) 方法的作用是返回与最后一次匹配操作中指定命名组名相匹配的字符串。它可以用于获取指定命名组名的匹配结果并进行后续处理。如果没有找到指定的命名组名，或者命名组名不合法，会抛出 IllegalArgumentException 异常.

（18）public boolean matches()

说明：matches() 方法是在 Matcher 类中的一个公共方法，用于尝试将整个输入序列与正则表达式进行匹配。

该方法会尝试将整个输入序列与正则表达式进行匹配，而不仅仅是寻找匹配的子序列。只有当整个输入序列完全匹配正则表达式时，matches() 方法才返回 true，否则返回 false。

public class RegTest { public static void main(String[] args) { String regex = "\\d\\d\\d"; String input = "12345"; Pattern pattern = Pattern.compile(regex); Matcher matcher = pattern.matcher(input); if (matcher.matches()) { System.out.println("Input matches the regular expression."); } else { System.out.println("Input does not match the regular expression."); } } } /* 运行结果： Input does not match the regular expression. */

因为上面的正则表达式无法完全匹配输入的12345，所以matches返回的false

（19）public Pattern pattern()

说明：pattern() 方法是在 Matcher 类中的一个公共方法，用于返回与当前 Matcher 对象关联的正则表达式模式。

正则表达式模式通过 Pattern 类的实例来表示。pattern() 方法返回的就是与当前 Matcher 对象关联的 Pattern 实例。

import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main { public static void main(String[] args) { String regex = "\\d+"; String input = "12345"; Pattern pattern = Pattern.compile(regex); Matcher matcher = pattern.matcher(input); Pattern associatedPattern = matcher.pattern(); System.out.println("Associated pattern: " + associatedPattern.pattern()); } } /* 运行结果： Associated pattern: \d+ */

我们首先创建了一个 Pattern 对象，用于表示正则表达式模式。然后，我们将该模式与输入字符串进行匹配操作，得到对应的 Matcher 对象。

接下来，我们调用 pattern() 方法获取与当前 Matcher 对象关联的正则表达式模式，并将其打印输出。

（20）public String replaceAll(String replacement)

说明：replaceAll(String replacement) 方法是在 Matcher 类中的一个公共方法，用于将匹配到的子序列替换为指定的字符串。

该方法会查找输入字符串中与正则表达式模式匹配的所有子序列，并将其替换为指定的字符串 replacement。

replaceAll(String replacement) 方法接受一个字符串参数 replacement，表示要替换匹配子序列的字符串。

replaceAll() 方法返回一个新的字符串，其中所有匹配的子序列都被替换为指定的字符串。

import java.util.regex.Matcher; import java.util.regex.Pattern; public class Main { public static void main(String[] args) { String regex = "\\d+"; String input = "Hello 123 World 456"; Pattern pattern = Pattern.compile(regex); Matcher matcher = pattern.matcher(input); String replacedString = matcher.replaceAll("X"); System.out.println("Replaced string: " + replacedString); } } /* 输出内容： Replaced string: Hello X World X */ 

们使用之前提到的方式创建了一个 Matcher 对象，并调用 replaceAll(String replacement) 方法进行替换操作。

该示例中，正则表达式模式\d+ 可以匹配连续的数字。我们将输入字符串中所有匹配到的数字替换为字符 “X”。

（21）public String replaceAll(Function<MatchResult, String> replacer) （java9/java1.9）

说明：String replaceAll(Function<MatchResult, String> replacer) 方法是在 Matcher 类中提供的一个功能，用于基于指定的模式替换字符串的部分内容。

它接受一个 函数式接口Function 参数 replacer，该参数用于确定每个匹配子串的替换值。replacer 函数接受一个 MatchResult 对象，表示当前的匹配结果，并返回替换后的字符串。

import java.util.function.Function; import java.util.regex.MatchResult; import java.util.regex.Matcher; import java.util.regex.Pattern; public class MatcherReplaceAllExample { public static void main(String[] args) { String text = "Hello, world! How are you?"; // Define a regular expression pattern Pattern pattern = Pattern.compile("\\b\\w{3}\\b"); // Create a matcher from the input text Matcher matcher = pattern.matcher(text); // Use replaceAll with a lambda expression as the replacer //这里表示在调用函数式接口的方法的时候，将每次匹配的内容以大写的形式返回 String result = matcher.replaceAll(match -> match.group().toUpperCase()); System.out.println(result); } } /* 运行结果： HELLO, WORLD! HOW ARE YOU? */

（22）public int start()

说明：返回上次匹配到内容的初始索引，如果上次匹配没有内容，抛出异常。

 String text = "Hello, world! How are you?"; // Define a regular expression pattern Pattern pattern = Pattern.compile("\\b\\w{3}\\b"); // Create a matcher from the input text Matcher matcher = pattern.matcher(text); while(matcher.find()){ System.out.println("当前匹配内容：" + matcher.group() +",当前匹配的索引是:" + matcher.start()); } } } /* 运行结果： 当前匹配内容：How,当前匹配的索引是:14 当前匹配内容：are,当前匹配的索引是:18 当前匹配内容：you,当前匹配的索引是:22 */

（23）public int start(int group)

说明：和public String group(int group)类似，上一次匹配结果，捕获组次序为group的的索引值。

（24）public int start(String name)

说明：和public String group(String Name)类似，上一次匹配结果，捕获组名称为name的的索引值。

（25）public int end()

说明：返回上一次匹配结果的结束索引位置，如果上次没有匹配，那么报错

（26）public int end(int group)

说明：和public String group(int group)类似，不做过多解释

（27）public int end(String name)

说明：和public String group(String name)类似，不做过多解释

（28）public int groupCount()

说明：

Matcher类的groupCount()方法是用于获取匹配器中捕获组的数量

String input = "Hello World"; Pattern pattern = Pattern.compile("(Hello) (World)"); Matcher matcher = pattern.matcher(input); int count = matcher.groupCount(); System.out.println("Number of capturing groups: " + count); /* 运行结果： Number of capturing groups: 2 */ 

我们使用正则表达式模式”(Hello) (World)“来创建一个Matcher对象。然后，我们使用groupCount()方法获取匹配器中的捕获组数量，并将结果打印出来。在这个例子中，正则表达式包含两个捕获组，因此输出是”Number of capturing groups: 2”。

（29）public int groupCount(int group)

说明：和public String group(int group)类似，不做过多解释

（30）public int groupCount(String name)

说明：和public String group(String name)类似，不做过多解释

（31）public boolean lookingAt()

说明：lookingAt()是Matcher类中的一个方法，用于检查输入字符串的起始部分是否与正则表达式模式匹配。

String input = "Hello World"; Pattern pattern = Pattern.compile("Hello"); Matcher matcher = pattern.matcher(input); boolean isLookingAt = matcher.lookingAt(); System.out.println("Looking at: " + isLookingAt); /* 运行结果： Looking at: true */

如果将input改为String input = “123Hello World”;，则会报错失败。

（32）public Matcher region(int start, int end)

说明：Matcher类的region()方法用于设置匹配器的区域范围，即指定在输入字符串中进行匹配操作的起始位置和结束位置。返回值为Matcher对象本身，因此可以进行链式调用。

参数说明：

• start：指定匹配操作的起始位置（包括）。
• end：指定匹配操作的结束位置（不包括）。

String input = "Hello World"; Pattern pattern = Pattern.compile("World"); Matcher matcher = pattern.matcher(input).region(6, 11); System.out.println("Matches: " + matcher.toString()); /* 运行结果： Matches: java.util.regex.Matcher[pattern=World region=6,11 lastmatch=] */

（33）public int regionEnd()

说明：regionEnd()是Matcher类中的一个方法，用于返回匹配器当前设置的区域范围的结束位置（不包括）

String input = "Hello World"; Pattern pattern = Pattern.compile("World"); Matcher matcher = pattern.matcher(input); matcher.region(6, 11); int regionEnd = matcher.regionEnd(); System.out.println("Region end: " + regionEnd); /* 运行结果： Region end: 11 */

（34）public int regionStart()

说明：regionStart() 是 Matcher 类中的一个方法，用于返回匹配器当前设置的区域范围的起始位置。

String input = "Hello World"; Pattern pattern = Pattern.compile("World"); Matcher matcher = pattern.matcher(input); matcher.region(6, 11); int regionStart = matcher.regionStart(); System.out.println("Region start: " + regionStart); /* 运行结果： Region start: 6 */

（35）public String replaceFirst(String replacement)

说明：replaceFirst(String replacement) 是 Matcher 类中的一个方法，用于将匹配到的第一个子字符串替换为指定的替换字符串。

 String input = "Hello World World World!"; Pattern pattern = Pattern.compile("World"); Matcher matcher = pattern.matcher(input); String replacedString = matcher.replaceFirst("Universe"); System.out.println("Replaced string: " + replacedString); /* 运行结果： Replaced string: Hello Universe World World! */

（36）public String replaceFirst(Function<MatchResult, String> replacer)

说明：类似于上面的public String replaceAll(Function<MatchResult, String> replacer)

String input = "Hello World World World!"; Pattern pattern = Pattern.compile("World"); Matcher matcher = pattern.matcher(input); String replacedString = matcher.replaceFirst(match -> match.group().toUpperCase()); System.out.println("Replaced string: " + replacedString); /* 运行结果： Replaced string: Hello WORLD World World! */ 

（37）public Matcher reset()

说明：

reset() 是 Matcher 类中的一个方法，用于重置匹配器的状态，将其重新设置为初始状态。

String input = "Hello World"; Pattern pattern = Pattern.compile("World"); Matcher matcher = pattern.matcher(input); matcher.find(); System.out.println("First match: " + matcher.group()); matcher.reset(); matcher.find(); System.out.println("Reset match: " + matcher.group()); /* 运行结果： First match: World Reset match: World */

我们首先使用正则表达式模式”World”创建一个 Matcher 对象，并将其应用于输入字符串”Hello World”。然后，我们使用 find() 方法进行一次匹配操作，并打印出第一个匹配到的子字符串 “World”。接下来，我们使用 reset() 方法重置匹配器的状态，将其恢复到初始状态。再次使用 find() 方法进行匹配操作，可以看到匹配器又重新从输入字符串中找到了与正则表达式匹配的子字符串 “World”。

（38）public Matcher reset(CharSequence input)

说明：reset(CharSequence input) 是 Matcher 类中的一个方法，用于重置匹配器的状态，并将新的输入字符序列应用于匹配器

String input = "Hello World"; Pattern pattern = Pattern.compile("World"); Matcher matcher = pattern.matcher(input); matcher.find(); System.out.println("First match: " + matcher.group()); CharSequence newInput = "Hello Universe"; matcher.reset(newInput); matcher.find(); System.out.println("Reset match: " + matcher.group()); /* 运行结果： First match: World Reset match: Universe */

（39）public Matcher reset(CharSequence input)

说明：toMatchResult() 是 Matcher 类中的一个方法，用于返回当前匹配操作的结果作为 MatchResult 对象。

String input = "Hello World"; Pattern pattern = Pattern.compile("World"); Matcher matcher = pattern.matcher(input); matcher.find(); MatchResult matchResult = matcher.toMatchResult(); System.out.println("Matched substring: " + matchResult.group()); System.out.println("Start index: " + matchResult.start()); System.out.println("End index: " + matchResult.end()); /* 输出： Matched substring: World Start index: 6 End index: 11 */

我们首先使用正则表达式模式”World”创建一个 Matcher 对象，并将其应用于输入字符串”Hello World”。然后，我们使用 find() 方法进行一次匹配操作。接下来，我们使用 toMatchResult() 方法获取当前匹配操作的结果作为 MatchResult 对象。通过 MatchResult 对象，我们可以访问匹配到的子字符串、起始位置和结束位置等信息，并将其打印出来。

请注意，toMatchResult() 方法返回的是一个 MatchResult 对象，其中包含了有关匹配结果的各种信息。通过 MatchResult 对象，您可以获取匹配到的子字符串以及它在输入字符串中的起始位置和结束位置等相关信息。

（40）public Matcher usePattern(Pattern newPattern)

说明：usePattern(Pattern newPattern) 是 Matcher 类中的一个方法，用于将匹配器切换到一个新的正则表达式模式

该方法的函数签名如下：

public Matcher usePattern(Pattern newPattern)

参数 newPattern 表示要切换到的新的正则表达式模式。

返回值为 Matcher 对象本身，因此可以进行链式调用

String input = "Hello World"; Pattern pattern1 = Pattern.compile("World"); Matcher matcher = pattern1.matcher(input); matcher.find(); System.out.println("First match: " + matcher.group()); Pattern pattern2 = Pattern.compile("Hello"); matcher.usePattern(pattern2); matcher.find(); System.out.println("New pattern match: " + matcher.group()); /* 运行结果： First match: World New pattern match: Hello */

我们首先使用正则表达式模式 “World” 创建一个 Matcher 对象，并将其应用于输入字符串 “Hello World”。然后，我们使用 find() 方法进行一次匹配操作，并打印出第一个匹配到的子字符串 “World”。接下来，我们创建了另一个正则表达式模式 “Hello” 并使用 usePattern() 方法将匹配器切换到这个新的模式。再次使用 find() 方法进行匹配操作，可以看到匹配器从新的模式中找到了与之匹配的子字符串 “Hello”。

请注意，usePattern(Pattern newPattern) 方法用于切换 Matcher 对象的正则表达式模式。通过使用不同的模式，您可以重复使用同一个 Matcher 对象进行多个不同模式的匹配操作。调用此方法后，匹配器的状态将被重置，并从新的模式开始进行匹配操作。

4 常用正则表达式

一、校验数字的表达式 数字：^[0-9]*$ n位的数字：^\d{n}$ 至少n位的数字：^\d{n,}$ m-n位的数字：^\d{m,n}$ 零和非零开头的数字：^(0|[1-9][0-9]*)$ 非零开头的最多带两位小数的数字：^([1-9][0-9]*)+(.[0-9]{1,2})?$ 带1-2位小数的正数或负数：^(\-)?\d+(\.\d{1,2})?$ 正数、负数、和小数：^(\-|\+)?\d+(\.\d+)?$ 有两位小数的正实数：^[0-9]+(.[0-9]{2})?$ 有1~3位小数的正实数：^[0-9]+(.[0-9]{1,3})?$ 非零的正整数：^[1-9]\d*$ 或 ^([1-9][0-9]*){1,3}$ 或 ^\+?[1-9][0-9]*$ 非零的负整数：^\-[1-9][]0-9"*$ 或 ^-[1-9]\d*$ 非负整数：^\d+$ 或 ^[1-9]\d*|0$ 非正整数：^-[1-9]\d*|0$ 或 ^((-\d+)|(0+))$ 非负浮点数：^\d+(\.\d+)?$ 或 ^[1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0$ 非正浮点数：^((-\d+(\.\d+)?)|(0+(\.0+)?))$ 或 ^(-([1-9]\d*\.\d*|0\.\d*[1-9]\d*))|0?\.0+|0$ 正浮点数：^[1-9]\d*\.\d*|0\.\d*[1-9]\d*$ 或 ^(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*))$ 负浮点数：^-([1-9]\d*\.\d*|0\.\d*[1-9]\d*)$ 或 ^(-(([0-9]+\.[0-9]*[1-9][0-9]*)|([0-9]*[1-9][0-9]*\.[0-9]+)|([0-9]*[1-9][0-9]*)))$ 浮点数：^(-?\d+)(\.\d+)?$ 或 ^-?([1-9]\d*\.\d*|0\.\d*[1-9]\d*|0?\.0+|0)$ 二、校验字符的表达式 汉字：^[\u4e00-\u9fa5]{0,}$ 英文和数字：^[A-Za-z0-9]+$ 或 ^[A-Za-z0-9]{4,40}$ 长度为3-20的所有字符：^.{3,20}$ 由26个英文字母组成的字符串：^[A-Za-z]+$ 由26个大写英文字母组成的字符串：^[A-Z]+$ 由26个小写英文字母组成的字符串：^[a-z]+$ 由数字和26个英文字母组成的字符串：^[A-Za-z0-9]+$ 由数字、26个英文字母或者下划线组成的字符串：^\w+$ 或 ^\w{3,20}$ 中文、英文、数字包括下划线：^[\u4E00-\u9FA5A-Za-z0-9_]+$ 中文、英文、数字但不包括下划线等符号：^[\u4E00-\u9FA5A-Za-z0-9]+$ 或 ^[\u4E00-\u9FA5A-Za-z0-9]{2,20}$ 可以输入含有^%&',;=?$\"等字符：[^%&',;=?$\x22]+ 禁止输入含有~的字符：[^~\x22]+ 三、特殊需求表达式 Email地址：^\w+([-+.]\w+)*@\w+([-.]\w+)*\.\w+([-.]\w+)*$ 域名：[a-zA-Z0-9][-a-zA-Z0-9]{0,62}(/.[a-zA-Z0-9][-a-zA-Z0-9]{0,62})+/.? InternetURL：[a-zA-z]+://[^\s]* 或 ^https://([\w-]+\.)+[\w-]+(/[\w-./?%&=]*)?$ 手机号码：^(13[0-9]|14[5|7]|15[0|1|2|3|5|6|7|8|9]|18[0|1|2|3|5|6|7|8|9])\d{8}$ 电话号码("XXX-XXXXXXX"、"XXXX-XXXXXXXX"、"XXX-XXXXXXX"、"XXX-XXXXXXXX"、"XXXXXXX"和"XXXXXXXX)：^(\(\d{3,4}-)|\d{3.4}-)?\d{7,8}$ 国内电话号码(0511-、021-)：\d{3}-\d{8}|\d{4}-\d{7} 身份证号： 15或18位身份证：^\d{15}|\d{18}$ 15位身份证：^[1-9]\d{7}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{3}$ 18位身份证：^[1-9]\d{5}[1-9]\d{3}((0\d)|(1[0-2]))(([0|1|2]\d)|3[0-1])\d{4}$ 短身份证号码(数字、字母x结尾)：^([0-9]){7,18}(x|X)?$ 或 ^\d{8,18}|[0-9x]{8,18}|[0-9X]{8,18}?$ 帐号是否合法(字母开头，允许5-16字节，允许字母数字下划线)：^[a-zA-Z][a-zA-Z0-9_]{4,15}$ 密码(以字母开头，长度在6~18之间，只能包含字母、数字和下划线)：^[a-zA-Z]\w{5,17}$ 强密码(必须包含大小写字母和数字的组合，不能使用特殊字符，长度在8-10之间)：^(?=.*\d)(?=.*[a-z])(?=.*[A-Z]).{8,10}$ 日期格式：^\d{4}-\d{1,2}-\d{1,2} 一年的12个月(01～09和1～12)：^(0?[1-9]|1[0-2])$ 一个月的31天(01～09和1～31)：^((0?[1-9])|((1|2)[0-9])|30|31)$ 钱的输入格式： 1.有四种钱的表示形式我们可以接受:"10000.00" 和 "10,000.00", 和没有 "分" 的 "10000" 和 "10,000"：^[1-9][0-9]*$ 2.这表示任意一个不以0开头的数字,但是,这也意味着一个字符"0"不通过,所以我们采用下面的形式：^(0|[1-9][0-9]*)$ 3.一个0或者一个不以0开头的数字.我们还可以允许开头有一个负号：^(0|-?[1-9][0-9]*)$ 4.这表示一个0或者一个可能为负的开头不为0的数字.让用户以0开头好了.把负号的也去掉,因为钱总不能是负的吧.下面我们要加的是说明可能的小数部分：^[0-9]+(.[0-9]+)?$ 5.必须说明的是,小数点后面至少应该有1位数,所以"10."是不通过的,但是 "10" 和 "10.2" 是通过的：^[0-9]+(.[0-9]{2})?$ 6.这样我们规定小数点后面必须有两位,如果你认为太苛刻了,可以这样：^[0-9]+(.[0-9]{1,2})?$ 7.这样就允许用户只写一位小数.下面我们该考虑数字中的逗号了,我们可以这样：^[0-9]{1,3}(,[0-9]{3})*(.[0-9]{1,2})?$ 8.1到3个数字,后面跟着任意个 逗号+3个数字,逗号成为可选,而不是必须：^([0-9]+|[0-9]{1,3}(,[0-9]{3})*)(.[0-9]{1,2})?$ 备注：这就是最终结果了,别忘了"+"可以用"*"替代如果你觉得空字符串也可以接受的话(奇怪,为什么?)最后,别忘了在用函数时去掉去掉那个反斜杠,一般的错误都在这里 xml文件：^([a-zA-Z]+-?)+[a-zA-Z0-9]+\\.[x|X][m|M][l|L]$ 中文字符的正则表达式：[\u4e00-\u9fa5] 双字节字符：[^\x00-\xff] (包括汉字在内，可以用来计算字符串的长度(一个双字节字符长度计2，ASCII字符计1)) 空白行的正则表达式：\n\s*\r (可以用来删除空白行) HTML标记的正则表达式：<(\S*?)[^>]*>.*?|<.*? /> (网上流传的版本太糟糕，上面这个也仅仅能部分，对于复杂的嵌套标记依旧无能为力) 首尾空白字符的正则表达式：^\s*|\s*$或(^\s*)|(\s*$) (可以用来删除行首行尾的空白字符(包括空格、制表符、换页符等等)，非常有用的表达式) 腾讯号：[1-9][0-9]{4,} (腾讯号从10000开始) 中国邮政编码：[1-9]\d{5}(?!\d) (中国邮政编码为6位数字) IP地址：\d+\.\d+\.\d+\.\d+ (提取IP地址时有用)