【Java】正则表达式 Pattern Matcher

Pattern：

生成一个正则表达式的模板，一般而言，不会用到Pattern的其他方法。步骤：

1.首先调用其静态方法compile，生成一个正则表达式的模板；

2.调用生成的Pattern实例的matcher方法，获得一个Matcher类型的实例；

Matcher：

是一个有状态的类，正则匹配的过程都是在这个类里完成的。为什么是有状态的呢？要进行正则匹配，我们需要调用其匹配的方法，有些匹配方式比如子串匹配，可能有多个结果，需要我们多次调用才能获得结果，可以理解为迭代器的流程，需要一步一步通知Matcher返回匹配结果，而不是一次性返回所有匹配结果，这个流程需要理解清楚。

matcher实例有三个匹配方法：

1.matches：将输入字符串作为一个整体进行匹配。再强调一遍是”整体“。怎么理解？可以理解为原来的模板自带^$符号。举个例子：

pattern = "[a-z]+"

s = "1abc2"，

使用matches方法匹配s，会返回false。因为s是以数字开头的，而模板要求全部是小写字母，所以匹配失败，即便s的子串”abc“是满足的。

2.lookingAt：从输入字符串的起始位置进行匹配。可以理解为原来的模板自带^符号。举个例子：

pattern仍然是之前的例子，s变为"abc123"，是可以匹配成功的，但是如果s是”1abc123“，就会匹配失败。

3.match：匹配输入字符串中所有满足模板要求的子串。仍然是上面的例子，s是”1acb2“，也能匹配到，因为s的子串”abc“满足模板要求。

另外，matches和lookingAt方法只能调用一次，多次调用效果一样，而match方法每一次调用返回一个结果。

好了，一旦我们调用上面的三个方法中的任意一个匹配到结果，我们可以使用下面介绍下Matcher类的其他方法来获取匹配结果，记住必须要先调用上面的方法，才能使用这些方法，因为Matcher是有状态的！：

1.start：匹配结果的起始位置

2.end：匹配结果的结束位置+1

3.group：匹配的结果

另外如果模板是分组的，可以调用groupCount方法获取捕获组的数目，再依次调用group(index)获取每一个捕获组的内容。

 

例子：

public class RegTest {

    private final String patternStr = "[a-z]+";
    private final Pattern pattern = Pattern.compile(patternStr);

    @Test
    public void testMatches1() {
        String s = "1a4";
        Matcher matcher = pattern.matcher(s);
        if (matcher.matches()) {
            System.out.println("start :" + matcher.start());
            System.out.println("end :" + matcher.end());
            System.out.println("content: " + matcher.group());
        }
//        匹配不到，无输出
    }

    @Test
    public void testMatches2() {
        String s = "abc";
        Matcher matcher = pattern.matcher(s);
        if (matcher.matches()) {
            System.out.println("start :" + matcher.start());
            System.out.println("end :" + matcher.end());
            System.out.println("content: " + matcher.group());
        }
//        start :0
//        end :3
//        content: abc
    }

    @Test
    public void testLookingAt1() {
        String s = "1abc";
        Matcher matcher = pattern.matcher(s);
        if (matcher.lookingAt()) {
            System.out.println("start :" + matcher.start());
            System.out.println("end :" + matcher.end());
            System.out.println("content: " + matcher.group());
        }
//        匹配不到，无输出
    }

    @Test
    public void testLookingAt2() {
        String s = "abc123";
        Matcher matcher = pattern.matcher(s);
        if (matcher.lookingAt()) {
            System.out.println("start :" + matcher.start()); // 如果匹配到，肯定是0
            System.out.println("end :" + matcher.end());
            System.out.println("content: " + matcher.group());
        }
    }
//    start :0
//    end :3
//    content: abc

    @Test
    public void testMatch1() {
        String s = "1abc2";
        Matcher matcher = pattern.matcher(s);
        while (matcher.find()) {
            System.out.println("start :" + matcher.start());
            System.out.println("end :" + matcher.end());
            System.out.println("content: " + matcher.group());
        }
//        start :1
//        end :4
//        content: abc
    }
}

 

除此之外，还可以调用Matcher类的下列方法做正则替换
replaceFirst：替换匹配到的第一个子串
replaceAll：替换匹配到的所有子串
这个还是很有用的，举个例子，要将输入串匹配到的子串过滤掉，可以replaceAll("")即可。

    @Test
    public void testReplace1() {
        String s = "1abc2abc3";
        Matcher matcher = pattern.matcher(s);
        String r1 = matcher.replaceFirst("###");
        System.out.println(r1);
        String r2 = matcher.replaceAll("###");
        System.out.println(r2);
    }
//    1###2abc3
//    1###2###3

 

最后看几个相同功能的方法：
String类里的replaceFirst和replaceAll和Matcher里的一样，底层就是调用的Matcher里的这俩方法：

    @Test
    public void testReplace2() {
        String s = "1abc2abc3";
        System.out.println(s.replaceFirst(patternStr, "###"));
        System.out.println(s.replaceAll(patternStr, "###"));
    }
//    1###2abc3
//    1###2###3

String类的matches和Pattern里的matches以及Matcher里的matches都是一样的，前两个方法底层调用的是Matcher里的matches方法：

    @Test
    public void test1() {
        String s = "abc";
        System.out.println(s.matches(patternStr));
        System.out.println(Pattern.matches(patternStr, s));

        Matcher matcher = pattern.matcher(s);
        System.out.println(matcher.matches());
    }