java中正则表达式之Pattern类与Matcher类

===================================================================================================
Pattern类说明
---------------------------------------------------------------------------------------------------
指定为字符串的正则表达式必须首先被编译为pattern类的实例。然后，可将得到的模式用于创建 Matcher 对象，
依照正则表达式，该对象可以与任意字符序列匹配。执行匹配所涉及的所有状态都驻留在匹配器中，
所以多个匹配器可以共享同一模式。
因此，典型的调用顺序是
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     方法扫描输入序列以查找与该模式匹配的下一个子序列。 

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

测试代码

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

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<k;i++){System.out.println(m5.group(i));}}}}}

 

结果代码

1. true   
2. true   
3. true   
4. a*b   
5. rrrrr>>>>   
6. cccc>>>>   
7. matches方法:  false   
8. lookingAt方法:  aa   
9. find方法:  aaaaa   
10. find方法:  aaaaaaaaa   
11. find方法:  a   
12. aaabbbccc   
13. aaa   
14. bbb   
15. ccc