浅谈Java正则表达式中的Pattern类与Matcher类-51CTO.COM

Pattern类说明

指定为字符串的Java正则表达式必须首先被编译为pattern类的实例。然后，可将得到的模式用于创建 Matcher 对象，依照Java正则表达式，该对象可以与任意字符序列匹配。执行匹配所涉及的所有状态都驻留在匹配器中，所以多个匹配器可以共享同一模式。

因此，典型的调用顺序是

Pattern p = Pattern.compile("a*b");  
Matcher m = p.matcher("aaaaab");  
boolean b = m.matches();

在仅使用一次正则表达式时，可以方便地通过pattern类定义 matches 方法。此方法编译表达式并在单个
调用中将输入序列与其匹配。语句
boolean b = Pattern.matches("a*b", "aaaaab");

等效于上面的三个语句，尽管对于重复的匹配而言它效率不高，因为它不允许重用已编译的模式。
此类的实例是不可变的，可供多个并发线程安全使用。Matcher 类的实例用于此目的则不安全。

Matcher类说明

通过调用模式的 matcher 方法从模式创建匹配器。创建匹配器后，可以使用它执行三种不同的匹配操作：

1 matches 方法尝试将整个输入序列与该模式匹配。

(注:当调用String的matches()方法时,实际上是调用Pattern的静态方法matches().也就是相当于调Matcher的matches(),所以是整个输入序列与模式匹配.)

2 lookingAt 尝试将输入序列从头开始与该模式匹配。

3 find 方法扫描输入序列以查找与该模式匹配的下一个子序列。

此类的实例用于多个并发线程是不安全的。

测试代码

package test;

import java.util.regex.Matcher;     
import java.util.regex.Pattern;     
/**     
 * java中运用正则表达式的两个重要类:Pattern与Matcher     
 * @author fhd001     
 */     
public class PatternAndMatcherTest {     
     public static void main(String[] args) {     
        /*     
         * 常用的调用     
         */     
        Pattern p1 = Pattern.compile("a*b");     
        String str1 = "aaaab";     
        Matcher m1 = p1.matcher(str1);     
        boolean b1 = m1.matches();     
        System.out.println(b1);     
             
        String str2 = "b";     
        Matcher m2 = p1.matcher(str2);     
        boolean b2 = m2.matches();     
        System.out.println(b2);     
         /*     
         * 另一种调用     
         * 等效于上面的语句，尽管对于重复的匹配而言它效率不高，因为它不允许重用已编译的模式。      
         * 但它可供多个并发线程安全使用,而上面的调用则就不是安全的.     
         */     
        boolean b3 = Pattern.matches("a*b", "aaab");     
        System.out.println(b3);     
             
        //Pattern类的pattern方法:从pattern类的实例中返回匹配模式的字符串表示     
        String pattern1 = p1.pattern();     
        System.out.println(pattern1);     
             
        //Pattern类的split方法     
        String[]arr1 = p1.split("rrrrraaabccccaaaaab");     
        for (String string : arr1) {     
            System.out.println(string+">>>>");     
        }     
        /*     
         * Matcher类     
         *      
         * matches方法:       方法尝试将整个输入序列与该模式匹配     
         * lookingAt方法: 尝试将输入序列从头开始与该模式匹配,与 matches 方法类似，     
         *                  此方法始终从区域的开头开始；与之不同的是，它不需要匹配整个区域。      
         * find方法:          方法扫描输入序列以查找与该模式匹配的下一个子序列     
         */     
        String str3 = "aabbcccaaaaaeeeaaaaaaaaagggga";     
        Pattern p3 = Pattern.compile("a+");     
        Matcher m3 = p3.matcher(str3);     
        boolean bo4 = m3.matches();     
        System.out.println("matches方法:  "+bo4);     
        /*     
         * lookingAt方法,从开头***个字符进行匹配,匹配成功了不再继续匹配,     
         * 从***个字符开始,匹配失败了,也不继续匹配.不需要匹配整个序列     
         */     
        boolean bo5 = m3.lookingAt();     
        if(bo5){     
            //group方法(不带参数)返回的就是匹配的子字符串.     
            System.out.println("lookingAt方法:  "+m3.group());     
        }     
     //find方法:找到一个匹配的子串,还会继续找下一个子串.     
        while(m3.find()){     
            System.out.println("find方法:  "+m3.group());     
        }     
     /*     
         * 带参数的group方法与不带参数的group方法区别     
         * 不带参数的group方法:find方法与lookingAt方法匹配出来的子序列(上面有演示)     
         * 带参数的group方法: 返回在以前匹配操作期间由给定组捕获的输入子序列。     
         */     
        String str6 = "aaabbbccc";     
        Pattern p5 = Pattern.compile("(a+)(b+)(c+)");     
        Matcher m5 = p5.matcher(str6);     
        boolean boo = m5.matches();     
        if(boo){     
            int k = m5.groupCount()+1;//加1就是把0下标的整个字符序列加上,它也作为一组放在0下标的位置.     
            if(k>0){     
                for(int i=0;i                    System.out.println(m5.group(i));     
                }     
            }     
        }     
    }     
}    
 
package test;  
 
import java.util.regex.Matcher;  
import java.util.regex.Pattern;  
 
/**  
 * java中运用正则表达式的两个重要类:Pattern与Matcher  
 * @author fhd001  
 */  
public class PatternAndMatcherTest {  
 
 public static void main(String[] args) {  
    
  /*  
   * 常用的调用  
   */  
    
  Pattern p1 = Pattern.compile("a*b");  
    
  String str1 = "aaaab";  
  Matcher m1 = p1.matcher(str1);  
  boolean b1 = m1.matches();  
  System.out.println(b1);  
    
  String str2 = "b";  
  Matcher m2 = p1.matcher(str2);  
  boolean b2 = m2.matches();  
  System.out.println(b2);  
 /*  
   * 另一种调用  
   * 等效于上面的语句，尽管对于重复的匹配而言它效率不高，因为它不允许重用已编译的模式。   
   * 但它可供多个并发线程安全使用,而上面的调用则就不是安全的.  
   */  
  boolean b3 = Pattern.matches("a*b", "aaab");  
  System.out.println(b3);  
    
  //Pattern类的pattern方法:从pattern类的实例中返回匹配模式的字符串表示  
  String pattern1 = p1.pattern();  
  System.out.println(pattern1);  
    
  //Pattern类的split方法  
  String[]arr1 = p1.split("rrrrraaabccccaaaaab");  
  for (String string : arr1) {  
   System.out.println(string+">>>>");  
  }  
  /*  
   * Matcher类  
   *   
   * matches方法:  方法尝试将整个输入序列与该模式匹配  
   * lookingAt方法: 尝试将输入序列从头开始与该模式匹配,与 matches 方法类似，  
   *      此方法始终从区域的开头开始；与之不同的是，它不需要匹配整个区域。   
   * find方法:   方法扫描输入序列以查找与该模式匹配的下一个子序列  
   */  
  String str3 = "aabbcccaaaaaeeeaaaaaaaaagggga";  
  Pattern p3 = Pattern.compile("a+");  
  Matcher m3 = p3.matcher(str3);  
  boolean bo4 = m3.matches();  
  System.out.println("matches方法:  "+bo4);  
   /*  
   * lookingAt方法,从开头***个字符进行匹配,匹配成功了不再继续匹配,  
   * 从***个字符开始,匹配失败了,也不继续匹配.不需要匹配整个序列  
   */  
  boolean bo5 = m3.lookingAt();  
  if(bo5){  
   //group方法(不带参数)返回的就是匹配的子字符串.  
   System.out.println("lookingAt方法:  "+m3.group());  
  }  
   //find方法:找到一个匹配的子串,还会继续找下一个子串.  
  while(m3.find()){  
   System.out.println("find方法:  "+m3.group());  
  }  
   /*  
   * 带参数的group方法与不带参数的group方法区别  
   * 不带参数的group方法:find方法与lookingAt方法匹配出来的子序列(上面有演示)  
   * 带参数的group方法: 返回在以前匹配操作期间由给定组捕获的输入子序列。  
   */  
  String str6 = "aaabbbccc";  
  Pattern p5 = Pattern.compile("(a+)(b+)(c+)");  
  Matcher m5 = p5.matcher(str6);  
  boolean boo = m5.matches();  
  if(boo){  
   int k = m5.groupCount()+1;//加1就是把0下标的整个字符序列加上,它也作为一组放在0下标的位置.  
   if(k>0){  
    for(int i=0;i     System.out.println(m5.group(i));  
    }  
   }  
  }  
 }  
}

结果代码

true     
true     
true     
a*b     
rrrrr>>>>     
cccc>>>>     
matches方法:  false     
lookingAt方法:  aa     
find方法:  aaaaa     
find方法:  aaaaaaaaa     
find方法:  a     
aaabbbccc     
aaa     
bbb     
ccc

【编辑推荐】