Java 正则表达式

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

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

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

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

捕获组

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

通过从左到右计算它们的开括号，可以给捕获组编号。例如，在表达式((A)(B(C)))中，有四个这样的组 –

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

要查找表达式中存在多少个组，请在匹配器对象上调用groupCount方法。groupCount方法返回一个整数，显示匹配器模式中存在的捕获组的数量。

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

示例

以下示例演示了如何从给定的字母数字字符串中查找一个数字字符串 –

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");
      }
   }
}

这将产生以下结果 −

输出

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+	匹配前一个元素出现1次或多次。
re?	匹配前面的表达式出现0次或1次。
re{ n}	匹配前面的表达式出现n次。
re{ n,}	匹配前面的表达式出现至少n次。
re{ n, m}	匹配前面的表达式出现至少n次，最多m次。
a	b \| 匹配a或b。
(re)	匹配并记住所匹配的文本。
(?: re)	不记忆匹配的文本，用于分组正则表达式。
(?> re)	无回溯地匹配独立模式。
\w	匹配字母、数字、下划线字符。
\W	匹配非字母、非数字、非下划线字符。
\s	匹配空白字符。等效于[\t\n\r\f]。
\S	匹配非空白字符。
\d	匹配数字。等效于[0-9]。
\D	匹配非数字字符。
\A	匹配字符串的开头。
\Z	匹配字符串的结尾。如果存在换行符，则在换行符之前进行匹配。
\z	匹配字符串的结尾。
\G	匹配上次匹配结束的位置。
\n	反向引用捕获组号为“n”的内容。
\b	匹配单词边界（在括号外）或退格符（0x08）（在括号内）。
\B	匹配非单词边界。
\n、\t等	匹配换行符、回车符、制表符等。
\Q	转义（引用）\E之前的所有字符。
\E	以 \Q 开始的引述终止。

Matcher类的方法

以下是一些有用的实例方法的列表：

索引方法

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

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

学习方法

学习方法回顾输入字符串并返回一个布尔值，指示是否找到了模式 –

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

替换方法

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

序号	方法与描述
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) 返回指定字符串的字面替换字符串。该方法生成一个字符串，该字符串将作为Matcher类的appendReplacement方法中的字面替换 s 。

开始和结束的方法

下面是一个示例，计算输入字符串中单词”cat”出现的次数 –

示例

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());
      }
   }
}

这将会产生以下结果 −

输出

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方法返回在前一个匹配操作期间给定组捕获的子序列的起始索引，而end返回最后一个匹配字符的索引加一。

匹配和lookingAt方法

匹配和lookingAt方法都试图将输入序列与模式匹配。然而，区别在于matches需要完整的输入序列匹配，而lookingAt则不需要。

这两个方法总是从输入字符串的开头开始。下面是一个说明功能的示例：

示例

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());
   }
}

这将产生以下结果−

输出

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

replaceFirst和replaceAll方法

replaceFirst和replaceAll方法替换与给定正则表达式匹配的文本。根据它们的名称，replaceFirst替换第一次出现的匹配项，而replaceAll替换所有出现的匹配项。

以下是解释功能的示例：

示例

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);
   }
}

这将产生以下结果 −

输出

The cat says meow. All cats say meow.

appendReplacement和appendTail方法

Matcher类还提供了用于文本替换的appendReplacement和appendTail方法。

下面是解释其功能的示例：

示例

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());
   }
}

这将产生以下结果 –

输出

-foo-foo-foo-

PatternSyntaxException类方法

PatternSyntaxException 是一个未经检查的异常，表示正则表达式模式中的语法错误。PatternSyntaxException 类提供了以下方法来帮助您确定出了什么问题−

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