首页 > 代码库 > 正则表达式

正则表达式

 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 plaincopyprint?
  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 plaincopyprint?
  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 plaincopyprint?
  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. 输出:  

 

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

正则表达式