javaSE-(regex)

java正则表达式详解

正则表达式：

正则表达式定义了字符串的模式。

正则表达式可以用来搜索、编辑或处理文本。

正则表达式并不仅限于某一种语言，但是在每种语言中有细微的差别。

Java 正则表达式和 Perl的是最为相似的。

java.util.regex包主要包括以下三个类：

·        Pattern类：

pattern 对象是一个正则表达式的编译表示。Pattern类没有公共构造方法。要创建一个 Pattern对象，你必须首先调用其公共静态编译方法，它返回一个 Pattern对象。该方法接受一个正则表达式作为它的第一个参数。

·        Matcher类：

Matcher 对象是对输入字符串进行解释和匹配操作的引擎。与Pattern类一样，Matcher也没有公共构造方法。你需要调用 Pattern对象的 matcher方法来获得一个 Matcher对象。

·        PatternSyntaxException：

PatternSyntaxException 是一个非强制异常类，它表示一个正则表达式模式中的语法错误。

 

         定义一个比较规则，用该规则去匹配想要匹配的东西，返回结果。

创建方式：

 

[java]  view plain  copy

1. //创建正则对象  
2.                    //调用静态方法compile方法，传参正则语句  
3.                    String regex = "abcd";  
4.                    String text = "++abcdabcd++";  
5.                    Pattern pattern = Pattern.compile(regex);  
6.                    //matcher匹配器对象  
7.                     Matcher matcher = pattern.matcher(text);  

进行匹配功能方法：find()查找，group()返回本次查找到的内容

注意，当find查找返回false时，再去执行group方法，就不会返回String，而是直接报错，所以我们应该在执行group方法的时候进行一次判断。

 

[java]  view plain  copy

1. //进行匹配操作，返回匹配结果  
2.                  //第一次默认从头开始查找  
3.                  boolean bool= matcher.find();  
4.                  System.out.println(bool? "匹配成功" : "匹配失败");  
5.                  //查看匹配到的文本  
6.                  String result = matcher.group();  
7.                  System.out.println(result);  
8.                  //第二次从上一次查找位置开始查找  
9.                  bool=matcher.find();  
10.                  System.out.println(bool? "匹配成功" : "匹配失败");  
11.                  //获取匹配到的文本  
12.                   result = matcher.group();  
13.                  System.out.println(result);  
14.                  //第三次从上一次查找位置开始查找  
15.                  bool=matcher.find();  
16.                  System.out.println(bool? "匹配成功" : "匹配失败");  
17.                  //获取匹配到的文本，发现本次find查找失败，查看group返回结果，报错  
18.                   //result = matcher.group();  
19.                   //System.out.println(result);  
20.                  //改造一下，我们在执行该方法时，进行一次if判断  
21.                  if(bool){  
22.                           result= matcher.group();  
23.                           System.out.println(result);  
24.     }  

到目前为止，以上代码已经是查找到了末尾，如果我想再次从指定位置查找，可以执行find（int index）方法，从指定位置进行查找，则又能查找成功。

               

[java]  view plain  copy

1. <span style="white-space:pre">  </span>//从指定位置开始查找            
2.                bool=matcher.find(0);  
3.                //匹配成功  
4.                System.out.println("从指定位置开始匹配"+ (bool ? "匹配成功" : "匹配失败"));  
5.                result= matcher.group();  
6.                System.out.println(result);  

start()和end()方法

start():返回匹配到文本第一位所在的索引

end():返回匹配到的文本末尾之后一位的索引

   

[java]  view plain  copy

1. //执行匹配方法  
2. =matcher.find();  
3.           System.out.println("从指定位置开始匹配"+ (bool ? "匹配成功" : "匹配失败"));  
4.           result= matcher.group();  
5.           System.out.println(result);  
6.           //查看一下匹配到文本内容的开始位置  
7.           start= matcher.start();  
8.           System.out.println("匹配到的开始位置："+ start);  
9.           //查看一下匹配到的文本的结束位置后一位  
10.           end= matcher.end();  
11.           System.out.println("匹配到的结尾位置："+ end);  
12. At()方法：从被匹配文本开始进行匹配，如果开始不满足正则表达式，则返回false，满足返回true。  
13.           //从开始位置进行匹配:lookingAt()  
14.           regex= "abcd";  
15.           text= "sdasdfasdfasfdaabcdefg";  
16.           pattern= Pattern.compile(regex);  
17.           matcher= pattern.matcher(text);  
18.           bool= matcher.lookingAt();  
19.           //返回失败，因为text开头并不是abcd  
20.           System.out.println("从开始进行匹配"+ (bool ? "匹配成功" : "匹配失败"));       

        

全匹配模式matcher()对整个匹配的文本进行匹配，返回布尔值：

[java]  view plain  copy

1. <span style="white-space:pre">      </span>//正则表达式匹配整个字符串  
2.                    text= "abcd";  
3.                    matcher= pattern.matcher(text);  
4.                    bool= matcher.matches();  
5.                    System.out.println("全匹配" +(bool ? "匹配成功" : "匹配失败"));       
6.                    //返回创建匹配器对象的pattern对象  
7.                    Pattern pattern2 = matcher.pattern();  
8.                    //比较返回的pattern2是否与创建mathcer对象的pattern一致  
9.                    System.out.println((pattern== pattern2)?"与创建本matcher的对象是同一个对象":"其他对象");//true    

 

替换第一个匹配到的内容replaceFirst：

          

[java]  view plain  copy

1. <span style="white-space:pre">  </span> <span style="white-space:pre">  </span>    //替换第一个匹配到的文本replaceFirst  
2.                regex= "abcd";  
3.                text= "sabcdabcdg";  
4.                pattern= Pattern.compile(regex);  
5.                matcher= pattern.matcher(text);  
6.                String rfResult = matcher.replaceFirst("替换的文本");  
7.                System.out.println("替换后的文本:"+rfResult);  

Reset()重置匹配器matcher对象后，再次执行后，从开始进行匹配

           

[java]  view plain  copy

1. //重置匹配器,返回本身对象  
2.                   //执行到这一步，匹配的文本内容是：s替换的文本abcdg  
3.                   boolean boo = matcher.find();//true  
4.                   System.out.println("第一次查找"+boo);  
5.                   boo= matcher.find();//false  
6.                   System.out.println("第二次查找"+boo);  
7.                   Matcher restMatcher = matcher.reset();  
8.                   System.out.println("调用reset方法返回的对象其实就是本对象" + (restMatcher == matcher));  
9.                   boo= matcher.find();  
10.                   System.out.println("第三次查找"+boo);//true  
11.                   //查看匹配器的信息,没啥用  
12.                   System.out.println(matcher.toMatchResult());  
13.     appendReplacement()使用指定字符串替换文本中匹配到的内容，并返回最后匹配到的内容之前的内容。  
14.               //appendReplacement(StringBuffersb, String replacement) 从头开始查找并替换匹配到的内容，直到匹配到最后一位，并且将从头到该位的内容输入到sb中    
15.                   regex= "abcd";  
16.                   text= "+++++abcd+++++abcd++++";  
17.                   pattern= Pattern.compile(regex);  
18.                   matcher= pattern.matcher(text);  
19.                   String Buffersb = new StringBuffer();  
20.                   while(matcher.find()){  
21.                            matcher.appendReplacement(sb,"X");  
22.                   }  
23.                   System.out.println("从开始替换匹配文本到结束："+ sb);  

appendTail():我们发现，使用替换方法，后面的内容没了，那么就可以使用该方法，将之后的内容添加到sb缓冲区中。

              

[java]  view plain  copy

1. //appendTail将之前匹配到最后一次文本的之后内容加到sb中  
2.                 matcher.appendTail(sb);  
3.                 System.out.println("将之前匹配到最后一次的位置之后的文本也加入到sb中：" + sb);  

 

接下来看一下常用的正则语句是如何使用的：

下面表格是从网上抄的，表格之后附有我敲的代码供参考：

\	将下一字符标记为特殊字符、文本、反向引用或八进制转义符。例如，"n"匹配字符"n"。"\n"匹配换行符。序列"\\"匹配"\"，"\("匹配"("。
^	匹配输入字符串开始的位置。如果设置了 RegExp 对象的 Multiline 属性，^还会与"\n"或"\r"之后的位置匹配。
$	匹配输入字符串结尾的位置。如果设置了 RegExp 对象的 Multiline 属性，$还会与"\n"或"\r"之前的位置匹配。
*	零次或多次匹配前面的字符或子表达式。例如，zo*匹配"z"和"zoo"。*等效于 {0,}。
+	一次或多次匹配前面的字符或子表达式。例如，"zo+"与"zo"和"zoo"匹配，但与"z"不匹配。+等效于{1,}。
?	零次或一次匹配前面的字符或子表达式。例如，"do(es)?"匹配"do"或"does"中的"do"。?等效于{0,1}。
{n}	n 是非负整数。正好匹配 n 次。例如，"o{2}"与"Bob"中的"o"不匹配，但与"food"中的两个"o"匹配。
{n,}	n 是非负整数。至少匹配 n 次。例如，"o{2,}"不匹配"Bob"中的"o"，而匹配"foooood"中的所有o。"o{1,}"等效于"o+"。"o{0,}"等效于"o*"。
{n,m}	M 和 n 是非负整数，其中 n <= m。匹配至少 n 次，至多 m 次。例如，"o{1,3}"匹配"fooooood"中的头三个 o。'o{0,1}'等效于 'o?'。注意：您不能将空格插入逗号和数字之间。
?	当此字符紧随任何其他限定符（*、+、?、{n}、{n,}、{n,m}）之后时，匹配模式是"非贪心的"。"非贪心的"模式匹配搜索到的、尽可能短的字符串，而默认的"贪心的"模式匹配搜索到的、尽可能长的字符串。例如，在字符串"oooo"中，"o+?"只匹配单个"o"，而"o+"匹配所有"o"。
.	匹配除"\r\n"之外的任何单个字符。若要匹配包括"\r\n"在内的任意字符，请使用诸如"[\s\S]"之类的模式。
(pattern)	匹配 pattern 并捕获该匹配的子表达式。可以使用 $0…$9 属性从结果"匹配"集合中检索捕获的匹配。若要匹配括号字符 ( )，请使用"\("或者"\)"。
(?:pattern)	匹配 pattern 但不捕获该匹配的子表达式，即它是一个非捕获匹配，不存储供以后使用的匹配。这对于用"or"字符 (|) 组合模式部件的情况很有用。例如，'industr(?:y|ies)是比 'industry|industries'更经济的表达式。
(?=pattern)	执行正向预测先行搜索的子表达式，该表达式匹配处于匹配 pattern 的字符串的起始点的字符串。它是一个非捕获匹配，即不能捕获供以后使用的匹配。例如，'Windows (?=95|98|NT|2000)'匹配"Windows 2000"中的"Windows"，但不匹配"Windows 3.1"中的"Windows"。预测先行不占用字符，即发生匹配后，下一匹配的搜索紧随上一匹配之后，而不是在组成预测先行的字符后。
(?!pattern)	执行反向预测先行搜索的子表达式，该表达式匹配不处于匹配 pattern 的字符串的起始点的搜索字符串。它是一个非捕获匹配，即不能捕获供以后使用的匹配。例如，'Windows (?!95|98|NT|2000)'匹配"Windows 3.1"中的 "Windows"，但不匹配"Windows 2000"中的"Windows"。预测先行不占用字符，即发生匹配后，下一匹配的搜索紧随上一匹配之后，而不是在组成预测先行的字符后。
x|y	匹配 x 或 y。例如，'z|food'匹配"z"或"food"。'(z|f)ood'匹配"zood"或"food"。
[xyz]	字符集。匹配包含的任一字符。例如，"[abc]"匹配"plain"中的"a"。
[^xyz]	反向字符集。匹配未包含的任何字符。例如，"[^abc]"匹配"plain"中"p"，"l"，"i"，"n"。
[a-z]	字符范围。匹配指定范围内的任何字符。例如，"[a-z]"匹配"a"到"z"范围内的任何小写字母。
[^a-z]	反向范围字符。匹配不在指定的范围内的任何字符。例如，"[^a-z]"匹配任何不在"a"到"z"范围内的任何字符。
\b	匹配一个字边界，即字与空格间的位置。例如，"er\b"匹配"never"中的"er"，但不匹配"verb"中的"er"。
\B	非字边界匹配。"er\B"匹配"verb"中的"er"，但不匹配"never"中的"er"。
\cx	匹配 x 指示的控制字符。例如，\cM匹配 Control-M或回车符。x 的值必须在 A-Z或 a-z 之间。如果不是这样，则假定 c 就是"c"字符本身。
\d	数字字符匹配。等效于 [0-9]。
\D	非数字字符匹配。等效于 [^0-9]。
\f	换页符匹配。等效于 \x0c和 \cL。
\n	换行符匹配。等效于 \x0a和 \cJ。
\r	匹配一个回车符。等效于 \x0d和 \cM。
\s	匹配任何空白字符，包括空格、制表符、换页符等。与 [ \f\n\r\t\v]等效。
\S	匹配任何非空白字符。与 [^ \f\n\r\t\v]等效。
\t	制表符匹配。与 \x09和 \cI等效。
\v	垂直制表符匹配。与 \x0b和 \cK等效。
\w	匹配任何字类字符，包括下划线。与"[A-Za-z0-9_]"等效。
\W	与任何非单词字符匹配。与"[^A-Za-z0-9_]"等效。
\xn	匹配 n，此处的 n 是一个十六进制转义码。十六进制转义码必须正好是两位数长。例如，"\x41"匹配"A"。"\x041"与"\x04"&"1"等效。允许在正则表达式中使用 ASCII 代码。
\num	匹配 num，此处的 num 是一个正整数。到捕获匹配的反向引用。例如，"(.)\1"匹配两个连续的相同字符。
\n	标识一个八进制转义码或反向引用。如果 \n 前面至少有 n 个捕获子表达式，那么 n 是反向引用。否则，如果 n 是八进制数 (0-7)，那么 n 是八进制转义码。
\nm	标识一个八进制转义码或反向引用。如果 \nm 前面至少有 nm 个捕获子表达式，那么 nm 是反向引用。如果 \nm 前面至少有 n 个捕获，则 n 是反向引用，后面跟有字符 m。如果两种前面的情况都不存在，则 \nm 匹配八进制值 nm，其中 n和 m 是八进制数字 (0-7)。
\nml	当 n 是八进制数 (0-3)，m 和 l 是八进制数 (0-7) 时，匹配八进制转义码 nml。
\un	匹配 n，其中 n 是以四位十六进制数表示的 Unicode 字符。例如，\u00A9匹配版权符号 (©)。

       下面代码是我对上表的一个简单的练习：  

[java]  view plain  copy

1. import java.util.regex.MatchResult;  
2. import java.util.regex.Matcher;  
3. import java.util.regex.Pattern;  
4. class TestRegex2{  
5.          public static void main(String[] args){  
6.             
7.                    //匹配字符  
8.                    String regex = "abc";  
9.                    String text ="aaabcddfabcasf";  
10.                              
11.           
12.                    //[abc]匹配括号中一个成员  
13.                    String regex = "[abc]";  
14.                    String text ="afacsbdfa";  
15.           
16.                    //在中括号中代表非，除了该括号字符之外任意字符  
17.                    String regex = "[^abc]";  
18.                    String text ="a1f-acs+bd4Wfa";  
19.           
20.                    //取范围内字符[a-zA-Z][a-z][1-9]  
21.                    String regex = "[1-9a-e]";  
22.                    String text ="a1f-acs+bd4Wfa";  
23.                     
24.                    //并集  
25.                    String regex = "[a-c[f-l]]";  
26.                    String text ="a1f-acs+bd4fjklWfzzzxxa";  
27.           
28.                    //交集  取 a-f 和e-j 的交集 ef  
29.                    String regex = "[a-f&&[e-j]]";  
30.                    String text ="a1f-aeecs+bfd4fjfklWfffzzzxxa";  
31.           
32.                    //取a-z，不包含e-f字母  
33.                    //[^e-f]:除了e、f所有的字母、数字、符号  
34.                    String regex = "[a-z&&[^e-f]]";  
35.                    String text ="a1f-aeecs+bfd4fjfklWfffzzzxxa";  
36.                     
37.                    //.：任何字符  
38.                    String regex = ".";  
39.                    String text ="a1f-aeecs+bfd4fjfklWfffzzzxxa";  
40.                     
41.                    //\d：数字0-9 ；\w:a-zA-Z_0-9；\s:空白字符，3个字母的大写相当于取反  
42.                    String regex = "\\d";  
43.                    String text ="a1f-aeecs+bfd4fjfklWfffzzzxxa";  
44.    
45.                    //^：以之后的字符进行开始进行匹配，放在语句第一位  
46.                    //$:行的结尾,以前面字符做匹配  
47.                    String regex = "......a$";  
48.                    String text ="aaa-aaa";  
49.           
50.                    //匹配次数 ？：0或1次，+：1次及以上，*：0次及以上  
51.                    String regex = "a+";  
52.                    String text ="bbbb";  
53.                     
54.                    //{n}:代表前面字符出现n次，{n,}:n次及以上，{n,m}n~m次  
55.                    String regex = "[1-9]\\d{17}";  
56.                    String text ="112345678912345678";  
57.           
58.                    //验证QQ 5~10  
59.                    String regex = "[1-9]\\d{4,9}$";  
60.                    String text ="10086231231231231213231231";  
61.                     
62.                    //|:或者  
63.                    String regex = "abc|ABC|XXX";  
64.                    String text ="ABCabcadfXXXasABCdabcf";  
65.             
66.                    //验证身份证号  
67.                    String regex = "[1-9]\\d{17}|[1-9]\\d{14}";  
68.                    String text ="142212199812122222";  
69.                     
70.                    //验证QQ号  
71.                    String regex = "[1-9]\\d{4,9}";  
72.                    String text ="12345";  
73.           
74.                    //验证手机号  
75.                    String regex = "^1[3|5|7|8|9]\\d{9}";  
76.                    String text ="15666666661";  
77.           
78.                    //验证邮箱 邮箱名为6-20位,邮箱服务商域名2~10位，结尾只能匹配com，net，cn格式  
79.                    String regex = "^\\w{6,20}@\\w{2,10}\\.com|net|cn";  
80.                    String text ="155aaaqq@qq.com";  
81.                     
82.    
83.                    //验证网址http://www.开头，域名主体为1-10位a-zA-Z0-9字符，结尾只能是以.com cn net org xin结尾的网址  
84.                    String regex = "^http://w{3}\\.\\w{1,10}\\.com|cn|net|org|xin";  
85.                    String text ="http://www.sohu.com";  
86.                     
87.                    //验证账号：a-zA-Z0-9_$,必须以字母打头，6-16位  
88.                    String regex = "^\\w[\\w|_|$|\\d]{5,15}";  
89.                    String text ="httpww";  
90.                     
91.                    //验证生日 格式 1999-12-12,月份不能大于12，月份中的日期不能大于31  
92.                    String regex = "^[12]\\d{3}-[01]\\d-([12]\\d)|(3[01])";  
93.                    String text ="1991-12-32";  
94.                     
95.                     
96.                    //创建正则对象  
97.                    Pattern pattern = Pattern.compile(regex);  
98.                    Matcher matcher = pattern.matcher(text);  
99.                    System.out.println(matcher.matches()?"匹配成功":"匹配失败") ;  
100.                     
101.                    //输出匹配的内容  
102.                   while(matcher.find()){  
103.                             Stringresult = matcher.group();  
104.                             System.out.println(result);  
105.                    }  
106.                     
107.          }  
108. }  

匹配器对象Matcher的替换方法： 

 

[java]  view plain  copy

1. <span style="white-space:pre">      </span>//appendReplacement(StringBuffersb, String replacement) 从头开始查找并替换匹配到的内容，直到匹配到最后一位，并且将从头到该位的内容输入到sb中         
2.                    regex= "abcd";  
3.                    text= "+++++abcd+++++abcd++++";  
4.                    pattern= Pattern.compile(regex);  
5.                    matcher= pattern.matcher(text);  
6.                    StringBuffer sb = new StringBuffer();  
7.                    while(matcher.find()){  
8.                             matcher.appendReplacement(sb,"X");  
9.                    }  
10.                    System.out.println("从开始替换匹配文本到结束："+ sb);  
11.                    //appendTail将之前匹配到最后一次文本的之后内容加到sb中  
12.                    matcher.appendTail(sb);  
13.                    System.out.println("将之前匹配到最后一次的位置之后的文本也加入到sb中：" + sb);  

分组语句： 

[java]  view plain  copy

1.   //分组语句(),结合group方法，传参获取指定组的匹配内容  
2. /  
3. *如下正则语句，将会匹配text文本的前11位字符，是没有问题的  
4. *String regex = "至尊宝至尊小宝至尊大宝";  
5. /  
6. //但是，我现在加上括号以后，匹配的结果和没有加括号一样，都是前11位字符  
7. String regex = "(至尊宝)(至尊小宝)(至尊大宝)";  
8. String text ="至尊宝至尊小宝至尊大宝秦祥林秦汉至尊玉";  
9.         Pattern pattern = Pattern.compile(regex);  
10.                   Matcher matcher = pattern.matcher(text);  
11.                   if(matcher.find ()){  
12.                            Stringgroup = matcher.group();  
13.                            System.out.println(group);  
14.                             
15.                   }  

那么，区别在哪儿？既然是分组语句，那么我们可以从匹配器的group方法中看到区别，在api中，group是可以传参的，传参int类型，当传入x数值时，那么返回的将会是正则语句中第x个括号中的匹配内容，当传入0时，返回整个匹配到的语句，如下案例： 

[java]  view plain  copy

1. //我现在加上括号以后，匹配的结果和没有加括号一样，都是前11位字符  
2. String regex = "(至尊宝)(至尊小宝)(至尊大宝)";  
3. String text ="至尊宝至尊小宝至尊大宝秦祥林秦汉至尊玉";  
4.         Pattern pattern = Pattern.compile(regex);  
5.                   Matcher matcher = pattern.matcher(text);  
6.                   if(matcher.find ()){  
7.                            //打印结果为至尊宝  
8.                            //String group = matcher.group(1);  
9.                            //System.out.println(group);  
10.   
11.                            //打印结果为至尊小宝  
12.                            String group = matcher.group(2);  
13.                            System.out.println(group);  
14.                             
15.   
16.                            //打印结果为：至尊宝至尊小宝至尊大宝  
17.                            String group = matcher.group(0);  
18.                            System.out.println(group);  
19.                             
20.                   }  

注意：如果group传入的参数的分组序号并不存在，如正则语句只分了2个组，但是group语句访第3个子语句，就会报错！

 其实分组语句还有一个好处，就是给语句进行分组，达到优先级匹配的效果，如下是我写的一个正则语句匹配身份证号，当然并不是那么完美，但是可以看出，下面的分组语句也起到了优先级的效果：

String regex = "^[1-9]\\d{5}(19[0-9]{2}|200[0-9]|201[0-7])(0[0-9]|1[0-2])([012][0-9]|3[01])\\d{3}[0-9|X]";
String text ="35123429800231112X";

预测语句：

[java]  view plain  copy

1. //(?:)向后匹配并将其作为捕获的内容  
2.         //语法解析：至尊后面只要有大宝、玉、小宝3个成员中的一个，就可以匹配成功，并且将括号中的成员也作为匹配到的内容，如下案例，匹配到的内容就是至尊大宝、至尊玉、至尊小宝：  
3.         String regex = "至尊(?:大宝|玉|小宝)";  
4.         String text ="至尊宝至尊小宝至尊大宝秦祥林秦汉至尊玉";  
5.         Pattern pattern = Pattern.compile(regex);  
6.                   Matcher matcher = pattern.matcher(text);  
7.                   if(matcher.find()){  
8.                            String group = matcher.group();  
9.                            System.out.println(group);  
10.                             
11.                   }  
12.         //(?=)向后匹配，预测语句其后包含括号中内容,但不捕获  
13.         //语法解析，至尊后面只要有大宝、玉、小宝三个成员中的一个，就会匹配成功，但是匹配结果并不会包含这三个成员，也就是说，该语句的匹配到的内容是:至尊、至尊、至尊  
14.         String regex = "至尊(?=大宝|玉|小宝)";  
15.         String text ="至尊宝至尊小宝至尊大宝秦祥林秦汉至尊玉";  
16.         Pattern pattern = Pattern.compile(regex);  
17.                   Matchermatcher = pattern.matcher(text);  
18.                   if(matcher.find()){  
19.                            String group = matcher.group();  
20.                            System.out.println(group);  
21.                             
22.                   }  
23.         //(?!)向后匹配，预测语句之后不包含括号内容,但不捕获  
24.         //语法解析：至尊后面只要不包含大宝、玉、小宝的字样，就可以匹配成功，如下案例匹配到的内容是：至尊宝，但是括号中的不包含的内容“宝”字也不会被捕获，即他的功能只是预测一下至尊后面是不是不包含某些字眼，并不会将该字眼之外的内容捕获放到匹配到的内容当中，所以如下结果打印为：至尊  
25.         String regex = "至尊(?!大宝|玉|小宝)";         
26.         String text ="至尊宝至尊小宝至尊大宝秦祥林秦汉至尊玉";  
27.         Pattern pattern = Pattern.compile(regex);  
28.         Matcher matcher = pattern.matcher(text);  
29.         if(matcher.find()){  
30.                   Stringgroup = matcher.group();  
31.                   System.out.println(group);       
32.         }