zheze2

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

计算机等级考试   辅导课程   2009-06-25  【字体：大 中 小 】  JavaEye    我要评论( <script src="http://www.gzu521.com/e/public/ViewClick?classid=2915&amp;id=21053&amp;down=2" type="text/javascript"></script> 0 )

<script src="http://www.gzu521.com/d/js/acmsd/thea4.js"></script><script src="http://www.gzu521.com/recommend/gg_cms_contenttop.js"></script>

<script src="http://www.gzu521.com/d/js/acmsd/thea5.js"></script><script src="http://www.gzu521.com/recommend/gg_cms_content.js"></script><script type="text/javascript">&lt;!-- google_ad_client = &quot;pub-5138858050714057&quot;; google_ad_type = &quot;text_image&quot;; google_ad_width = 336; google_ad_height = 280; google_ad_format = &quot;336x280_as&quot;; google_ad_channel =&quot;3346635250&quot;; google_color_border = &quot;F7FDFF&quot;; google_color_bg = &quot;F7FDFF&quot;; google_color_link = &quot;000000&quot;; google_color_text = &quot;333333&quot;; google_color_url = &quot;222222&quot;; //--&gt;</script><script src="http://pagead2.googlesyndication.com/pagead/show_ads.js" type="text/javascript"> </script>

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