Java - 正则表达式

---

---

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

Java 中的正则表达式

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

Java 正则表达式 (Regex) 类

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)

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

还有一个特殊的组，组 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 中所有可用正则表达式元字符语法的列表 -

正则表达式 - Matcher 类方法

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

索引方法

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

研究方法

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

正则表达式 - 替换方法

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

start 和 end 方法

以下示例计算单词“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 返回匹配到的最后一个字符的索引加一。

matches() 和 lookingAt() 方法

matches 和 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 类提供以下方法来帮助您确定问题所在：