13518219792
网站建设资讯

NEWS

网站建设资讯

Java正则表达式中Pattern类与Matcher类有什么区别

本篇文章为大家展示了Java正则表达式中Pattern类与Matcher类有什么区别，内容简明扼要并且容易理解，绝对能使你眼前一亮，通过这篇文章的详细介绍希望你能有所收获。

创新互联网站建设公司是一家服务多年做网站建设策划设计制作的公司,为广大用户提供了成都网站制作、做网站、外贸营销网站建设，成都网站设计，一元广告，成都做网站选创新互联，贴合企业需求，高性价比，满足客户不同层次的需求一站式服务欢迎致电。

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;  

  1. import java.util.regex.Matcher;     
  2. import java.util.regex.Pattern;     
  3. /**     
  4.  * java中运用正则表达式的两个重要类:Pattern与Matcher     
  5.  * @author fhd001     
  6.  */     
  7. public class PatternAndMatcherTest {     
  8.      public static void main(String[] args) {     
  9.         /*     
  10.          * 常用的调用     
  11.          */     
  12.         Pattern p1 = Pattern.compile("a*b");     
  13.         String str1 = "aaaab";     
  14.         Matcher m1 = p1.matcher(str1);     
  15.         boolean b1 = m1.matches();     
  16.         System.out.println(b1);     
  17.              
  18.         String str2 = "b";     
  19.         Matcher m2 = p1.matcher(str2);     
  20.         boolean b2 = m2.matches();     
  21.         System.out.println(b2);     
  22.          /*     
  23.          * 另一种调用     
  24.          * 等效于上面的语句，尽管对于重复的匹配而言它效率不高，因为它不允许重用已编译的模式。      
  25.          * 但它可供多个并发线程安全使用,而上面的调用则就不是安全的.     
  26.          */     
  27.         boolean b3 = Pattern.matches("a*b", "aaab");     
  28.         System.out.println(b3);     
  29.              
  30.         //Pattern类的pattern方法:从pattern类的实例中返回匹配模式的字符串表示     
  31.         String pattern1 = p1.pattern();     
  32.         System.out.println(pattern1);     
  33.              
  34.         //Pattern类的split方法     
  35.         String[]arr1 = p1.split("rrrrraaabccccaaaaab");     
  36.         for (String string : arr1) {     
  37.             System.out.println(string+">>>>");     
  38.         }     
  39.         /*     
  40.          * Matcher类     
  41.          *      
  42.          * matches方法:       方法尝试将整个输入序列与该模式匹配     
  43.          * lookingAt方法: 尝试将输入序列从头开始与该模式匹配,与 matches 方法类似，     
  44.          *                  此方法始终从区域的开头开始；与之不同的是，它不需要匹配整个区域。      
  45.          * find方法:          方法扫描输入序列以查找与该模式匹配的下一个子序列     
  46.          */     
  47.         String str3 = "aabbcccaaaaaeeeaaaaaaaaagggga";     
  48.         Pattern p3 = Pattern.compile("a+");     
  49.         Matcher m3 = p3.matcher(str3);     
  50.         boolean bo4 = m3.matches();     
  51.         System.out.println("matches方法:  "+bo4);     
  52.         /*     
  53.          * lookingAt方法,从开头***个字符进行匹配,匹配成功了不再继续匹配,     
  54.          * 从***个字符开始,匹配失败了,也不继续匹配.不需要匹配整个序列     
  55.          */     
  56.         boolean bo5 = m3.lookingAt();     
  57.         if(bo5){     
  58.             //group方法(不带参数)返回的就是匹配的子字符串.     
  59.             System.out.println("lookingAt方法:  "+m3.group());     
  60.         }     
  61.      //find方法:找到一个匹配的子串,还会继续找下一个子串.     
  62.         while(m3.find()){     
  63.             System.out.println("find方法:  "+m3.group());     
  64.         }     
  65.     /*     
  66.          * 带参数的group方法与不带参数的group方法区别     
  67.          * 不带参数的group方法:find方法与lookingAt方法匹配出来的子序列(上面有演示)     
  68.          * 带参数的group方法: 返回在以前匹配操作期间由给定组捕获的输入子序列。     
  69.          */     
  70.         String str6 = "aaabbbccc";     
  71.         Pattern p5 = Pattern.compile("(a+)(b+)(c+)");     
  72.         Matcher m5 = p5.matcher(str6);     
  73.         boolean boo = m5.matches();     
  74.         if(boo){     
  75.             int k = m5.groupCount()+1;//加1就是把0下标的整个字符序列加上,它也作为一组放在0下标的位置.     
  76.             if(k>0){     
  77.                 for(int i=0;i                    System.out.println(m5.group(i));     
  78.                 }     
  79.             }     
  80.         }     
  81.     }     
  82. }    
  83.  
  84. package test;  
  85.  
  86. import java.util.regex.Matcher;  
  87. import java.util.regex.Pattern;  
  88.  
  89. /**  
  90.  * java中运用正则表达式的两个重要类:Pattern与Matcher  
  91.  * @author fhd001  
  92.  */  
  93. public class PatternAndMatcherTest {  
  94.  
  95.  public static void main(String[] args) {  
  96.     
  97.   /*  
  98.    * 常用的调用  
  99.    */  
  100.     
  101.   Pattern p1 = Pattern.compile("a*b");  
  102.     
  103.   String str1 = "aaaab";  
  104.   Matcher m1 = p1.matcher(str1);  
  105.   boolean b1 = m1.matches();  
  106.   System.out.println(b1);  
  107.     
  108.   String str2 = "b";  
  109.   Matcher m2 = p1.matcher(str2);  
  110.   boolean b2 = m2.matches();  
  111.   System.out.println(b2);  
  112.  /*  
  113.    * 另一种调用  
  114.    * 等效于上面的语句，尽管对于重复的匹配而言它效率不高，因为它不允许重用已编译的模式。   
  115.    * 但它可供多个并发线程安全使用,而上面的调用则就不是安全的.  
  116.    */  
  117.   boolean b3 = Pattern.matches("a*b", "aaab");  
  118.   System.out.println(b3);  
  119.     
  120.   //Pattern类的pattern方法:从pattern类的实例中返回匹配模式的字符串表示  
  121.   String pattern1 = p1.pattern();  
  122.   System.out.println(pattern1);  
  123.     
  124.   //Pattern类的split方法  
  125.   String[]arr1 = p1.split("rrrrraaabccccaaaaab");  
  126.   for (String string : arr1) {  
  127.    System.out.println(string+">>>>");  
  128.   }  
  129.   /*  
  130.    * Matcher类  
  131.    *   
  132.    * matches方法:  方法尝试将整个输入序列与该模式匹配  
  133.    * lookingAt方法: 尝试将输入序列从头开始与该模式匹配,与 matches 方法类似，  
  134.    *      此方法始终从区域的开头开始；与之不同的是，它不需要匹配整个区域。   
  135.    * find方法:   方法扫描输入序列以查找与该模式匹配的下一个子序列  
  136.    */  
  137.   String str3 = "aabbcccaaaaaeeeaaaaaaaaagggga";  
  138.   Pattern p3 = Pattern.compile("a+");  
  139.   Matcher m3 = p3.matcher(str3);  
  140.   boolean bo4 = m3.matches();  
  141.   System.out.println("matches方法:  "+bo4);  
  142.    /*  
  143.    * lookingAt方法,从开头***个字符进行匹配,匹配成功了不再继续匹配,  
  144.    * 从***个字符开始,匹配失败了,也不继续匹配.不需要匹配整个序列  
  145.    */  
  146.   boolean bo5 = m3.lookingAt();  
  147.   if(bo5){  
  148.    //group方法(不带参数)返回的就是匹配的子字符串.  
  149.    System.out.println("lookingAt方法:  "+m3.group());  
  150.   }  
  151.    //find方法:找到一个匹配的子串,还会继续找下一个子串.  
  152.   while(m3.find()){  
  153.    System.out.println("find方法:  "+m3.group());  
  154.   }  
  155.    /*  
  156.    * 带参数的group方法与不带参数的group方法区别  
  157.    * 不带参数的group方法:find方法与lookingAt方法匹配出来的子序列(上面有演示)  
  158.    * 带参数的group方法: 返回在以前匹配操作期间由给定组捕获的输入子序列。  
  159.    */  
  160.   String str6 = "aaabbbccc";  
  161.   Pattern p5 = Pattern.compile("(a+)(b+)(c+)");  
  162.   Matcher m5 = p5.matcher(str6);  
  163.   boolean boo = m5.matches();  
  164.   if(boo){  
  165.    int k = m5.groupCount()+1;//加1就是把0下标的整个字符序列加上,它也作为一组放在0下标的位置.  
  166.    if(k>0){  
  167.     for(int i=0;i     System.out.println(m5.group(i));  
  168.     }  
  169.    }  
  170.   }  
  171.  }  
  172. } 

结果代码

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

上述内容就是Java正则表达式中Pattern类与Matcher类有什么区别，你们学到知识或技能了吗？如果还想学到更多技能或者丰富自己的知识储备，欢迎关注创新互联行业资讯频道。


文章名称：Java正则表达式中Pattern类与Matcher类有什么区别
本文来源：http://cdweb.net/article/geoidp.html

其他资讯