关于Patter类和Match类

部分引用自: http://developer.51cto.com/art/200906/131761.htm

本文将介绍Java正则表达式中的Pattern类与Matcher类。首先我们要清楚指定为字符串的正则表达式必须首先被编译为pattern类的实例。因此如何更好的了解这两个类，是编程人员必须知道的。

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));
                 }
             }
         }
     }
 }

结果代码

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

>>>>>>>>>>>>>>>

PatternTest.java

 import java.io.BufferedReader;
 import java.io.FileInputStream;
 import java.io.FileOutputStream;
 import java.io.IOException;
 import java.io.InputStream;
 import java.io.InputStreamReader;
 import java.io.OutputStream;
 import java.util.regex.Matcher;
 import java.util.regex.Pattern;

 public class PatternTest {
     public static void main(String[] args) {
         try {
             replaceInFile("<name>.*</name>","C:\\project.xml","<name>BigDataDemo</name>");
         } catch (IOException e) {
             e.printStackTrace();
         }

     }
     public static void replaceInFile(String regex, String fileName, String replacement) throws IOException {
         InputStream in = new FileInputStream(fileName);
         StringBuffer buffer = new StringBuffer();
         try {
             Pattern p = Pattern.compile(regex);
             InputStreamReader inR = new InputStreamReader(in);
             BufferedReader buf = new BufferedReader(inR);
             String line;
             while ((line = buf.readLine()) != null) {
                 Matcher matcher = p.matcher(line);
                 if (matcher.find()) {
                     line = matcher.replaceAll(replacement);
                 }
                 buffer.append(line).append("\n"); //$NON-NLS-1$
             }
         } catch (IOException e) {
             //
         } finally {
             in.close();
         }

         OutputStream os = new FileOutputStream(fileName);
         os.write(buffer.toString().getBytes());
         os.close();
     }
 }

在C盘的更目录下有一个project.xml文件

一开始<name> *****</name>不是BigDataDemo

 <?xml version="1.0" encoding="UTF-8"?>
 <projectDescription>
     <name>BigDataDemo</name>
     <comment>
 To have ready-to-use Job Designs at your disposal, import the Demo Project include in Talend Open Studio.

 Simply follow the steps below:

     * Launch Talend Open Studio
     * In the login window, click on Demo
     * Choose Java or Perl Demo Project
     * Click on Finish to complete the operation
     * Choose the TALENDDEMOJAVA or TALENDDEMOPERL on the &quot;Existing&quot; list
     * Click on Ok</comment>
     <projects>
     </projects>
     <buildSpec>
     </buildSpec>
     <natures>
         <nature>org.talend.core.talendnature</nature>
     </natures>
 </projectDescription>