Matcher 类的方法

本节介绍了Matcher类的一些其他有用方法。为了方便起见,下面列出的方法根据功能进行了分组。

Index Methods

索引方法提供有用的索引值,这些值精确显示在 Importing 字符串 中找到匹配项的位置:

Study Methods

研究方法检查 Importing 字符串,并返回一个布尔值,指示是否找到该 Pattern。

Replacement Methods

替换方法是用于替换 Importing 字符串 中的文本的有用方法。

使用开始和结束方法

这是一个示例MatcherDemo.java,它计算单词“ dog”在 Importing 字符串 中出现的次数。

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

public class MatcherDemo {

    private static final String REGEX =
        "\\bdog\\b";
    private static final String INPUT =
        "dog dog dog doggie dogg";

    public static void main(String[] args) {
       Pattern p = Pattern.compile(REGEX);
       //  get a matcher object
       Matcher m = p.matcher(INPUT);
       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

您可以看到,该示例使用单词边界来确保字母"d" "o" "g"不仅仅是较 Long 单词中的子字符串。它还提供了一些有用的信息,说明匹配在 Importing 字符串 中的何处发生。 start方法返回在上一次匹配操作期间给定组catch的子序列的起始索引,而end返回最后匹配的字符的索引加 1.

使用匹配项和 lookingAt 方法

matcheslookingAt方法都try将 Importing 序列与 Pattern 进行匹配。但是,区别在于matches要求匹配整个 Importing 序列,而lookingAt则不需要。这两种方法总是从 Importing 字符串 的开头开始。这是完整的代码MatchesLooking.java

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

public class MatchesLooking {

    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) {
   
        // Initialize
        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(String)和 replaceAll(String)

replaceFirstreplaceAll方法替换与给定正则表达式匹配的文本。顾名思义,replaceFirst替换了第一个出现的位置,而replaceAll替换了所有出现的位置。这是ReplaceDemo.java代码:

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

public class ReplaceDemo {
 
    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.

在此第一个版本中,所有出现的dogcat代替。但是为什么在这里停下来?您可以替换与任何正则表达式匹配的文本,而不是替换dog这样的简单 Literals。此方法的 API 指出“给定正则表达式a*b,Importingaabfooaabfooabfoob和替换字符串-,对该表达式在匹配器上调用此方法将产生字符串-foo-foo-foo-。”

这是ReplaceDemo2.java代码:

import java.util.regex.Pattern;
import java.util.regex.Matcher;
 
public class ReplaceDemo2 {
 
    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);
        INPUT = m.replaceAll(REPLACE);
        System.out.println(INPUT);
    }
}
OUTPUT: -foo-foo-foo-

要仅替换 Pattern 的第一次出现,只需调用replaceFirst而不是replaceAll即可。它接受相同的参数。

使用 appendReplacement(StringBuffer,String)和 appendTail(StringBuffer)

Matcher类还提供appendReplacementappendTail方法来替换文本。下面的示例RegexDemo.java使用这两种方法来实现与replaceAll相同的效果。

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

public class RegexDemo {
 
    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);
        Matcher m = p.matcher(INPUT); // get a matcher object
        StringBuffer sb = new StringBuffer();
        while(m.find()){
            m.appendReplacement(sb,REPLACE);
        }
        m.appendTail(sb);
        System.out.println(sb.toString());
    }
}
OUTPUT: -foo-foo-foo-

java.lang.String 中的 Matcher 方法等效项

为了方便起见,String类也模仿了Matcher个方法: