黑马程序员 Java 正则表达式中的数量词

----------------------ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------

java中的正则位于java.util.regex包中，这个包中只有一个MatchResult接口和Matcher、Pattern两个类。

   正则中的数量词有Greedy (贪婪)、Reluctant(懒惰)和Possessive(强占)三种

  

Greedy(贪婪)  数量词
X?	X，一次或一次也没有
X*	X，零次或多次
X+	X，一次或多次
X{n}	X，恰好 n 次
X{n,}	X，至少 n 次
X{n,m}	X，至少 n 次，但是不超过 m 次

Greedy是最常用的，它的匹配方式是先把整个字符串吞下，然后匹配整个字符串，如果不匹配，就从右端吐出一个字符，再进行匹配，直到找到匹配或把整个字符串吐完为止。

[java] view plain copy print ?

1. Matcher m=Pattern.compile("a.*b")  
2.               .matcher("a====b=========b=====");  
3. while(m.find()){  
4.       System.out.println(m.group());  
5.         }  
6.   
7.   
8. 输出：  
9. a====b=========b  

因为总是从最大 匹配开始匹配，故称贪婪。

 

Reluctant (懒惰)  数量词
X??	X，一次或一次也没有
X*?	X，零次或多次
X+?	X，一次或多次
X{n}?	X，恰好 n 次
X{n,}?	X，至少 n 次
X{n,m}?	X，至少 n 次，但是不超过 m 次

Reluctant正好和Greedy相反，它先从最小匹配开始，先从左端吞入一个字符，然后进行匹配，若不匹配就再吞入一个字符，直到找到匹配或将整个字符串吞入为止。

[java] view plain copy print ?

1. Matcher m=Pattern.compile("a.*?b")  
2.                   .matcher("a====b=========b=====");  
3. while(m.find()){  
4.         System.out.println(m.group());  
5.         }  
6.   
7. 输出：  
8. a====b  

 因为总是从最小匹配开始，故称懒惰。

Possessive (强占)  数量词
X?+	X，一次或一次也没有
X*+	X，零次或多次
X++	X，一次或多次
X{n}+	X，恰好 n 次
X{n,}+	X，至少 n 次
X{n,m}+	X，至少 n 次，但是不超过 m 次

Possessive和Greedy的匹配方式一样，先把整个字符串吞下，然后匹配整个字符串，如果匹配，就认为匹配，如果不匹配，就认为整个字符串不匹配，它不会从右端吐出一个字符串再进行匹配，只进行一次

[java] view plain copy print ?

1. Matcher m=Pattern.compile("a.*+b")  
2.                    .matcher("a====b=========b=====");  
3. while(m.find()){  
4.     System.out.println(m.group());  
5.         }  
6.   
7. 输出：  

因为贪婪但并不聪明，故称强占。 

----------------------ASP.Net+Android+IOS开发、.Net培训、期待与您交流！ ----------------------