正则表达式第二篇

1、捕获组（Capture Group）

捕获组就是把正则表达式中子表达式匹配的内容，保存到内存中以数字编号或手动命名的组里，以供后面引用。

表达式

说明

(Expression)

普通捕获组，将子表达式Expression匹配的内容保存到以数字编号的组里

(?<name> Expression)

命名捕获组，将子表达式Expression匹配的内容保存到以name命名的组里

普通捕获组（在不产生歧义的情况下，简称捕获组）是以数字进行编号的，编号规则是以“(”从左到右出现的顺序，从1开始进行编号。通常情况下，编号为0的组表示整个表达式匹配的内容。

命名捕获组可以通过捕获组名，而不是序号对捕获内容进行引用，提供了更便捷的引用方式，不用关注捕获组的序号，也不用担心表达式部分变更会导致引用错误的捕获组。

 public static void group1()    {    Pattern p = Pattern.compile("\\d{3,5}[a-z]{2}");String s = "123aa-34345bb-234cc-00";Matcher m = p.matcher(s);while(m.find()) {System.out.print(m.group(0)+ " - "); /*整个表达式为第0组*/}    }        public static void group2()    {    //(\\d{3,5})第一组：([a-z]{2})：第二组    Pattern p = Pattern.compile("(\\d{3,5})([a-z]{2})"); String s = "123aa-34345bb-234cc-00";Matcher m = p.matcher(s);while(m.find()) {System.out.print(m.group(1) + " - ");//System.out.println(m.group(2));}    }

2、非捕获组

一些表达式中，不得不使用( )，但又不需要保存( )中子表达式匹配的内容，这时可以用非捕获组来抵消使用( )带来的副作用。

表达式

说明

(?:Expression)

进行子表达式Expression的匹配，并将匹配内容保存到最终的整个表达式的区配结果中，但Expression匹配的内容不单独保存到一个组内

3、反向引用

捕获组匹配的内容，可以在正则表达式的外部程序中进行引用，也可以在表达式中进行引用，表达式中引用的方式就是反向引用。

反向引用通常用来查找重复的子串，或是限定某一子串成对出现。

表达式

说明

\1，\2

对序号为1和2的捕获组的反向引用

\k<name>

对命名为name的捕获组的反向引用

举例：

“(a|b)\1”在匹配“abaa”时，匹配成功，匹配到的结果是“aa”。“(a|b)”在尝试匹配时，虽然既可以匹配“a”，也可以匹配“b”，但是在进行反向引用时，对应()中匹配的内容已经是固定的了。

4、环视（Look Around）

环视只进行子表达式的匹配，匹配内容不计入最终的匹配结果，是零宽度的。

环视按照方向划分有顺序和逆序两种，按照是否匹配有肯定和否定两种，组合起来就有四种环视。环视相当于对所在位置加了一个附加条件。

 

表达式

说明

(?<=Expression)

逆序肯定环视，表示所在位置左侧能够匹配Expression

(?<!Expression)

逆序否定环视，表示所在位置左侧不能匹配Expression

(?=Expression)

顺序肯定环视，表示所在位置右侧能够匹配Expression

(?!Expression)

顺序否定环视，表示所在位置右侧不能匹配Expression

举例：

“(?<=Windows )\d+”在匹配“Windows 2003”时，匹配成功，匹配结果为“2003”。我们知道“\d+”表示匹配一个以上的数字，而“(?<=Windows )”相当于一个附加条件，表示所在位置左侧必须为“Windows ”，它所匹配的内容并不计入匹配结果。同样的正则在匹配“Office 2003”时，匹配失败，因为这里任意一串数字子串的左侧都不是“Windows ”。

“(?!1)\d+”在匹配“123”时，匹配成功，匹配的结果为“23”。“\d+”匹配一个以上数字，但是附加条件“(?!1)”要求所在位置右侧不能是“1”，所以匹配成功的位置是“2”前面的位置。

5、忽略优先和匹配优先

或者叫做正则表达式匹配的贪婪与非贪婪模式。

标准量词修饰的子表达式，在可匹配可不匹配的情况下，总会先尝试进行匹配，称这种方式为匹配优先，或者贪婪模式。此前介绍的一些量词，“{m}”、“{m,n}”、“{m,}”、“?”、“*”和“+”都是匹配优先的。

一些NFA正则引擎支持忽略优先量词，也就是在标准量词后加一个“?”，此时，在可匹配可不匹配的情况下，总会先忽略匹配，只有在由忽略优先量词修饰的子表达式，必须进行匹配才能使整个表达式匹配成功时，才会进行匹配，称这种方式为忽略优先，或者非贪婪模式。忽略优先量词包括“{m}?”、“{m,n}?”、“{m,}?”、“??”、“*?”和“+?”。

举例：

源字符串：<div>aaa</div><div>bbb</div>

正则表达式1：<div>.*</div>      匹配结果：<div>aaa</div><div>bbb</div>

正则表达式2：<div>.*?</div>     匹配结果：<div>aaa</div>

/*常用这个*/public static void fun1()    {    Pattern p = Pattern.compile(".{3,10}[0-9]"); /*3到10个字符后面跟着一位数字:没有问号：一次吃10个字符发现不匹配于是吐出一个字符再去匹配......*/String s = "aaaa5bbbb6";Matcher m = p.matcher(s);if(m.find())System.out.println(m.start() + "-" + m.end());else System.out.println("not match!");    }/*勉强模式*/    public static void fun2()    {    Pattern p = Pattern.compile(".{3,10}?[0-9]"); /*第一次吃3个字符看符合不？此时第四个表示数子，因此不符合，再吃进一位：此时符合*/String s = "aaaa5bbbb68";Matcher m = p.matcher(s);if(m.find())System.out.println(m.start() + "-" + m.end());else System.out.println("not match!");    }        /*一般不用:占有模式*/    public static void fun3()    {    Pattern p = Pattern.compile(".{3,10}+[0-9]");/*一次吃10个字符并且不往外吐*/String s = "aaaa5bbbb6";Matcher m = p.matcher(s);if(m.find())System.out.println(m.start() + "-" + m.end());else System.out.println("not match!");    }        public static void fun4()    {    Pattern p = Pattern.compile(".{3}"); String s = "444a66b";Matcher m = p.matcher(s);while(m.find()) {System.out.println(m.group());}        }        public static void fun5()    {    Pattern p = Pattern.compile(".{3}(?=a)"); /*(?=a)：表示非捕获组(不捕获a)：表示结束的字符是a*/String s = "444a66b";Matcher m = p.matcher(s);while(m.find()) {System.out.println(m.group());}        }        public static void fun6()    {    Pattern p = Pattern.compile("(?=a).{3}"); /*(?=a)：表示非捕获组(不捕获a)：表示以a打头后面三个字符,包挂a*/String s = "444a66b";Matcher m = p.matcher(s);while(m.find()) {System.out.println(m.group());}        }    public static void fun7()    {    Pattern p = Pattern.compile(".{3}(?=!a)"); String s = "444a66b";Matcher m = p.matcher(s);while(m.find()) {System.out.println(m.group());}    }            public static void fun8()    {    Pattern p = Pattern.compile(".{3}(?<=a)"); /*从后往前数还包含a的*/String s = "444a66b";Matcher m = p.matcher(s);while(m.find()) {System.out.println(m.group());}    }        /*向前引用*/    public static void fun9()    {    Pattern p = Pattern.compile("(\\d\\d)\\1");/*1:表示后面找到的结果必须和前面找到的一模一样*/String s = "1212";Matcher m = p.matcher(s);System.out.println(m.matches());    }    /*向前引用*/    public static void fun10()    {    Pattern p = Pattern.compile("(\\d(\\d))\\2");/*(\\d(\\d)):这里是两个组：第二个组抓到的是2 后面的\\2:表示后面的要和第二个抓到数字一样*/String s = "122";Matcher m = p.matcher(s);System.out.println(m.matches());    }        public  static void fun11()    {    Pattern p = Pattern.compile("java", Pattern.CASE_INSENSITIVE);        System.out.println("Java".matches("(?i)(java)")); /*(?i)非捕获组:是上面的简写*/        }    public static void main(String[] args) { System.out.println("==================fun1();================================"); fun1(); System.out.println("==================fun2();================================"); fun2(); System.out.println("==================fun3();================================"); fun3(); System.out.println("==================fun4();================================"); fun4(); System.out.println("==================fun5();================================"); fun5(); System.out.println("==================fun6();================================"); fun6(); System.out.println("==================fun7();================================"); fun7(); System.out.println("==================fun8();================================"); fun8(); System.out.println("==================fun9();================================"); fun9(); System.out.println("==================fun10();================================"); fun10(); System.out.println("==================fun11();================================"); fun11();}