1. WIKI教程
2. 学习Java
3. Java - 正则表达式(Regular Expressions)

Java - 正则表达式(Regular Expressions)

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

正则表达式是一种特殊的字符序列，可帮助您使用模式中保存的专用语法来匹配或查找其他字符串或字符串集。 它们可用于搜索，编辑或操作文本和数据。

java.util.regex包主要由以下三个类组成 -

• Pattern Class - 模式对象是正则表达式的编译表示。 Pattern类不提供公共构造函数。 要创建模式，必须首先调用其公共静态compile()方法之一，然后返回Pattern对象。 这些方法接受正则表达式作为第一个参数。

• Matcher Class - Matcher对象是解释模式并对输入字符串执行匹配操作的引擎。 与Pattern类一样，Matcher没有定义公共构造函数。 通过在Pattern对象上调用matcher()方法获取Matcher对象。

• PatternSyntaxException - PatternSyntaxException对象是未经检查的异常，指示正则表达式模式中的语法错误。

捕获群组

捕获组是将多个字符视为一个单元的一种方法。 它们是通过将要分组的字符放在一组括号中来创建的。 例如，正则表达式（dog）创建包含字母“d”，“o”和“g”的单个组。

捕获组通过从左到右计算它们的左括号来编号。 在表达式（（A）（B（C）））中，例如，有四个这样的组 -

• ((A)(B(C)))
• (A)
• (B(C))
• (C)

要查找表达式中存在多少个组，请在匹配器对象上调用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中可用的所有正则表达式元字符语法的表 -

子表达式	火柴
^	匹配行的开头。
$	匹配线的末尾。
.	匹配除换行符之外的任何单个字符。 使用m选项也可以匹配换行符。
[...]	匹配括号中的任何单个字符。
[^...]	匹配不在括号中的任何单个字符。
\A	整个字符串的开头。
\z	整个字符串的结尾。
\Z	除允许的最终行终止符之外的整个字符串的结尾。
re*	匹配前面表达式的0次或更多次出现。
re+	匹配前一项中的一项或多项。
re?	匹配前面表达式的0或1次出现。
re{ n}	准确匹配前面表达式的n次出现次数。
re {n，}	匹配前面表达式的n次或多次出现。
re {n，m}	匹配前面表达式的至少n次和最多m次出现。
A | b	匹配a或b。
(re)	对正则表达式进行分组并记住匹配的文本。
（？: 回覆）	将正则表达式分组而不记住匹配的文本。
(?> re)	匹配独立模式而无需回溯。
\w	匹配单词字符。
\W	匹配非单词字符。
\s	匹配空白。 相当于[\ t\n\r\n]。
\S	匹配非空白。
\d	匹配数字。 相当于[0-9]。
\D	匹配非数字。
\A	匹配字符串的开头。
\Z	匹配字符串的结尾。 如果存在换行符，则它在换行符之前匹配。
\z	匹配字符串的结尾。
\G	匹配最后一场比赛结束的点。
\n	反向捕获组号“n”。
\b	在括号外部匹配单词边界。 在括号内匹配退格（0x08）。
\B	匹配非字边界。
\n, \t, etc.	匹配换行符，回车符，制表符等。
\Q	逃脱（引用）所有字符到\ E。
\E	结束引用以\ Q开头。

匹配类的方法

以下是有用的实例方法列表 -

指数方法

索引方法提供有用的索引值，精确显示在输入字符串中找到匹配的位置 -

Sr.No.	方法和描述
1	public int start() 返回上一个匹配的起始索引。
2	public int start(int group) 返回上一个匹配操作期间给定组捕获的子序列的起始索引。
3	public int end() 返回最后一个字符匹配后的偏移量。
4	public int end(int group) 返回在上一个匹配操作期间由给定组捕获的子序列的最后一个字符之后的偏移量。

研究方法

研究方法检查输入字符串并返回一个布尔值，指示是否找到模式 -

Sr.No.	方法和描述
1	public boolean lookingAt() 尝试将从区域开头开始的输入序列与模式匹配。
2	public boolean find() 尝试查找与模式匹配的输入序列的下一个子序列。
3	public boolean find(int start) 重置此匹配器，然后尝试从指定的索引处开始查找与模式匹配的输入序列的下一个子序列。
4	public boolean matches() 尝试将整个区域与模式匹配。

替换方法

替换方法是替换输入字符串中的文本的有用方法 -

Sr.No.	方法和描述
1	public Matcher appendReplacement(StringBuffer sb, String replacement) 实现非终端附加和替换步骤。
2	public StringBuffer appendTail(StringBuffer sb) 实现终端附加和替换步骤。
3	public String replaceAll(String replacement) 将具有给定替换字符串的模式匹配的输入序列的每个子序列替换。
4	public String replaceFirst(String replacement) 将具有给定替换字符串的模式匹配的输入序列的第一个子序列替换。
5	public static String quoteReplacement(String s) 返回指定String的文字替换String。 此方法生成一个String，它将作为Matcher类的appendReplacement方法中的文字替换。

开始和结束方法

以下是计算输入字符串中“cat”一词出现次数的示例 -

Example

import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches {
   private static final String REGEX = "\\bcat\\b";
   private static final String INPUT = "cat cat cat cattie cat";
   public static void main( String args[] ) {
      Pattern p = Pattern.compile(REGEX);
      Matcher m = p.matcher(INPUT);   // get a matcher object
      int count = 0;
      while(m.find()) {
         count++;
         System.out.println("Match number "+count);
         System.out.println("start(): "+m.start());
         System.out.println("end(): "+m.end());
      }
   }
}

这将产生以下结果 -

Output

Match number 1
start(): 0
end(): 3
Match number 2
start(): 4
end(): 7
Match number 3
start(): 8
end(): 11
Match number 4
start(): 19
end(): 22

您可以看到此示例使用单词边界来确保字母“c”“a”“t”不仅仅是较长单词中的子字符串。 它还提供了有关输入字符串中匹配发生位置的一些有用信息。

start方法返回上一个匹配操作期间给定组捕获的子序列的起始索引，结束返回匹配的最后一个字符的索引加1。

匹配和寻找方法

matches和lookingAt方法都尝试将输入序列与模式匹配。 然而，不同之处在于匹配需要匹配整个输入序列，而查找则不需要。

两种方法总是从输入字符串的开头开始。 以下是解释功能的示例 -

Example

import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches {
   private static final String REGEX = "foo";
   private static final String INPUT = "fooooooooooooooooo";
   private static Pattern pattern;
   private static Matcher matcher;
   public static void main( String args[] ) {
      pattern = Pattern.compile(REGEX);
      matcher = pattern.matcher(INPUT);
      System.out.println("Current REGEX is: "+REGEX);
      System.out.println("Current INPUT is: "+INPUT);
      System.out.println("lookingAt(): "+matcher.lookingAt());
      System.out.println("matches(): "+matcher.matches());
   }
}

这将产生以下结果 -

Output

Current REGEX is: foo
Current INPUT is: fooooooooooooooooo
lookingAt(): true
matches(): false

replaceFirst和replaceAll方法

replaceFirst和replaceAll方法替换匹配给定正则表达式的文本。 正如其名称所示，replaceFirst替换第一个匹配项，replaceAll替换所有匹配项。

以下是解释功能的示例 -

Example

import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches {
   private static String REGEX = "dog";
   private static String INPUT = "The dog says meow. " + "All dogs say meow.";
   private static String REPLACE = "cat";
   public static void main(String[] args) {
      Pattern p = Pattern.compile(REGEX);
      // get a matcher object
      Matcher m = p.matcher(INPUT); 
      INPUT = m.replaceAll(REPLACE);
      System.out.println(INPUT);
   }
}

这将产生以下结果 -

Output

The cat says meow. All cats say meow.

appendReplacement和appendTail方法

Matcher类还为文本替换提供appendReplacement和appendTail方法。

以下是解释功能的示例 -

Example

import java.util.regex.Matcher;
import java.util.regex.Pattern;
public class RegexMatches {
   private static String REGEX = "a*b";
   private static String INPUT = "aabfooaabfooabfoob";
   private static String REPLACE = "-";
   public static void main(String[] args) {
      Pattern p = Pattern.compile(REGEX);
      // get a matcher object
      Matcher m = p.matcher(INPUT);
      StringBuffer sb = new StringBuffer();
      while(m.find()) {
         m.appendReplacement(sb, REPLACE);
      }
      m.appendTail(sb);
      System.out.println(sb.toString());
   }
}

这将产生以下结果 -

Output

-foo-foo-foo-

PatternSyntaxException类方法

PatternSyntaxException是未经检查的异常，表示正则表达式模式中的语法错误。 PatternSyntaxException类提供以下方法来帮助您确定出错的地方 -

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