Javaregex 简明教程

Java Regex - Quick Guide

Java Regex - Overview

Java 提供 java.util.regex 包，用于使用正则表达式进行模式匹配。Java 正则表达式与 Perl 编程语言非常相似，且非常容易学习。

正则表达式是由字符组成的特殊序列，它使用模式中包含的专门语法，帮助您匹配或查找其他字符串或字符串集。它们可以用来搜索、编辑或处理文本和数据。

java.util.regex 包主要包含以下三个类 −

Pattern Class − Pattern 对象是正则表达式的编译表示。Pattern 类不提供任何公共构造函数。要创建模式，你必须首先调用其公共静态 compile() 方法之一，然后该方法将返回一个 Pattern 对象。这些方法将正则表达式作为第一个参数接受。
Matcher Class - Matcher 对象是解释模式并在给定输入字符串上执行匹配操作的引擎。与 Pattern 类类似，Matcher 未定义任何公共构造函数。可以通过对 Pattern 对象调用 matcher() 方法来获取 Matcher 对象。
PatternSyntaxException - PatternSyntaxException 对象是未检查的异常，指示正则表达式模式中的语法错误。

Java Regex - Capturing Groups

捕获组是一种将多个字符视为单个单位的方法。它们是通过将待分组的字符置于一组圆括号内创建的。例如，正则表达式 (dog) 创建单个组，其中包含字母“d”、“o”和“g”。

捕获组通过从左到右计算其左括号进行编号。例如，在表达式 A)(B© 中，存在四个这样的组 -

A)(B©
(A)
(B©)
©

若要找出表达式中有多少组，请对匹配器对象调用 groupCount 方法。groupCount 方法返回一个 int，显示匹配器模式中存在的分组数。

还有一个特殊的组，组 0，它始终代表整个表达式。此组不包括在 groupCount 报告的总数中。

Example

以下示例说明如何从给定的字母数字字符串中找到数字字符串 -

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

public class RegexMatches {
   public static void main( String args[] ) {
      // String to be scanned to find the pattern.
      String line = "This order was placed for QT3000! OK?";
      String pattern = "(.*)(\\d+)(.*)";

      // Create a Pattern object
      Pattern r = Pattern.compile(pattern);

      // Now create matcher object.
      Matcher m = r.matcher(line);

      if (m.find( )) {
         System.out.println("Found value: " + m.group(0) );
         System.out.println("Found value: " + m.group(1) );
         System.out.println("Found value: " + m.group(2) );
      } else {
         System.out.println("NO MATCH");
      }
   }
}

这会产生以下结果 −

Output

Found value: This order was placed for QT3000! OK?
Found value: This order was placed for QT300
Found value: 0

Java Regex - MatchResult Interface

Introduction

java.util.regex.MatchResult 接口表示匹配操作的结果。此接口包含用于确定针对正则表达式的匹配结果的查询方法。匹配边界、组和组边界可以通过 MatchResult 查看，但不能修改。

Interface declaration

以下是 java.util.regex.MatchResult 接口的声明 −

public interface MatchResult

Interface methods

Sr.No	Method & Description
1	int end() 返回最后一个匹配字符后的偏移量。
2	int end(int group) 用于返回在此匹配期间给定组捕获的子序列的最后一个字符后的偏移量。
3	String group() 返回上次匹配匹配的输入子序列。
4	String group(int group) 返回上次匹配操作期间给定组捕获的输入子序列。
5	int groupCount() 返回此匹配结果的模式中的捕获组数。
6	int start() 返回匹配的起始索引。
7	int start(int group) 返回在此匹配期间给定组捕获的子序列的起始索引。

Java Regex - Pattern Class

Introduction

java.util.regex.Pattern 类表示正则表达式的编译表示。

Class declaration

以下是 java.util.regex.Pattern 类的声明 -

public final class Pattern
   extends Object
      implements Serializable

Field

以下是 java.util.regex.Duration 类的字段 -

static int CANON_EQ − 启用规范等同。
static int CASE_INSENSITIVE − 启用不区分大小写的匹配。
static int COMMENTS − 允许模式中的空格和注释。
static int DOTALL − 启用 dotall 模式。
static int LITERAL − 启用模式的字面解析。
static int MULTILINE − 启用多行模式。
static int UNICODE_CASE − 启用 Unicode 感知大小写折叠。
static int UNICODE_CHARACTER_CLASS − 启用 Unicode 版本预定义的字符类和 POSIX 字符类。
static int UNIX_LINES − 启用 Unix 行模式。

Class methods

Sr.No	Method & Description
1	static Pattern compile(String regex) 将给定的正则表达式编译成一个模式。
2	static Pattern compile(String regex, int flags) 将给定的正则表达式编译成具有给定标志的模式。
3	int flags() 返回此模式的匹配标志。
4	Matcher matcher(CharSequence input) 创建一个匹配器，该匹配器将使用此模式匹配给定的输入。
5	static boolean matches(String regex, CharSequence input) 编译给定的正则表达式，并尝试使用它匹配给定的输入。
6	String pattern() 返回此模式从中编译出的正则表达式。
7	static String quote(String s) 返回指定字符串的字符串字面模式。
8	String[] split(CharSequence input) 围绕此模式的匹配拆分给定的输入序列。
9	String[] split(CharSequence input, int limit) 围绕此模式的匹配拆分给定的输入序列。
10	String toString() 返回此模式的字符串表示形式。

Methods inherited

此类从以下类中继承方法：

Java.lang.Object

Java Regex - Matcher Class

Introduction

java.util.regex.Matcher 类充当一个引擎，它通过解释 Pattern 来对字符序列执行匹配操作。

Class declaration

以下是 java.util.regex.Matcher 类的声明−

public final class Matcher
   extends Object
      implements MatchResult

Class methods

Sr.No	Method & Description
1	Matcher appendReplacement(StringBuffer sb, String replacement) 实现一个非终端追加和替换步骤。
2	StringBuffer appendTail(StringBuffer sb) 实现一个终端追加和替换步骤。
3	int end() 返回匹配的最后一个字符之后的偏移量。
4	int end(int group) 返回在先前的匹配操作中由给定组捕获的子序列的最后一个字符之后的偏移量。
5	boolean find() 尝试在输入序列中查找与模式相匹配的下一个子序列。
6	boolean find(int start) 重置此匹配器，然后尝试从指定索引开始查找与模式相匹配的输入序列的下一个子序列。
7	String group() 返回在先前的匹配操作中由给定组捕获的输入子序列。
8	String group(String name) 在上次匹配操作期间，返回给定已命名捕获组捕获的输入子序列。
9	int groupCount() 返回此匹配器的模式中捕获组的数量。
10	boolean hasAnchoringBounds() 查询此匹配器区域边界的固定。
11	boolean hasTransparentBounds() 查询此匹配器区域边界的透明度。
12	boolean hitEnd() 如果在本次匹配器执行的上次匹配操作中，搜索引擎触及输入的末尾，则返回 true。
13	boolean lookingAt() 尝试从区域的开头匹配输入序列，与模式匹配。
14	boolean matches() 尝试匹配整个区域与模式。
15	Pattern pattern() 返回此匹配器解释的模式。
16	static String quoteReplacement(String s) 返回指定字符串的文字替换字符串。
17	Matcher region(int start, int end) 设置此匹配器的区域限制。
18	int regionEnd() 报告此匹配器区域的结束索引（不包括）。
19	int regionStart() 报告此匹配器区域的开始索引。
20	String replaceAll(String replacement) 将匹配模式的输入序列的每个子序列替换为给定的替换字符串。
21	String replaceFirst(String replacement) 将匹配模式的输入序列的第一个子序列替换为给定的替换字符串。
22	boolean requireEnd() 如果输入更多内容可能将正向匹配变成负向匹配，则返回 true。
23	Matcher reset()Resets this matcher.
24	Matcher reset(CharSequence input) 使用一个新的输入序列重置此匹配器。
25	int start() 返回上次匹配的开始索引。
26	int start(int group) 返回在上次匹配操作期间由给定组捕获的子序列的开始索引。
27	MatchResult toMatchResult() 将此匹配器匹配状态返回为 MatchResult。
28	String toString() 返回此匹配器的字符串表示形式。
29	Matcher useAnchoringBounds(boolean b) 设置此匹配器的区间边界锚定。
30	Matcher usePattern(Pattern newPattern) 更改此匹配器用于查找匹配项的模式。
31	Matcher useTransparentBounds(boolean b) 设置此匹配器的区间边界透明度。

Methods inherited

此类从以下类中继承方法：

Java.lang.Object

Java Regex - PatternSyntaxException Class

Introduction

java.util.regex.PatternSyntaxException 类表示抛出一个未检查异常，以指示正则表达式模式的语法错误。

Class declaration

以下是 java.util.regex.PatternSyntaxException 类的声明 −

public class PatternSyntaxException
   extends IllegalArgumentException

Constructors

Sr.No

Method & Description

*PatternSyntaxException(String desc, String regex, int index)*构造此类的新的实例。

Class methods

Sr.No	Method & Description
1	String getDescription()检索错误的描述。
2	int getIndex()检索错误索引。
3	String getMessage()返回一个多行字符串，其中包含语法错误及其索引、错误的正则表达式模式和模式中错误索引的可视指示。
4	String getPattern()检索错误的正则表达式模式。

Methods inherited

此类从以下类中继承方法：

Java.lang.Throwable
Java.lang.Object

Example

以下示例展示了 java.util.regex.Pattern.PatternSyntaxException 类方法的用法。

package com.tutorialspoint;

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

public class PatternSyntaxExceptionDemo {
   private static String REGEX = "[";
   private static String INPUT = "The dog says meow " + "All dogs say meow.";
   private static String REPLACE = "cat";

   public static void main(String[] args) {
      try{
         Pattern pattern = Pattern.compile(REGEX);

         // get a matcher object
         Matcher matcher = pattern.matcher(INPUT);
         INPUT = matcher.replaceAll(REPLACE);
      } catch(PatternSyntaxException e){
         System.out.println("PatternSyntaxException: ");
         System.out.println("Description: "+ e.getDescription());
         System.out.println("Index: "+ e.getIndex());
         System.out.println("Message: "+ e.getMessage());
         System.out.println("Pattern: "+ e.getPattern());
      }
   }
}

让我们编译并运行上述程序，这将生成以下结果 −

PatternSyntaxException:
Description: Unclosed character class
Index: 0
Message: Unclosed character class near index 0
[
^
Pattern: [

Java Regex - Examples Matching Characters

以下是使用 Java 中的正则表达式匹配字符的各种示例。

Sr.No	Construct & Matches
1	xThe character x
2	link:../javaregex/javaregex_characters_backslash.html[\\]The backslash character
3	\0n 具有八进制值 0n（0 ≤ n ≤ 7）的字符
4	\0nn 具有八进制值 0nn（0 ≤ n ≤ 7）的字符
5	\0mnn 具有八进制值 0mnn（0 ≤ m ≤ 3, 0 ≤ n ≤ 7）的字符
6	\xhh 具有十六进制值 0xhh 的字符
7	\uhhhh 具有十六进制值 0xhhhh 的字符
8	\tThe tab character ('\u0009')
9	\n 换行（换行符）字符 ('\u000A')
10	\rThe carriage-return character ('\u000D')
11	\fThe form-feed character ('\u000C')

Java Regex - Matching Character Classes

以下是使用 Java 中的正则表达式匹配各种字符类别的示例。

Sr.No	Construct & Matches
1	[abc] a, b，或 c（简单类）。
2	[^abc] 除了 a、b、或 c 之外的任何字符（否定）。
3	[a-zA-Z] 从 a 到 z 或 A 到 z，包括（范围）。
4	[a-d[m-p]] 从 a 到 d，或从 m 到 p：[a-dm-p]（并集）。
5	[a-z&&[def]] d、e 或 f（交集）。
6	[a-z&&[^bc]] 从 a 到 z，但除外 b 和 c：[ad-z]（减法）
7	[a-z&&[^m-p]] 从 a 到 z，且不包括 m 到 p：[a-lq-z]（减法）。

Matching Predefined Character Classes

以下是使用正则表达式在 Java 中匹配预定义字符类的各种示例。

Sr.No	Construct & Matches
1	. 任何字符（可能匹配或不匹配行终止符）。
2	\dA digit: [0-9].
3	\DA non-digit: [^0-9].
4	\s 一个空白字符：[ \t\n\x0B\f\r]
5	\SA non-whitespace character: [^\s].
6	\wA word character: [a-zA-Z_0-9].
7	\WA non-word character: [^\w]

Matching POSIX Character Classes

以下是使用正则表达式在 Java 中匹配 POSIX 字符类的各种示例。

Sr.No	Construct & Matches
1	\p{Lower} 小写字母字符：[a-z]。
2	\p{Upper}An upper-case alphabetic character:[A-Z].
3	\p{ASCII}All ASCII:[\x00-\x7F].
4	\p{Alpha}An alphabetic character:[\p{Lower}\p{Upper}].
5	\p{Digit}A decimal digit: [0-9].
6	\p{Alnum}An alphanumeric character:[\p{Alpha}\p{Digit}].
7	\p{Punct}Punctuation: One of !"#$%&'()*+,-./:;<⇒?@[\]^_>{
}<.	8
\p{Graph}A visible character: [\p{Alnum}\p{Punct}].	9
\p{Print}A printable character: [\p{Graph}\x20].	10
\p 空格或制表符： [ \t]。	11
\p{XDigit}A hexadecimal digit: [0-9a-fA-F].	12

Matching JAVA Character Classes

以下是使用 Java 中正则表达式匹配 JAVA 字符类的各种示例。

Sr.No	Construct & Matches
1	\p{javaLowerCase}Equivalent to java.lang.Character.isLowerCase().
2	\p{javaUpperCase}Equivalent to java.lang.Character.isUpperCase().
3	\p{javaWhitespace}Equivalent to java.lang.Character.isWhitespace().
4	\p{javaMirrored}Equivalent to java.lang.Character.isMirrored().

Matching Unicode Character Classes

以下是使用正则表达式在 Java 中匹配 Unicode 字符类的各种示例。

Sr.No	Construct & Matches
1	\p{IsLatin}A Latin script character.
2	\p{InGreek} Greek 区块中的一个字符。
3	\p{Lu}An uppercase letter.
4	\p{IsAlphabetic} 一个字母字符（二进制属性）。
5	\p{Sc}A currency symbol.
6	\P{InGreek} 除 Greek 区块中的字符外的任何字符。
7	[\p{L}&&[^\p{Lu}]] 除大写字母外的任何字母。

Examples of Boundary Matchers

以下是使用 Java 中的正则表达式编写边界匹配器的一些示例。

Sr.No	Construct & Matches
1	[role="bare"]../javaregex/javaregex_boundary_matcher_begin.html行首。
2	$ 行尾。
3	\bA word boundary.
4	\BA non-word boundary.
5	\A 输入开头。
6	\G 上次匹配的结尾。
7	\Z 输入结束，但有最终终止符（如果存在）。
8	\z 输入结束。

Java Regexs of Greedy Quantifiers

贪婪限定符指示搜索引擎搜索整个字符串并检查它是否与给定的正则表达式匹配。以下是使用正则表达式在 Java 中使用贪婪限定符的各种示例。

Sr.No	Construct & Matches
1	X? X，一次或根本不匹配。
2	X* X，零次或多次。
3	X+ X，一次或多次。
4	X{n}X, exactly n times.
5	X{n,} X，至少 n 次。
6	X{n,m} X，至少 n 次但不超过 m 次。

Examples of Reluctant Quantifiers

懒惰量词指示搜索引擎从最短可能的字符串片段开始。一旦找到匹配项，引擎将继续；否则，它会向正在检查的字符串部分添加一个字符并搜索该部分，依此类推。此过程将一直持续到找到匹配项或用完整个字符串。以下是使用 Java 中的正则表达式编写懒惰量词的一些示例。

Sr.No	Construct & Matches
1	X?? X，一次或根本没有。
2	X*? X，零次或多次
3	X+? X，一次或多次。
4	X{n}?X, exactly n times.
5	X{n,}? X，至少n次。
6	X{n,m}? X，至少n次但不多于m次

Examples of Possessive Quantifiers

独占量词类似于贪婪量词。它指示引擎从检查整个字符串开始。如果不行，则它有不同的含义，如果匹配失败，并且没有回顾。以下是用 Java 中正则表达式使用独占量词的各种示例。

Sr.No	Construct & Matches
1	X?+ X，一次或根本不匹配。
2	X*+ X，零次或多次。
3	X++ X，一次或多次。
4	X{n}+X, exactly n times.
5	X{n,}+ X，至少 n 次。
6	X{n,m}+ X，至少 n 次，但不多于 m 次。

Java Regex - Examples of Logical Operators

以下是使用 Java 中正则表达式中逻辑运算符的各种示例。

Sr.No

Construct & Matches

XYX followed by Y.

link:../javaregex/javaregex_logical_xory.html[X

Sr.No	Method & Description
1	String getDescription()检索错误的描述。
2	int getIndex()检索错误索引。
3	String getMessage()返回一个多行字符串，其中包含语法错误及其索引、错误的正则表达式模式和模式中错误索引的可视指示。
4	String getPattern()检索错误的正则表达式模式。