贪婪模式

*和+这两个限定符都可以标识匹配多个元素，在默认情况下它们会尽可能多的匹配文字，这就是所谓的“贪婪模式”

示例代码

###  测试代码
 @Test
    public void test() throws IOException {
        String str = "<xml>helloworld<xml>";
        String regex = "<.*>";

        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(str);

        while (matcher.find()) {
            System.out.println(matcher.group());
        }
    }

###输出结果

<xml>helloworld<xml>

Process finished with exit code 0

注意观察上述代码，按照匹配规则，"<.>"表示匹配以‘<’开头，‘>’结尾，中间有任意个字符的字符串。那么很明显第一个<xml>和最后一个</xml>也是满足匹配规则的，但是结果只输出了整个字符串。这就是限定符的贪婪模式，会尽可能多的匹配字符，也就是说它匹配了“xml>helloworld<xml”这一整串内容。

怎么消除这种现象让它能匹配到第一个满足条件的“<xml>”和最后一个“</xml>”呢？

示例代码

    @Test
    public void test() throws IOException {
        String str = "<xml>helloworld<xml>";
        String regex = "<.*?>";

        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(str);

        while (matcher.find()) {
            System.out.println(matcher.group());
        }
    }

### 输出结果
<xml>
<xml>

Process finished with exit code 0
    

将匹配的字符串从"<.>" 变更为 "<.?>"，也就是在限定符后面加“？”即可消除贪婪模式

分组即“()”在正则表达式中的作用

使限定符可以作用于成对的匹配规则

  @Test
    public void test() throws IOException {
        String str = "abcabcabc";
        String regex = "(abc){3}";

        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(str);

        while (matcher.find()) {
            System.out.println(matcher.group());
        }
    }
    
### 输出结果
abcabcabc

Process finished with exit code 0

可以看到，通过"()"将“abc”字符包裹之后，限定符"{3}"的修饰内容变成了“abc”整体出现三次，于是成功匹配了我们的目标字符串“abcabcabc”.

检索字符串

所谓检索字符串，可以理解为提取目标字符串，例如：对于字符串“<xml>helloworld<xml>”,通过检索可以提取出<xml></xml>标签的内容“helloworld”。

在理解检索之前，顺带提一下java中matcher类,我们常用的方法有2个

matcher.matches();
matcher.find();  

他们之间的区别在于：

matches()方法意为匹配，即目标字符串“整体”与我们的“正则表达式”进行匹配，返回结果是true或者false，这种情况通常用在例如：邮箱，电话号码等场景，用来检查输入的正确与否。

find()方法意为查找，也就是说它并不强调整体匹配是否正确，只是按照我们的“正则表达式”规则到目标字符串中查找是否有相匹配的字符串，其实就是部分匹配的意思。

示例代码

 @Test
    public void test() throws IOException {
        String str = "helloworld";
        String regex = "hello";

        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(str);

         System.out.print(matcher.matches());
//        while (matcher.find()) {
//            System.out.println(matcher.group());
//        }
    }
    
### 输出结果 false  这是因为"hello"字符串与"helloworld"是不相匹配的

上述代码更改为

 @Test
    public void test() throws IOException {
        String str = "helloworld";
        String regex = "hello";

        Pattern pattern = Pattern.compile(regex);
        Matcher matcher = pattern.matcher(str);

//        System.out.print(matcher.matches());
        while (matcher.find()) {
            System.out.println(matcher.group());
        }
    }
    
### 输出结果 hello
这是因为在目标字符串"helloworld"中找到了与我们的匹配规则相符的字符串"hello"

find()方法的匹配是从左到右的，也就是说如果字符串中有多个满足表达式的子字符串，通过多次find可以全部找出。示例代码:

 @Test
    public void test2() throws IOException {
        String str = "helloworldhello";
        String regex = "hello";

        Matcher matcher = Pattern.compile(regex).matcher(str);
        //必须先调用matcher.find()，这样才会将匹配的结果放到group中
        int n = 0;
        while (matcher.find()) {
            System.out.println(n++);
            int count = matcher.groupCount();
            for (int i = 0; i <= count; i++) {
                System.out.println("matcher.group(" + i + "): " + matcher.group(i));
            }
        }
    }
    
###输出结果
0
matcher.group(0): hello
1
matcher.group(0): hello
    

以上代码第一次find找到了第一个hello，第二次find找到了world后面的hello

看完上述代码再来讲下如何使用"()"的检索功能

示例代码

@Test
    public void test() throws IOException {
        String str = "<xml>helloworld</xml>";
        String regex = "<xml>([a-z]*)</xml>";

        Matcher matcher = Pattern.compile(regex).matcher(str);
        //必须先调用matcher.find()，这样才会将匹配的结果放到group中
        if (matcher.find()) {
            int count = matcher.groupCount();
            for (int i = 0; i <= count; i++) {
                System.out.println("matcher.group(" + i + "): " + matcher.group(i));
            }
        }
    }
    
###输出结果

matcher.group(0): <xml>helloworld</xml>
matcher.group(1): helloworld
    

上面代码，通过给中间匹配加"([a-z])",matcher类会将这个分组的匹配结果放到group(1)，称为捕获组1，通过matcher.group(1)即可以检索出标签内容"helloworld"。 记住group(0)永远是整个"正则表达式"的匹配结果，即捕获组0。在这个示例中，group(0)是"<xml>([a-z])</xml>"整串表达式的匹配结果。捕获组在group(几)取决于“()”在整个表达式中从左到右，从外到里的顺序(这个可以自行验证)

后向引用

在检索功能中我们知道了捕获组的概念，正则表达式后面的子表达式可以使用前面的捕获组，示例代码：

 @Test
    public void test() throws IOException {
        String str = "<xml>helloworld</xml>";
        
        
        //“\\1”(实际上是“\1”，第一个\是转义符号)用来引用捕获组1
        String regex = "<(xml)>.*</\\1>";

        Matcher matcher = Pattern.compile(regex).matcher(str);
        //必须先调用matcher.find()，这样才会将匹配的结果放到group中
        if (matcher.find()) {
            int count = matcher.groupCount();
            for (int i = 0; i <= count; i++) {
                System.out.println("matcher.group(" + i + "): " + matcher.group(i));
            }
        }
    }
    
    
### 输出结果

matcher.group(0): <xml>helloworld</xml>
matcher.group(1): xml

从上面代码应该很清楚 在正则表达式中可以通过"\i"的形式来引用捕获组i 的内容 即“xml“字符串。

注意事项:

1.这里为什么叫后向引用呢，这是因为“\i”所引用的捕获组i必须是在它前面所定义的，如果将上述表达式改为的"<\1>.*</xml>"，就匹配不到了。

2.后向引用所引用的是"内容",而非"表达式"。示例代码：

将上面例子中的代码改为:
 @Test
    public void test() throws IOException {
        String str = "<xml>helloworld</html>";
        String regex = "<([a-z]{3})>.*</\\1>";

        Matcher matcher = Pattern.compile(regex).matcher(str);
        //必须先调用matcher.find()，这样才会将匹配的结果放到group中
        if (matcher.find()) {
            int count = matcher.groupCount();
            System.out.println(count);
            for (int i = 0; i <= count; i++) {
                System.out.println("matcher.group(" + i + "): " + matcher.group(i));
            }
        }
    }

### 输出结果是空的

### 这是因为在匹配的过程中，“([a-z]{3})”首先匹配到了“xml”，于是后面“\\1”就变成了“xml”，于是整个表达式其实变成了 "<([a-z]{3})>.*</xml>"，这显然是无法匹配到"<xml>helloworld</html>"，所以整个表达式没有匹配结果。
    

断言

断言的概念比较模糊，我的理解是断言是特殊的限定符，用来对它所修饰的表达式添加匹配条件。示例代码：

 @Test
    public void test() throws IOException {
        String str = "hello2017";
        //“X1(?=X2)” 这是断言的一种写法，表示表达式X1匹配成功的前提是它后面有能够匹配表达式X2的内容。
        String regex = "hello(?=2017)";

        Matcher matcher = Pattern.compile(regex).matcher(str);
        //必须先调用matcher.find()，这样才会将匹配的结果放到group中
        if (matcher.find()) {
            int count = matcher.groupCount();
            for (int i = 0; i <= count; i++) {
                System.out.println("matcher.group(" + i + "): " + matcher.group(i));
            }
        }
    }
    
### 输出
matcher.group(0): hello

Process finished with exit code 0

我们前面说过group(0)是整个表达式匹配的结果，但这里为什么不是hello2017而只输出了hello呢? 断言有点类似限定符，并不是匹配元素，所以整个表达式其实就是"hello"，而断言给这个表达式匹配增加了条件。在这个例子中，hello所匹配成功的条件必须是后面跟着2017的hello，也就是只能是hello2017中的hello。将上述str改成"hello2018"，虽然hello字符串依然能够配对hello，但是它后面跟的不是2017，不满足断言条件，因而匹配结果为空。

1.断言是不消耗字符的，在上面的例子中，虽然2017参与了"hello(?=2017)"这个表达式的运算，但它并没有被消耗，仍旧可以被后面的表达式所匹配。示例代码：

 @Test
    public void test() throws IOException {
        String str = "hello2017";
        String regex = "hello(?=2017)2";

        Matcher matcher = Pattern.compile(regex).matcher(str);
        //必须先调用matcher.find()，这样才会将匹配的结果放到group中
        if (matcher.find()) {
            int count = matcher.groupCount();
            for (int i = 0; i <= count; i++) {
                System.out.println("matcher.group(" + i + "): " + matcher.group(i));
            }
        }
    }
    
###输出结果
matcher.group(0): hello2

从这个结果可以看出，2017虽然参与了"hello"字符串的匹配，但是并没有被消耗掉，依然可以在后面的表达式"2"中使用，于是输出结果是hello2

2.断言不是捕获组，前面所述的"()"的使用中说过"()"的内容会被放入捕获组，那么代码中怎么区分是捕获组还是断言呢？其实就是?的作用，形如"(?=X)"由于加入了一个"?"，因此代码执行时知道这是一个断言，不需要放入捕获组。

断言分为4种：