tinguo002

 

浅谈Java正则表达式中的Pattern类与Matcher类(转)

Pattern类说明

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

(转)http://developer.51cto.com/art/200906/131761.htm

因此,典型的调用顺序是

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

结果代码

  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

【编辑推



欢迎大家访问我的个人网站 萌萌的IT人

posted on 2013-04-11 17:44 一堣而安 阅读(332) 评论(0)  编辑  收藏 所属分类: java


只有注册用户登录后才能发表评论。


网站导航:
 

导航

统计

常用链接

留言簿(1)

随笔分类

随笔档案

收藏夹

搜索

最新评论

阅读排行榜

评论排行榜