温馨提示×

温馨提示×

您好,登录后才能下订单哦!

密码登录×
登录注册×
其他方式登录
点击 登录注册 即表示同意《亿速云用户服务条款》

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

发布时间:2021-07-01 16:31:35 来源:亿速云 阅读:273 作者:Leah 栏目:编程语言

本篇文章为大家展示了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.  }  


结果代码

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

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

向AI问一下细节

免责声明:本站发布的内容(图片、视频和文字)以原创、转载和分享为主,文章观点不代表本网站立场,如果涉及侵权请联系站长邮箱:is@yisu.com进行举报,并提供相关证据,一经查实,将立刻删除涉嫌侵权内容。

AI